关于Sort排序与冒泡法的区别

Sort排序和冒泡法的异同

 

对数组a{2,4,3,6,2,8,1}进行排序。

快速排序法

原理：

对于数组a{2,4,3,6,2,8,1}

①  需要选取一个关键元素作为基准元素key，用数组内所有元素跟基准元素比较大小

②  先假设数组内第一个元素的角标为i，最后一个元素角标为j

③  先将数组元素最后一个元素跟基准元素比较，若a[j]>key,则j--,直到a[j]<key,然后进行交换，大的放后面，小的放前面。接着进行第④步；

④  将数组元素第一个元素与基准元素比较，所a[i]<key,则i++,直到a[i]>key,然后进行交换。

⑤  重复③④步，直到i==j，第一趟比较结束。（第一趟比较结束时，基准元素key一般在数组元素的中间位置，然后以基准元素key为中轴，将数组划分为两个子数组，key左边的子数组都小于key，右边的子数组都大于key.）

注：若key为数组元素的最小值，第一趟比较结束时，只比较key右边的子数组，再重新选子数组的基准元素key1，然后进行比较。

若数组为空时，则输出一个空的序列。

若数组不合法时，也输出空序列。

关键点：1.找基准元素；

通常选取数组内第一个元素为基准元素；

     2. 设第一个元素角标为i；

设最后一个元素角标为j；

       3.先由后往前跟基准元素比较，在右前往后比较；

       4.划分子数组。

关于代码：

代码一： 

package shuzu;

 

public classQuickSort {

     public voidsort(int[] arras,intlow,inthigh) {    

         int i=low;

         int j=high;

         if(i>j){

             /*使用了快速排序

             arras:要排序的数组

             low：数组的开始下标

             high:数组的末尾下标

             */

             return;

         }

         int key=arras[low];//选基准元素（一般都数组内第一个元素）

         while(true){     //让一趟里面全部元素比较完毕

             while(j>i){  //由j角标开始往前比较

                 if(arras[j]<key){ //交换

                     int temp=arras[j];

                     arras[j]=arras[i];

                     arras[i]=temp;

                     break;

                 }else{

                     j--;

                 }

             }

             while(j>i){  //由i角标开始往后比较

                 if(arras[i]>key){   //交换

                     int temp=arras[j];

                     arras[j]=arras[i];

                     arras[j]=arras[i];

                     arras[i]=temp;

                     break;

                 }else{

                     i++;

                 }

             }

             if(i==j){  //终止最外层循环，表示一趟比较结束

                 break;

             }

         }    //此时的i=j是基准元素的角标

         sort (arras,low,i-1);  //基准元素左边

         sort (arras,i+1,high);  //基准元素右边

     }

     public voidprint(int[]arras ){   //打印数组元素

         for(inti=0;i<arras.length;i++){

             if (i==arras.length-1){

                 System.out.print(arras[i]);

             }else{

                 System.out.print(arras[i]+",\t");

             }

         }

     }

     public staticvoidmain(String[] args){

         int[] arras ={2,4,3,6,2,8,1};

         QuickSort qs=new QuickSort();

         qs.sort(arras,0,arras.length-1);

         qs.print(arras);

     }

}

       

 

对于上面的代码，还有有几个需要进一步理解的地方。

1.上面的sort(arras,low,i-1)是不是排序arras[low]到arrow[i-1]?没见过这种表示方法，所以有点看不明白。

2.

为什么定义low和high得在sort()内？

3.

对于qs.sort()这种表示也有迷惑，是不是说2、3两个问题都是一种简洁的表示方法？就像课件里的代码那种简洁的表示？

 

代码二：

package shuzu;

import java.util.Arrays;

    public class sort {

         public static void main(String[] args) {

              int[] a =new int[]{2,4,3,6,2,8,1};

              Arrays.sort(a);

              for(inti:a){

                System.out.print(a[i]+"\t");

              }

         }

    }

 

或者是

package shuzu;

import java.util.Arrays;

    public class sort {

         public static void main(String[] args) {

              int[] a =new int[]{2,4,3,6,2,8,1};

              Arrays.sort(a);

              for (int i = 0; i < a.length; i++) {

               

           

            

              //for(int i:a){

                System.out.print(a[i]+"\t");

              }

         }

    }

这样也是可以的

 

冒泡法排序

原理：

对于数组a{2,4,3,6,2,8,1}

①  数组内元素两两比较，先从前两个开始

②  本着让最大的元素放到最后的原则，若a[i]<a[i+1],则i++继续比较;若a[i]>a[i+1],则交换位置。

③  交换位置后，小的元素在前大的元素在后，然后继续用大的元素跟后面元素比较，直到最后，此时该数组最大元素到了最后的位置上，一趟比较结束。

④  一趟比较结束后，继续②③，（这时候，最后一个已经沉底的元素就不需要参与比较了）让次大元素沉到倒数第二的位置上。一直循环，直到将所有元素排列好为止。

注：第一趟比较需进行a.length-1次比较；

第i趟比较需进行a.length-1-i次。

   关键点：

        冒泡法的关键点就在于a.length-1-i次比较有点不好理解，我感觉的话冒泡法还是比快速排序好理解一点，虽然快速排序法写起来很简单。

 

附代码：

写法一

package shuzu;

 

    public class MParray {

         public static void main(String[] args) {

              int[] a =new int[]{2,4,3,6,2,8,1};//定义一个int型数组a,并输入数组元素

             int temp=0;   //定义一个临时变量

              for(int i=0;i<a.length-1;i++){   

              for(intj=0;j<a.length-1-i;j++){

                     if(a[j]>a[j+1]){ //比较相邻两个元素的大小，并交换

                      temp=a[j];

                      a[j]=a[j+1];

                      a[j+1]=temp;

                      }

                   }

                 }

              /*利用冒泡法排序

                并用了两个for循环嵌套

                */

                       for(int i=0;i<a.length;i++){ 

                       System.out.print(a[i]+"\t"); //再利用一个for循环，遍历排序后的数组元素

              }

             }

           }

 

写法二

package shuzu;

public classBubbleSort{

      public staticvoidmain(String[] args) {

          int[] a =new int[]{2,4,3,6,2,8,1};

        int temp = 0;

        for (int i = a.length - 1; i > 0; --i){

            for (int j = 0; j < i; ++j){

                if (a[j + 1] < a[j]){

                    temp = a[j];

                    a[j] = a[j + 1];

                    a[j + 1] = temp;

                }

            }

        }

        for(int i=0;i<a.length;i++){ 

            System.out.print(a[i]+"\t");

   }

 }

}

关于写法二，写法二是我从网上找资料的时候看到的，跟所学的不一样，然后拿过来试一试，一样能运行成功，

在for循环语句中，i++和++i并没有什么区别。

 

总结：

快速排序法的基本思想：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

冒泡法的基本思想：重复地走访要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

快速排序法是在冒泡法的基础上改进而来，其新的写法比冒泡法更容易书写。就像老师说的，在家用Sort排序，在外面用冒泡法，两种方法交替使用，使得可以面对的情况更宽。

通过这两天对Sort排序法资料的研究与整理，真的是受益匪浅。这不仅使我明白了Sort排序的原理，也加深了对冒泡法的理解，更让我对于java或者说敲代码的理解更进一层。我发现对于以前看着就头疼的程序代码，现在也是越来越有兴趣了，也享受到了学习的乐趣，这是在进入大学以后第一次感受到的。

我喜欢这样的生活，喜欢这里的老师，也喜欢这里的氛围，感谢惠普！