排序总结

1.冒泡排序

• 思想：

  • 两个数比较大小，较大的数下沉，较小的数冒起来。

  • 过程：

    • 比较相邻的两个数据，如果第二个数小，就交换位置。
    • 从后向前两两比较，一直到比较最前两个数据。最终最小数被交换到起始的位置，这样第一个最小数的位置就排好了。
    • 继续重复上述过程，依次将第2.3...n-1个最小数排好位置。

　　时间复杂度:O(n2)

代码：

public static void BubbleSort(int [] arr){

     int temp;//临时变量
     for(int i=0; i<arr.length-1; i++){   //表示趟数，一共arr.length-1次。
         for(int j=arr.length-1; j>i; j--){

             if(arr[j] < arr[j-1]){
                 temp = arr[j];
                 arr[j] = arr[j-1];
                 arr[j-1] = temp;
             }
         }
     }
 }

优化：

• 针对问题：
  数据的顺序排好之后，冒泡算法仍然会继续进行下一轮的比较，直到arr.length-1次，后面的比较没有意义的。

• 方案：
  设置标志位flag，如果发生了交换flag设置为true；如果没有交换就设置为false。
  这样当一轮比较结束后如果flag仍为false，即：这一轮没有发生交换，说明数据的顺序已经排好，没有必要继续进行下去。

public static void BubbleSort1(int [] arr){

   int temp;//临时变量
   boolean flag;//是否交换的标志
   for(int i=0; i<arr.length-1; i++){   //表示趟数，一共 arr.length-1 次

       // 每次遍历标志位都要先置为false，才能判断后面的元素是否发生了交换
       flag = false;
       
       for(int j=arr.length-1; j>i; j--){ //选出该趟排序的最大值往后移动

           if(arr[j] < arr[j-1]){
               temp = arr[j];
               arr[j] = arr[j-1];
               arr[j-1] = temp;
               flag = true;    //只要有发生了交换，flag就置为true
           }
       }
       // 判断标志位是否为false，如果为false，说明后面的元素已经有序，就直接return
       if(!flag) break;
   }
}

 

2.简单选择排序

• 思想：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，它们当中至少有一个将被移到其最终位置上，因此对 n个元素进行排序总共进行至多 n-1次交换

 

 

• 时间复杂度：O（n*n）
• 代码

 

/*
    * 简单选择排序
    * */
    public static void selectSort(int a[],int n){
//有序区间[0,i) 无序区间[i,n)
        for (int i=0;i<n-1;i++){//遍历n-1次
            int k=i;//最小值下标
            for(int j=i+1;j<n;j++){ //从[i+1,n)区间找出最小值和a[i]比较
                if (a[j]<a[k]){
                    k=j;
                }
            }
            if (a[i]!=a[k]){//最小值和a[i]交换
                int temp=a[i];
                a[i]=a[k];
                a[k]=temp;
            }

        }
    }

3.希尔排序

基本思想：
在要排序的一组数中，根据某一增量分为若干子序列，并对子序列分别进行插入排序。
然后逐渐将增量减小,并重复上述过程。直至增量为1,此时数据序列基本有序,最后进行插入排序。

时间复杂度：O(n1.5)

public static void shell_sort(int array[],int lenth){

   int temp = 0;
   int incre = lenth;

   while(true){
       incre = incre/2;

       for(int k = 0;k<incre;k++){    //根据增量分为若干子序列

           for(int i=k+incre;i<lenth;i+=incre){

               for(int j=i;j>k;j-=incre){
                   if(array[j]<array[j-incre]){
                       temp = array[j-incre];
                       array[j-incre] = array[j];
                       array[j] = temp;
                   }else{
                       break;
                   }
               }
           }
       }

       if(incre == 1){
           break;
       }
   }
}

 

4. 插入排序

• 思想：在待排序的一组数据中，假定前n-1个数有序，将第n个数插入到前面的有序序列中，使得这n个数也保持有序，具体做法是从后往前枚举已有序序列，进行比较，确定插入位置

 

 

 

• 时间复杂度：O（n*n）

代码：

 /*
    * 插入排序
    * */
    public static void insertSort(int a[]){
        for (int i=0;i<a.length-1;i++){
            for (int j=i+1;j>0;j--){
                if (a[j]<a[j-1]){
                    int temp=a[j];
                    a[j]=a[j-1];
                    a[j-1]=temp;
                }
                else break;
            }
        }
    }

5.快速排序：

• 思路：分治思想，复杂度：O(N*logN)
  • 先从数列中取出一个数作为基准值；
  • 将比这个数小的数全部放在它的左边，大于或等于它的数全部放在它的右边；
  • 对左右两个小数列重复第二步，直至各区间只有1个数。

代码：

/*
    * 快速排序
    * */
    //划分区间对【left，right】进行划分
    public static int partition(int []a,int left,int right){
        int temp=a[left];//a[left]存放至临时变量
        while (left<right){//只要left和right不相遇
            while (left<right&&a[right]>=temp) right--;//反复左移right
                a[left]=a[right];
            while (left<right&&a[left]<temp) left++;//反复右移left
                a[right]=a[left];
        }
        a[left]=temp;//把temp放到left和right相遇的地方
        return left;
    }
    public static void quickSort(int a[],int left,int right){
        if (left>=right){//当前区间长度不超过1
            return;
        }
            int pos=partition(a,left,right);//将[left,right]按a[left]一分为二
            quickSort(a,left,pos-1);//对左子区间递归进行快速排序
            quickSort(a,pos+1,right);//对右子区间进行快速排序
    }

6.归并排序

• 思路：2-路归并排序，其原理是，将序列两两分组，将序列归并为【n/2】个组，组内单独排序；然后将这些组在两两归并，生成【n/4】个组，组内再单独排序；以此类推，直到只剩下一个组为止
• 时间复杂度：O(nlogn)
• 例子:将序列{66,12,33,57,64,27,18} 进行2-路归并排序

1. 第一趟。两两分组，得到四组：{66,12}、{33,57}、{64,27}、{18}，组内单独排序，得到新序列{{12,66}，{33,57}，{27,64}，{18}}
2. 第二趟。将四个组继续两两分组，得到两组：{12,66,33,57}，{27,64,18}，组内单独排序，得到新序列{{12,33,57,66}，{18,27,64}}
3. 第三趟。将两个组继续两两分组，得到一组：{12,66,33,57,27,64,18}，组内单独排序，得到新序列{12,18,27,33,57,64,66}

整个过程如下图：

 

2-路归并排序的核心在于如何将两个有序序列合并为一个有序序列

代码：

 

/*
    * 归并排序
    * */
    public static void merge(int A[],int L1,int R1,int L2,int R2){
        /*将[L1,R1][L2,R2]合并为有序区间，L2=R1+1*/
        int maxn=100;
        int i=L1,j=L2;
        int [] temp=new int[maxn];//temp 临时数组存放合并后的数组，index为其下标
        int index=0;
        while(i<=R1&&j<=R2){
            if (A[i]<=A[j]){
                temp[index++]=A[i++];//将A[i]加入序列temp
            }else{
                temp[index++]=A[j++];//将A[j]加入序列temp
            }
        }
        while(i<=R1) temp[index++]=A[i++];//将[L1,R1]的剩余元素加入序列temp
        while(j<=R2) temp[index++]=A[j++];//将[L2,R2]的剩余元素加入序列temp
        for (i=0;i<index;i++){
            A[L1+i]=temp[i];//将合并后的序列赋值回数组A
        }
    }
    public static void mergeSort(int A[],int left,int right){
        if (left<right){
            int mid=(left+right)/2;//取【left，right】的中点
            mergeSort(A,left,mid);//递归将左子区间【left，mid】归并排序
            mergeSort(A,mid+1,right);//递归将右子区间【mid+1，right】归并排序
            merge(A,left,mid,mid+1,right);//将左子区间和右子区间合并
        }
    }