JAVA-基础-几种常见的排序

1.概念

排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。平时的上下文中，如果提到排序，通常指的是排升序（非降序）。通常意义上的排序，都是指的原地排序(in place sort)。
排序的稳定性指的是：两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性的排序算
法

2.几种常见的排序方法

1.直接插入排序：

直接插入排序非常简单，将数组分为两个区间，有序和无序区间，将无序区间的数一个个的插入到有序区间即可；
用图来演示：

上述过程可以视作从无序数组中取出数，插入到有序数组中，有序数组变长，无序数组减短；
通过代码实现这个操作：

public static void myInsertSort(int[] array){
        for(int i=1;i<array.length;i++){
            int j=i-1;
            int tmp = array[i];
            for(;j>=0;j--){
                if(array[j]>tmp){
                    array[j+1]=array[j];//往后挪一位
                }else {
                    break;//小于tmp了；
                }
                array[j+1]=tmp;//在进行判断时走到了j位置进行比较，
                // 但其小于tmp，因此tmp紧随其后
            }
        }
    }

时间复杂度：最好O(n)，平均 O(n²)，最坏O(n²),空间复杂度：O(1)；

2.希尔排序

又称为缩小增量法，希尔排序的思想是：将待排序的文件分成a组，a为任意数，所有距离为b的数被分成一组，然后对每一组进行排序，重复进行上述操作，当b为1时，所有组的数都会变成插入排序，但此时只需要简单的调整即可，这些间隔gap即是增量序列，增量序列从大到小都为素数，

代码实现：进行多次插入排序即可，通过遍历增量序列来确定每次的分组

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

3.选择排序

代码示例：

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[j]<array[i]){
                    int tmp=array[i];
                    array[i]=array[j];
                    array[j]=tmp;
                }
            }
        }
    }

4.堆排序

基本原理也是选择排序，只是不在使用遍历的方式查找无序区间的最大的数，而是通过堆来选择无序区间的最大的数
通过大根堆的特点根为最大元素，将其进行多次大根堆向下调整，每次将根放在列表末尾，最终得到一个排好序的堆，其实就是将列表非为两部分，有序的为后端，将每次前端的最大值陆续放在后端即可
图示：

public static  void HeapSort(int[] array){
        createBigheap(array);
        int size=array.length-1;
        for(int i=array.length-1;i>=0;i--){
            int tmp = array[i];
            array[i]=array[0];
            array[0]=tmp;
//进行向下调整时，需要注意此时不调整已经安置的末尾节点，
            shiftDown(array,size,0);
            size--;
        }
    }
    public static void createBigheap(int[] array){
        int size = array.length-1;
        for(int i=(array.length-1)/2;i>=0;i--){
            shiftDown(array,array.length,i);//从末尾开始进行向下调整，将所有子树都调整为一个大根堆，

        }
    }
    public static void shiftDown(int[] array,int size,int index){
        int left=2*index+1;
        while(left<size){
            int right=left+1;
            int max = left;
            if (right<size && array[right]>array[left]){
                max=right;
            }
            if (array[max]>array[index]){
                int tmp = array[max];
                array[max]=array[index];
                array[index]=tmp;
                index=max;//调整过程中，只挪动了max位置的值，因此只需要将max子树再进行下调整即可
                left=2*index+1;
            }else{
                break;
            }
        }
    }

5.冒泡排序

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

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

6.快速排序

通过一次排序将列表分为两部分，后端部分一定比前端部分大，
然后再按照相同的步骤将这两部分分别进行快速排序，直到列表有序，整个过程递归进行

public static void quickSort(int [] array){
        quick(array,0,array.length-1);
    }
    public static void quick(int[] array,int low,int high){
        if (low<high){
            int piv = pivot(array,low,high);
            quick(array,low,piv-1);
            quick(array,piv+1,high);
        }
        return;
    }
    public static int pivot(int[] array,int start,int end) {
        int tmp = array[start];
        while (start < end) {
            while (start<end && array[end]>=tmp) {
                end--;
            }
            if (start>=end){
                array[start]=tmp;
            }else{
                array[start]=array[end];
            }
            array[start]=array[end];
            //把数据赋值给start
            while (start<end && array[start]<=tmp) {
                start++;
            }
            if (start>=end){
                array[start]=tmp;
            }else{
                array[end]=array[start];
            }
            //把start下标的值给end
        }
        array[start] = tmp;
        return start;
    }

非递归实现：

public static void quickSort2(int[] array){
        Stack<Integer> stack = new Stack<>();
        int low = 0;
        int high = array.length-1;
        int piv = pivot(array,low,high);
        if(piv > low + 1) {
            stack.push(low);//每次找到的是中间值的位置，将中间值的两边推入栈中
            stack.push(piv-1);//
        }
        if(piv < high-1) {
            stack.push(piv+1);
            stack.push(high);
        }
        while (!stack.empty()) {
            high = stack.pop();//在得到一个新的边界后，继续寻找中间值的位置
            low = stack.pop();//并且继续对数组进行划分，知道栈为空，栈中保存的是每次找到中间值位置后，两边的边界
            piv = pivot(array, low, high);//每次都将两边的边界推入栈，找中间值位置，再推入边界，//直到piv=low+1;这时他们已经不需要调整
            if (piv > low + 1) {
                stack.push(low);
                stack.push(piv - 1);
            }
            if (piv < high - 1) {
                stack.push(piv + 1);
                stack.push(high);
            }
        }
    }
    public static int pivot(int[] array,int start,int end) {
        int tmp = array[start];
        while (start < end) {
            while (start<end && array[end]>=tmp) {
                end--;
            }
            if (start>=end){
                array[start]=tmp;
            }else{
                array[start]=array[end];
            }
            array[start]=array[end];
            //把数据赋值给start
            while (start<end && array[start]<=tmp) {
                start++;
            }
            if (start>=end){
                array[start]=tmp;
            }else{
                array[end]=array[start];
            }
            //把start下标的值给end
        }
        array[start] = tmp;
        return start;
    }

7.归并排序

归并排序也是利用了分治策略的思想，首先将数组分成单个的数，再将其进行两两合并排序，得到最终的有序的数组

public static void mergeSort2(int[] array) {
        
        mergeSortInternal(array,0,array.length-1);
    }
public static void merge(int[] array,int start,int mid,int end) {
        int s1 = start;
        int s2 = mid+1;

        int[] tmp = new int[end-start+1];
        int k = 0;//tmp数组的下标

        while (s1 <= mid && s2 <= end) {
            if(array[s1] <= array[s2]) {
                tmp[k++] = array[s1++];
            }else{
                tmp[k++] = array[s2++];
            }
        }
        //有可能第一个段还有数据 有可能第2个段也有数据
        while (s1 <= mid) {
            tmp[k++] = array[s1++];
        }
        while (s2 <= end){
            tmp[k++] = array[s2++];
        }

        for (int i = 0; i < tmp.length; i++) {
            array[i+start] = tmp[i];
        }
    }

    public static void mergeSortInternal(int[] array,int low,int high) {
        if(low >= high) return;
        int mid = (low+high)/2;
        mergeSortInternal(array,low,mid);
        mergeSortInternal(array,mid+1,high);
        //合并的操作
        merge(array,low,mid,high);
    }

3.性能分析

排序方法	最好	平均	最坏	空间复杂度	稳定性
冒泡排序	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)	稳定