精华内容
下载资源
问答
  • 冒泡排序--数组的简单排序,从大到小,从小到大

    千次阅读 多人点赞 2019-11-20 18:03:33
    冒泡排序 是计算机程序中较为常见和简单的排序算法,它需要重复地走访需要进行排序的元素列,按照一定顺序依次比较两个相邻的元素,如果顺序错误就把他们交换过来。 示意原图如下: 我们需要的结果示意图如下: 那...

    冒泡排序 是计算机程序中较为常见和简单的排序算法,它需要重复地走访需要进行排序的元素列,按照一定顺序依次比较两个相邻的元素,如果顺序错误就把他们交换过来。
    示意原图如下:
    在这里插入图片描述
    我们需要的结果示意图如下:
    在这里插入图片描述
    那我们应该怎么进行程序的编写才能满足这样的结果呢?
    你首先会想到用什么方法来进行排序呢?

    此刻。你想想,在军训时候,同排队列中是怎么行按照身高高低来进行站队的?是不是每个人和自己相邻的下一位进行比较?冒泡排序就是利用这种方法,只不过军训站队是可以队列中各个相邻的两个人在同时比较,而冒泡排序一般选择从第一位开始,依次进行比较和排序。

    **注意:**以数值从小到大排序为例:是第一位和第二位比较,如果第一位的值 > 第二位的值,则交换,如果不大于,则不交换,这个时候需要比较的位次增加 1,各数值并不变化,第二位和第三位比较,如果第二位的值 > 第三位的值 ,则第二位和第三位交换,如果不大于,则不交换,不管比较与否,需要比较的位次都需要自增 1 ,依次类推直到比较完所有元素(遍历完整个都没有发生交换则证明最后一位的值就是最大的)。

    比如对下面这个序列进行从小到大排序:
    100 40 130 10 60

    第一轮
    1)100 和 40比,100>40,则它们互换位置
    40 100 130 10 60 (第一次发生交换,继续比较)

    2)100 和 130 比,100<130,则不用交换位置
    没有发生交换,则需要比较的位数增加 1 ,但各位的值并不交换。
    依然是:40 100 130 10 60

    3)130 和 10 比,130>10,则它们互换位置
    40 100 10 130 60 (第二次发生交换,实际上是第三次比较(第二次没有交换),继续比较)

    4)130 和 60 比,130>60,则它们互换位置
    40 100 10 60 130

    到此第一轮就比较完了第一轮的结果是找到了序列中最大的那个数,并浮到了最右边

    比较时,每轮中第 n 次比较是新序列中第 n 个元素和第 n+1 个元素的比较(假如 n 从 1 开始)。

    第二轮
    第一轮比较完状态:40 100 10 60 130

    1. 40 和 100 比,40<100,则不用交换位置。
      40 100 10 60 130

    2. 100 和 10 比,100>10,则它们互换位置:
      40 10 100 60 130

    3. 100 和 60 比,100>60,则它们互换位置:
      40 10 60 100 132(此刻注意:最后一位不再比较,因为已经第一轮已经比较过了

    到此第二轮就比较完了第二轮的结果是找到了序列中第二大的那个数,并浮到了最右边第二个位置

    第三轮
    第三轮初始状态:40 10 60 100 130
    1) 40和 10 比,40>10,则它们互换位置:
    10 40 60 100 130

    2)40 和 60 比,40 < 60,则不用交换位置。
    10 40 60 100 130 (保留上一次比较)(同时,60和100不再比较,因为在第二轮中已经比较过,并输出100为第二轮最大数,整个数组倒数第二大,输出在倒数第二位)

    到此第三轮就比较完了第三轮的结果是找到了序列中第三大的那个数,并浮到了最右边第三个位置

    第四轮
    第四轮初始状态:10 40 60 100 130

    1. 10 和 40 比,10 <40,则不用交换位置。(为什么要比较?因为总共5个数,需要比较4次,前面只输出了三个最大数)
      10 40 60 100 130

    至此,整个序列排序完毕。从小到大的序列就是“10 40 60 100 130 ”。从这个例子中还可以总结出,如果有 n 个数据,那么只需要比较 n–1 轮。而且除了第一轮之外,每轮都不用全部比较。因为经过前面轮次的比较,已经比较过的轮次已经找到该轮次中最大的数并浮到右边了,所以右边的数不用比较也知道是大的。

    借鉴百度一张示意图如下:
    在这里插入图片描述
    写一个简单的程序来具体的理解一下:

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <strings.h>
    int main()
    {
    	int a[10]={6,5,4,8,9,3,2,0,1,7};           //创建一个数组,数组有十个元素;再给这十个元素赋值;
    	int i;            //申明变量,i,用来表示第几次循环;
    	int j;           //声明变量,j,用来表示第几个元素;
    	int t;          //申明变量,t,用来交换,也可以不用申请,用 a^(异或) 的方式进行交换;
    	for(i=0;i<9;i++)              //进入循环,开始遍历,遍历次数为 n-1,(最后剩下元素肯定是最小),n 为元素总个数;
    	{
    		for(j=0;j<9-i;j++)       //进入循环,是元素之间的循环,循环次数不断减少,因为随着 i 的增加,最大元素不断被筛选;
    		{                     //每轮比较 (n-1)-i次:两元素间比较,所以是 n-1,因为前面比较 i 轮,已经筛选了i 个最大值;
    			if(a[j]>a[j+1])      //相邻元素进行比较,满足则往下执行,不满足,则跳回for(j=....)循环
    			{
    				t=a[j];
    				a[j]=a[j+1];
    				a[j+1]=t;        //如果满足判断语句,交换两个比较元素的值
    			}
    		}
    	}
    	for(i=0;i<10;i++)          //循环打印,n 为元素总个数,注意区分循环体中循环次数的区别
    	{
    		printf("%d\t",a[i]);
    	}
    	printf("\n");
    	return 0;
    }
    

    接下来我们看一下实际效果,如下图:
    在这里插入图片描述
    总结:对于冒泡排序,最主要的在于理解其冒泡原理,明白是怎么来实现这个结果的。其实就是一次一次的比较,每次选出当轮中的最大值放在其倒数位置上,第 n 轮比较,则第 n 轮中的最大值放在整个数组的倒数第 n 位,依次排列。所以,冒泡排序其实运行时间并不是最快的。但,是非常简单和容易理解的。

    展开全文
  • //对34,5,22,-98,6,-76,0,-3这一从小到大排序 int arr[] = new int[]{34, 5, 22, -98, 6, -76, 0, -3}; //外层循环控制排序的次数 for (int i = 0; i < arr.length - 1; i++) { //内层循环读取数组的元素...

    冒泡排序

    适合新手,简单易懂,废话不多说,直接上JAVA代码:
    首先定义数组,定义两层循环
    int arr[] = new int[]{“这里填需要排序的数”};

    //对34,5,22,-98,6,-76,0,-3这一组数从小到大排序
    	int arr[] = new int[]{34, 5, 22, -98, 6, -76, 0, -3};
    //外层循环控制排序的次数
    	for (int i = 0; i < arr.length - 1; i++) {
    //内层循环读取数组的元素进行比较
    	for (int j = 0; j < arr.length - 1 - i; j++) {
    

    再来个if条件判断大小:

    //数组第一个元素与第二个元素相比较,如果第一个元素大
    //则交换位置,实现从小到大排序;如果从大到小,则是“<”符号
    	if (arr[j] > arr[j + 1]) {
    		  int temp = arr[j];
    		  arr[j] = arr[j + 1];
    		  arr[j + 1] = temp;
    	}
    

    最后输出排好序的数组:

    //循环遍历输出数组中的每一个元素
    	for (int i = 0; i < arr.length; i++) {
    		System.out.print(arr[i] + " ");
    	}
    

    完整代码:

    public class BubbleSort {
        public static void main(String[] args) {
            //对34,5,22,-98,6,-76,0,-3这一组数从小到大排序
            int arr[] = new int[]{34, 5, 22, -98, 6, -76, 0, -3};
            //外层循环控制排序的次数
            for (int i = 0; i < arr.length - 1; i++) {
                //内层循环读取数组的元素进行比较
                for (int j = 0; j < arr.length - 1 - i; j++) {
                    //数组第一个元素与第二个元素相比较,如果第一个元素大
                    //则交换位置,实现从小到大排序;如果从大到小,则是“<”符号
                    if (arr[j] > arr[j + 1]) {
                        int temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
            //循环遍历输出数组中的每一个元素
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + " ");
            }
    
        }
    }
    
    

    运行结果:
    在这里插入图片描述
    似懂非懂???

    展开全文
  • 【程序设计】--------------------------------------------------功能:编写函数用冒泡排序对数组中的数据进行从小到大的排序。*********Begin**********和**********End*********...【程序设计】---------------...

    【程序设计】--------------------------------------------------功能:编写函数用冒泡排序法对数组中的数据进行从小到大的排序。*********Begin**********和**********End*********...

    【程序设计】

    --------------------------------------------------

    功能:编写函数用冒泡排序法对数组中的数据进行从小到

    大的排序。

    *********Begin**********和********** End **********不可删除

    ------------------------------------------------*/

    #include "stdlib.h"

    #include "stdio.h"

    void sort(int a[],int n)

    {

    /*********Begin**********/

    /********** End **********/

    }

    main()

    {

    int a[16],i;

    void TestFunc();

    for(i=0;i<16;i++)

    a[i]=rand()%30;

    for(i=0;i<16;i++)

    printf("%3d",a[i]);

    printf("\n-------------------\n");

    sort(a,16);

    for(i=0;i<16;i++)

    printf("%3d",a[i]);

    TestFunc();

    }

    void TestFunc()

    {

    FILE *IN,*OUT;

    int n;

    int i[10];

    IN=fopen("in.dat","r");

    if(IN==NULL)

    {

    printf("Read File Error");

    }

    OUT=fopen("out.dat","w");

    if(OUT==NULL)

    {

    printf("Write File Error");

    }

    for(n=0;n<10;n++)

    {

    fscanf(IN,"%d",&i[n]);

    }

    sort(i,10);

    for(n=0;n<10;n++)

    fprintf(OUT,"%d\n",i[n]);

    fclose(IN);

    fclose(OUT);

    }

    展开

    展开全文
  • 1.冒泡排序:始终将最大的值冒泡排序到最后面 ``` var arr = [8,7,6,5,4,3,2,1]; //先找到最大的数,放最后,进行两两比较,最大的数永远在最后面,利用两个for循环,外层的for用于循环多次判断数组的两两...

    第1种方法、冒泡排序:始终将最大的值冒泡排序到最后面

            var arr = [8,7,6,5,4,3,2,1];
    
            //先找到最大的数,放到最后,进行两两比较,最大的数永远在最后面,利用两个for循环,外层的for用于循环多次判断数组的两两大小,里面的for循环用于判断前后两个数,也就是两两对比,大的值就对调位置,再用if用于判断,里面申明一个新的变量接收对调的值的临时存放,最终完成对调
    
            for(var j = 0; j < arr.length -1; j++){
               for(var i = 0; i < arr.length - 1 - j; i++){
                   if(arr[i] > arr[i+1]){
                       var tmp;
                       tmp = arr[i];
                       arr[i] = arr[i+1];
                       arr[i+1] = tmp;
                   }
               }
            }
            console.log(arr);

    第2种方法、选择排序:将最小的数永远排序放在最前面

          

     var arr = [8,7,6,5,4,3,2,1];
    
       // 要比较的数
    
       for (var i = 0; i < arr.length - 1; i++) {
    
           // i = 8  依次和后面的 7,6,5,4,3,2,1比较
    
           for (var j = i + 1; j < arr.length; j++) {
    
               // 如果这一轮中的某个值 比当前要比较的值小 则交换位置
    
               if (arr[j] < arr[i]) {
    
                   var tmp;
    
                   tmp = arr[i];
    
                   arr[i] = arr[j];
    
                   arr[j] = tmp;
    
               }
    
           }
    
       }
    
       console.log(arr);

    展开全文
  • 冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果他们的顺序(如从大到小、首字母从AZ)错误就把他们交换过来。走访元素的工作是重复...
  • PHP 冒泡对数组排序从小到大以及从大到小 冒泡排序可简单的理解为,从数组的第一个值开始,循环的与后面的所有值进行对比,选出大(小)的那个,继续与后续的值对比,继续选出大(小)的值一直到两两比较完,...
  • C语言对数组元素进行排序(冒泡排序法)

    万次阅读 多人点赞 2019-11-13 15:38:27
    在实际开发中,有很多场景需要我们将数组元素按照从大到小(或者从小到大)的顺序排列,这样在查阅数据时会更加直观,例如: 一个保存了班级学号的数组,排序后更容易分区好学生和...以从小到大排序为例,冒泡排序...
  • 对数组进行冒泡排序

    2021-11-05 13:13:11
    冒泡排序就将第一个数与第二个数进行比较,将较大值赋给第二个数,依次循环,直到数组从小到大排列完成。 我们先假定一个数组将主体写出来。 int main() { int arr[10] = {1,2,3,4,55,66,77,88,99,100}; ...
  • 例如 int a[10] = {0,5,2,3,6,9,8,7,4,1}对其10个整数由小到大进行排序思想:实现一:#includeint main(){int i = 0;int a[10] = {0,5,2,3,6,9,8,7,4,1};int j = 0;int tmp = 0;int m = sizeof(a) / sizeof(a[0]); /...
  • C语言实验-51-功能:编写函数用冒泡排序对数组中的数据进行从小到大的排序;.c
  • 对数组中的数从小到大排序,使用多种方法排序(冒泡排序,选择排序,快速排序)
  • 冒泡排序 比较相邻两个数字,如果数字比较小就交换位置,全部比较完,除去那一个数最后其余的数同上比较出全部的数字大小 */ public static void sort(int[] array){ //外层循环,判断我们这个要走多少次 //...
  • 冒泡对数组中10个数字从小到大排序: 先将10个数字中最小的数与a[0]置换,再将a[1]到a[9]中最小的数与a[1]置换,总共比较9轮 void sort(array,n)//a[10],10 int array[]; int n; { int i, j, k, t;//本位、后一...
  • //利用函数模板,形参数进行对数组从小到大排序 using namespace std; template <typename T> void swap(T arr[],int a,int b){ int tmp; tmp = arr[a]; arr[a] = arr[b]; arr[b] = tmp; } ...
  • 用冒泡法对数组中10个整数按照从小到大排序。 //数组本身就是一种引用类型。 2.来吧展示,代码如下: using System; namespace Unit_2._4 { class Program { //冒泡排序从小到大 static void sort(int[] ...
  • java:用冒泡方法对数组进行排序

    千次阅读 2019-12-03 20:41:22
    冒泡排序法关键词相关说明源码运行结果附加说明 关键词 bubble(气泡) (比较关键的步骤,默认从上下) class Demo{} //需要Demo建对象bubbleSorter0 Demo bubbleSorter0=new Demo(); //对象bubbleSorter0用于排列...
  • } 冒泡排序是利用相邻的两个进行比较,然后再进行排序。 例如第0行的数据{1,2,7,4,8},先1与2比,然后2和7比,如果后面的比前面的小,就调换位置。如7和4比,后面的数字就比前面的小,故交换位置,变为4,7。然后7...
  • class Demo_10 { public static void main(String[] args) { //定义并初始化一个数组 int[] arr = {34,642,2,3,90,35,23,22,0,18}; int[] arr1 = {3,56,2,... //对无序数组进行遍历 //调用方法 printArr...
  • #include<iostream> using namespace std; int main() ... "排序前:" << endl; for (int i = 0; i < 9; i++) { cout << arr[i] << " "; } cout << endl; ...
  • Java 实现冒泡排序对数组进行排序

    千次阅读 2018-12-02 15:50:12
    冒泡排序是交换排序中的一种简单的排序方法。它的基本思想是对所有相邻记录的关键字值进行比较,如果是逆序(a[j]&gt;a[j+1]),则将其交换,最终达到有序化。  public class BubbleSort { public void ...
  • 冒泡排序,让数组从大到小或者从小到大进行排序 // 定义一个数组 var arr = [5, 4, 3, 2, 1]; var arr = [4, 1, 2, 3, 5]; for (var i = 0; i <= arr.length - 1; i++) { // 外层循环管趟数 for (var j ...
  • 理解冒泡排序问题,有详细的步骤 重点: 从某一个值开始,只有当后面的大于此值.交换值, 附代码 public static void main(String[] args) { //1.首先随机生成20个随机数 int[] a=new int[30]; for(int i=0;i<a...
  • 下面的程序完成对长度为N的整型数组a进行从小到大的排序。请分别用选择排序法、冒泡排序法完成函数sort。 #include #define N 10 ___________________ void main() { int a[N],i; printf("Input %d ...
  • 冒泡排序实现随机数列的从小到大排序 冒泡排序是一种简单的排序算法。它重复地进行相邻数据的比较,一次比较两个元素,如果它们的顺序错误就把它们交换过来。每趟排序,排出一个最大元素放在末尾,重复地进行这项...
  • // 对数组排序从小到大 function sortArr(arr) { for (var i = 0; i < arr.length - 1; i++) { var isSort = true; for (var j = 0; j < arr.length - 1 - i; j++) { if (arr[j] > arr[j+1]) { ...
  • 把数组里的元素按照从大到小 或者从小到大的顺序排列 <script> var arr = [1, 2, 3, 4, 5, 6, 7]; for (var i = 0; i <= arr.length - 1; i++) { for (var j = 0; j <= arr.length - i - 1; j++)...
  • #include<stdio.h> int main(){ int i,j; int a[6]={0};//随机输入的6个整数 int len = sizeof(a) / sizeof(int); //siziof(a):表示a这个变量占了多少个字节。...// sizeof(int):表示int型的变量占了多少...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,632
精华内容 2,252
关键字:

对数组进行从小到大冒泡排序