十大排序算法 详解 markdown

稳定： 如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
不稳定： 如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。
如何记忆稳定算法：冒插归稳 冒冒失失插到最前面面试，神气归来，稳了

快速排序

最坏情况下（例如前面所说，数组倒序，枢纽元选第一位）快速排序将花费O(N2)时间。
最好情况下，快速排序和归并排序一样，花费O(NlogN)时间。
平均情况下，快速排序花费O(NlogN)时间。

快速排序最优的情况就是每一次取到的元素都刚好平分整个数组

此时的时间复杂度公式则为：T[n] = 2T[n/2] + f(n)；T[n/2]为平分后的子数组的时间复杂度，f[n] 为平分这个数组时所花的时间；

最差的情况就是每一次取到的元素就是数组中最小/最大的，这种情况其实就是冒泡排序了(每一次都排好一个元素的顺序)

 这种情况时间复杂度就好计算了，就是冒泡排序的时间复杂度：T[n] = n * (n-1) = n^2 + n;

 综上所述：快速排序最差的情况下时间复杂度为：O( n^2 )

归并排序

参考：https://blog.csdn.net/m0_38056893/article/details/79461901

参考：https://www.cnblogs.com/shudonghe/p/3302888.html

归并排序采用的是分治(divide-and-conquer)法思想。

（1）基本思想：将待排序元素分成大小大致相同的2个子集合，分别对2个子集合进行排序，最终将排好序的子集合合并成为所要求的排好序的集合。

（2）执行过程：

（3）算法思路：

（4）Java代码：

import java.util.Arrays;

public class MergeSort {
    public static void main(String[] args) {
        int[] arr= {6,5,3,9,4,1,2,7,8,0};
        System.out.println("排序前：" + Arrays.toString(arr));
        mergeSort(arr, 0, arr.length-1);
        System.out.println("排序后：" + Arrays.toString(arr));
    }

    public static void mergeSort(int[] arr, int low, int high){
        if(low >= high){
            return ;
        }

        int mid = low + (high-low)/2;
        mergeSort(arr, low, mid);          //对左边序列进行归并排序
        mergeSort(arr, mid+1, high);  //对右边序列进行归并排序
        merge(arr, low, mid, high);        //合并两个有序序列

    }

    public static void merge(int[] arr, int low, int mid, int high){
        int i = low;     //左边序列起始索引
        int j = mid+1;   //右边序列起始索引
        int[] tmp = new int[arr.length];
        int k = low;      //tmp的下标

        while(i <= mid && j <= high){
            if(arr[i] < arr[j]){
                tmp[k++] = arr[i++];
            }else{
                tmp[k++] = arr[j++];
            }
        }

        //若左边序列还有剩余，则将其全部拷贝进tmp[]中
        while(i <= mid){
            tmp[k++] = arr[i++];
        }
        //若右边序列还有剩余，则将其全部拷贝进tmp[]中
        while(j <= high){
            tmp[k++] = arr[j++];
        }

        for(int t = low; t < k; t++){
            arr[t] = tmp[t];
        }

    }
}

（6）复杂度分析：

堆排序

参考

堆排序

堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。

堆排序的基本思想

将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。

堆

堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。
设当前元素在数组中以R[i]表示，那么，
(1) 它的左孩子结点是：R[2i+1];
(2) 它的右孩子结点是：R[2i+2];
(3) 它的父结点是：R[(i-1)/2];

复杂度

因为堆排序无关乎初始序列是否已经排序已经排序的状态，始终有两部分过程，构建初始的大顶堆的过程时间复杂度为O(n)，交换及重建大顶堆的过程中，需要交换n-1次，重建大顶堆的过程根据完全二叉树的性质，[log2(n-1),log2(n-2)…1]逐步递减，近似为nlogn。所以它最好和最坏的情况时间复杂度都是O(nlogn)，空间复杂度O(1)。

代码

/*
设当前元素在数组中以R[i]表示，那么，
(1) 它的左孩子结点是：R[2*i+1];
(2) 它的右孩子结点是：R[2*i+2];
(3) 它的父结点是：R[(i-1)/2];
 */

import java.util.Arrays;

public class HeapSort {
    public static void main(String []args){
        int []arr = {9,8,7,6,5,0,4,3,2,1};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void sort(int []arr){
        //1.构建大顶堆
        for(int i=arr.length/2-1;i>=0;i--){
            //从第一个非叶子结点从下至上，从右至左调整结构
            adjustHeap(arr,i,arr.length);
        }
        //2.调整堆结构+交换堆顶元素与末尾元素
        for(int j=arr.length-1;j>0;j--){
            swap(arr,0,j);//将堆顶元素与末尾元素进行交换
            adjustHeap(arr,0,j);//重新对堆进行调整
        }
    }

    /**
     * 调整大顶堆（仅是调整过程，建立在大顶堆已构建的基础上）
     * 将下标为i的元素放到合适的位置
     * @param arr
     * @param i
     * @param length
     */
    public static void adjustHeap(int []arr,int i,int length){
        int temp = arr[i];//先取出当前元素i
        for(int k=i*2+1;k<length;k=k*2+1){//从i结点的左子结点开始，也就是2i+1处开始
            if(k+1<length && arr[k]<arr[k+1]){//如果左子结点小于右子结点，k指向右子结点
                k++;
            }
            if(arr[k] >temp){//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
                arr[i] = arr[k];
                i = k;
            }else{
                break;
            }
        }
        arr[i] = temp;//将temp值放到最终的位置
    }

    /**
     * 交换元素
     * @param arr
     * @param a
     * @param b
     */
    public static void swap(int []arr,int a ,int b){
        int temp=arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}