基础 | 7大排序算法java总结（上）

• 常见排序算法分类
  
• 常见排序算法性能比较：

排序 方法	平均情况	最好 情况	最坏 情况	空间复杂度	稳定性
冒泡 排序	O(n²)	O(n)	O(n²)	O(1)	稳定
选择 排序	O(n²)	O(n²)	O(n²)	O(1)	不稳定
插入 排序	O(n²)	O(n)	O(n²)	O(1)	稳定
希尔 排序	O(nlogn) ~ O(n²)	O(n^1.3)	O(n²)	O(1)	不稳定
堆排序	O(nlogn)	O(nlogn)	O(nlogn)	O(1)	不稳定
归并 排序	O(nlogn)	O(nlogn)	O(nlogn)	O(n)	稳定
快速 排序	O(nlogn)	O(nlogn)	O(n²)	O(logn)~O(n)	不稳定

• 排序算法的稳定性问题：
  若arr[i] = arr[j]，排序前arr[i]在arr[j]之前，排序后arr[i]还在arr[j]之前，则称这种排序算法是稳定的。通俗地讲就是保证排序前后两个相等的数的相对顺序不变。

举例：冒泡排序是一个稳定的排序算法，但若将arr[j]>arr[j+1]换为arr[j]>=arr[j+1]，则两个相等的数就需要交换位置，从而变成不稳定的算法

1.冒泡排序

基本思想：

不断地进行两两比较相邻数据，如果前面的数据大于后面的就将它们交换，使得大的数往后面走，每次冒泡就会将一个大的数往后面冒，直到没有需要交换的数据为止。

• 代码如下：

public static void bubbleSort(int[] arr){                    
    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;                             
            }                               
        }                                                                  
    }                                       
}                                                                     

通过上述冒泡我们可以发现，当数组进行到第7趟时已经有序，但仍然进行了第8趟操作，尽管没有交换数据，但之后的大量比较有些多余。此时考虑 冒泡算法的优化：加入flag标记，确定是否已有序

• 优化版本：

public static void bubbleSort(int[] arr){               
    for(int i=0;i<arr.length-1;i++){
        boolean flag=false;//优化标记
        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;             
               flag=true;       //若发生数据交换，则flag置为true
            }                              
        }           
        if(flag==false){
           //System.out.print("已有序");
           return;
        }      
    }                                      
}                                          

分析知，当待排序数组本身有序，根据优化后的代码，可推断出进行n-1次比较，时间复杂度为O(n)，当待排序全部无序时，此时需要比较n(n-1)/2次，因此冒泡排序的时间复杂度为O(n²)

2.选择排序

基本思想：

待排序序列通过n-i次数据间的比较，从n-i+1个记录中选出最小值，和第i个数据交换。

• 代码如下：

public static void sort(int[] arr){
    for(int i = 0; i<arr.length ; i++) {
       int minIndex=i;
       for(int j=i+1;j<arr.length;j++) {   //j只是为找最小值下标
           if (arr[j] < arr[minIndex]) {
               minIndex = j;
           }
        }
        int temp = arr[minIndex];
        arr[minIndex] = arr[i];
        arr[i] = temp;
    }
}

分析知：无论最好最差的情况，选择排序的比较次数是一样多的，其时间复杂度仍然为O(n²)，尽管选择排序与冒泡排序时间复杂度相同，但性能上还是略优于冒泡排序

3.插入排序

基本思想：

①从0号下标开始(默认此时已有序)
②取1号下标数据，从后往前进行比较 ，如果该数据大于下一个数据，将该元素后移；
③重复操作，直到找到已排序的元素小于或者等于该元素的位置，将新元素插入到该位置后

• 代码如下：

public static void char1(int[] arr) {
    for(int i=0;i<arr.length-1;i++){
        if(arr[i]>arr[i+1]){
            int j=i+1;
            int temp=arr[j];
            while(i>=0&&temp<arr[i]){
                arr[i+1]=arr[i];
                i--;
            }
            arr[i+1]=temp;
        }
    }
}

4.希尔排序

基本思想：

将相隔某个增量的数据组成一个子序列，实现跳跃式移动，从而提高排序效率

• 代码如下：

public static void shell(int[]arr){  //充当接口作用
    int[] gaps = {5,3,1};
    for(int i=0;i<gaps.length;i++){
        shellSort(arr,gaps[i]);
    }
}

public static void shellSort(int[] arr, int gap) {
    for (int i = gap; i < arr.length; i++) {
        int temp = arr[i];
        int j = i - gap;
        while (j >= 0 && arr[j] > temp) {
            arr[j + gap] = arr[j];
            j -= gap;
        }
        arr[j + gap] = temp;
    }
}

5.快速排序

基本思想：

对一个数组，标记初始值arr[0]为temp（基准）。
①用right下标从后向前找到比temp小的数据，将其放在left下标位置，此时right下标位置为空；
②用left从前向后找到比temp大的数据，将其放在right下标位置，此时left所指位置为空
③用temp填补left的空白位置 -> 此时right==left
当right或者left位左右数据个数<=2时，表示数组已正序

若left或right下标左右数据个数>=2，划分左右，重复操作：

• 代码如下：

public static void quickSort(int[] arr) {  //充当接口作用
    quickProcess(arr, 0, arr.length - 1);
}

private static void quickProcess(int[] arr, int left, int right) {
    int index = partition(arr, left, right);
    //划分左边
    if (index - left >= 2) {
        quickProcess(arr, left, index - 1);
    }
    //划分右边
    if (right - index >= 2) {
        quickProcess(arr, index + 1, right);
    }
}

private static int partition(int[] arr, int left, int right) {
    int temp = arr[left];
    while (left < right) {
        //从后往前找比基准小的数丢到left的位置
        while (left < right && arr[right] >= temp) {
             right--;
        }
        arr[left] = arr[right];
        //从前向后找比基准大的数字丢到right的位置
        while (left < right && arr[left] <= temp) {
            left++;
        }
        arr[right] = arr[left];
    }
    arr[left] = temp;
    return right;
}