Java常见排序算法，面试必考，不看你会后悔

引言：由于堆排序在写堆时已经写过算法了，就在本文中不在做介绍，想看的朋友可以去看看我的关于堆的文章，下面介绍几种常见的排序算法

冒泡排序

原理：
在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序

 public static void bubbleSort(int[]  array){
        for(int i=0;i<array.length-1;i++){
            boolean flag=false;
            for(int j=0;j<array.length-1-i;j++){
                if(array[j]>array[j+1]){
                    int tmp=array[j+1];
                    array[j+1]=array[j];
                    array[j]=tmp;
                    flag=true;
                }
            }
            if(flag==false){
                break;
            }
        }
    }

时间复杂度	时间复杂度	时间复杂度	空间复杂度
最好	平均	最坏
O(n)	O(n^2)	O(n^2)	O(1)
数据有序		数据逆序

稳定性：稳定

插入排序

原理：
整个区间被分为

1. 有序区间
2. 无序区间

每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入

 public static void insertSort(int[] array){
        for( int i=1;i<array.length;i++){
           //有序区间[0,i)
           //无序区间[i,array.length-1]
            int min=array[i];
            int j=i-1;
            for(;j>=0&&array[j]>min;j--){
                array[j+1]=array[j];
            }
            array[j+1]=array[min];
        }
    }

时间复杂度	时间复杂度	时间复杂度	空间复杂度
最好	平均	最坏
O(n)	O(n^2)	O(n^2)	O(1)
数据有序		数据逆序

稳定性：稳定

希尔排序

原理：希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。

1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比

 public static void shell(int[] array,int gap) {
        for(int i=gap;i<array.length;i++){
            int tmp=array[i];
            int j;
            for( j=i-gap;j>=0;j-=gap){
                if(array[j]>tmp){
                    array[j+gap]=array[j];
                }else{
                    break;
                }
            }
            array[j+gap]=tmp;
        }
    }

时间复杂度	时间复杂度	时间复杂度	空间复杂度
最好	平均	最坏
O(n)	O(n^1.3)	O(n^2)	O(1)
数据有序		比较难构造

稳定性：不稳定

选择排序

原理：
每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完 。

public static void selectSort(int[] array){
         for(int i=0;i<array.length;i++){
             for(int j=i+1;j<array.length;j++){
                 if(array[i]>array[j]){
                     int temp=array[i];
                     array[i]=array[j];
                     array[j]=temp;
                 }
             }
         }
    }

时间复杂度	空间复杂度
O(n^2)	O(1)
数据不敏感	数据不敏感

稳定性：不稳定

快速排序

原理：

1. 从待排序区间选择一个数，作为基准值(pivot)；
2. Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可以包含相等的）放到基准值的右边；
3. 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区间的长度 == 0，代表没有数据。

  public static void swap(int[] array,int i,int j){
            int tmp=array[j];
            array[j]=array[i];
            array[i]=tmp;
    }
    public static int partion(int[] array,int start,int end) {
        int tmp = start;

        while (start < end) {
            while (start < end && array[end] >= array[tmp]) {
                end--;
            }
            while (start < end && array[start] <= array[tmp]) {
                start++;
            }
            swap(array,start,end);
        }
        swap(array,tmp,start);
        return start;
    }
    public static void  quickFun(int[] array,int left,int right){
        if(left>=right){
            return ;
        }
        int par=partion(array,left,right);
        quickFun(array,left,par-1);
        quickFun(array,par+1,right);
    }

    public static void quickSortRec(int[] array){
        quickFun(array,0,array.length-1);
    }

稳定性：不稳定

归并排序

原理：
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

public static void merge(int[] array, int low, int mid, int high){ 
   int i = low; 
   int j = mid; 
 int length = high - low; 
 int[] extra = new int[length]; 
 int k = 0; 
 
 // 选择小的放入 extra 
 while (i < mid && j < high) { 
 // 加入等于，保证稳定性
 if (array[i] <= array[j]) { 
 extra[k++] = array[i++]; 
 } else { 
 extra[k++] = array[j++]; 
 } 
 } 
 
 // 将属于元素放入 extra 
 while (i < mid) { 
 extra[k++] = array[i++]; 
 } 
 
 while (j < right) { 
 extra[k++] = array[j++]; 
 } 
 
 // 从 extra 搬移回 array 
 for (int t = 0; t < length; t++) { 
 // 需要搬移回原位置，从 low 开始
 array[low + t] = extra[t]; 
 } 
} 

public static void mergeSort(int[] array){
   mergeSortInternal(array, 0, array.length); 
} 
// 待排序区间为 [low, high) 
private static void mergeSortInternal(int[] array, int low, int high) { 
 if (low - 1 >= high) { 
 return; 
 } 
 
 int mid = (low + high) / 2; 
 mergeSortInternal(array, low, mid); 
 mergeSortInternal(array, mid, high); 
 
 merge(array, low, mid, high); 
} 

时间复杂度	空间复杂度
O(n*log(n))	O(n)
数据不敏感	数据不敏感

稳定性：稳定

排序总结

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