各种排序算法详解（代码+图解）

排序

在讲具体排序算法之前，先将它们用到的方法写在前面。

比较两个元素的大小

public boolean less(Comparable a,Comparable b){
    return a.comparaTo(b)<0;
}

交换两个元素的位置

public void exch(Comparable[] a,int i,int j){
    Comparable t=a[i];
    a[i]=a[j];
    a[j]=t;
}

1.1选择排序

原理：首先找到数组中的最小值，将它和数组中的第一个元素交换位置。接着，在剩下的元素中找到最小的元素，和第二格元素交换位置，直到整个数组有序。因为它在不断选择剩余元素中的最小值，所以叫做选择排序。

特点：

①运行时间和输入（不是大小，而是状态，即是否有序）无关。 因为为了找到最小的元素而扫描一次数组并不能为下次扫描提供什么有效的信息。

②数据移动次数最少。 每次交换都确定一个元素，因此交换N次就排好序了。这是其他算法都不具备的。

算法实现

public void sort(Comparable[] a){
    int len=a.length;
    for (int i=0;i<len-2;i++){
        int min=i;
        for (int j=i+1;i<len;j++){
            if (less(a[j],a[min]))
                exch(a,j,min);
        }
    }
}

1.2 插入排序

**原理：**给定一个数组，默认第一个元素为有序数组，后边的元素往有序数组里边插。

优势：插入排序对部分有序数组进行排序时，效率很高。 如果数组中倒置的数量小于数组大小的某个倍数，我们说这个数组是部分有序的。 下边列出几种典型的部分有序数组。

• 数组中的每个元素距离它的最终位置都不远。
• 一个有序的大数组接一个小数组。
• 数组中只有几个元素不确定。

算法实现

public void sort(Comparable[] a){
    int len=a.length;
    for (int i=1;i<len;i++){
        for (int j=i;i>0 && less(a[j],a[j-1]);j--)
            exch(a,j,j-1);
    }
}

选择排序不会访问索引左侧的元素，插入排序不会访问索引右侧的元素。

1.3希尔排序

希尔排序是对插入排序进行改进的一种排序算法。

**原理：**使数组中任意间隔为h的元素有序。这里的h没有规定,一般为数组大小的一半。如图所示，相同颜色的代表间隔为h的数组，我们使相同颜色的数组有序。接着减小h的值，再使相同颜色的数组有序，当h为1时，整个数组已经排好序了。

算法实现：

public void sort(Comparabel[] a){
    int len=a.length;
    int h=1;
    while (h<len/2)
        h=2*h+1;
    while(h>=1){
        for (int i=h;i<len;i++){
            for (int j=i;j>=h && less(a[j],a[j-h]);j-=h)
                exch(a,j,j-h);
        }
        h=h/2;
    }
}

1.4归并排序

**原理：**将一个大数组分为两部分，分别进行排序，将排序好的数组进行归并。

优缺点: 它能保证将任意长度为n的数组进行排序的时间复杂度和NlogN成正比， 缺点是它所需的额外空间和N成正比。

算法实现：

public class Merge{
    public static Comparable[] assert;  //归并所需的辅助数组
    public static void sort(Comparable[] a){
        assert=new Comparable(a.length);
        sort(a,0,a.length-1);
    }
    public static void sort(Comparable[] a,int lo,int hi){
        if (hi<=lo)
            return;
        int mid=l0+(hi-lo)/2;
        sort(a,lo,mid); //对左半边进行排序
        sort(a,mid+1,hi);  //对右半边进行排序
        merge(a,lo,mid,hi);
    }
    //将两个有序数组进行归并
    public static void merge(Comparable[] a,int lo,int mid,int hi){
        int i=lo;
        int j=mid+1;
        for (int k=lo;k<=hi;k++)
            assert[k]=a[k];
        for (int k=lo;k<=hi;k++){
            if (i>mid)  //左半边用尽
                 a[k]=assert[j++];
            else if (j>hi)//右半边用尽
                a[k]=assert[i++];
            else if (less(assert[i],assert[j]) //左半边的当前元素小于右半边的当前元素
                 a[k]=assert[i++];
            else   //右半边的当前元素小于左半边的当前元素
                  a[k]=assert[j++];
        }
    }
}

将两个有序数组进行归并的原理图

1.5快速排序

**原理：**通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

优点：

①原地排序，不需要额外的存储空间

② 它能保证将任意长度为n的数组进行排序的时间复杂度和NlogN成正比，与归并排序一样。

给定原始数列如下，要求从小到大排序：

我们首先选定基准元素Pivot，并且设置两个指针left和right，指向数列的最左和最右两个元素：

接下来是第一次循环，从right指针开始，把指针所指向的元素和基准元素做比较。如果大于等于pivot，则指针向左移动；如果小于pivot，则right指针停止移动，切换到left指针。

在当前数列中，1<4，所以right直接停止移动，换到left指针，进行下一步行动。

轮到left指针行动，把指针所指向的元素和基准元素做比较。如果小于等于pivot，则指针向右移动；如果大于pivot，则left指针停止移动。

由于left一开始指向的是基准元素，判断肯定相等，所以left右移一位。

由于7 > 4，left指针在元素7的位置停下。这时候，我们让left和right指向的元素进行交换。

接下来，我们进入第二次循环，重新切换到right向左移动。right先移动到8，8>2，继续左移。由于2<8，停止在2的位置。

切换到left，6>4，停止在6的位置。

元素6和2交换。

进入第三次循环，right移动到元素3停止，left移动到元素5停止。

元素5和3交换。

进入第四次循环，right移动到元素3停止，这时候请注意，left和right指针已经重合在了一起。

当left和right指针重合之时，我们让pivot元素和left与right重合点的元素进行交换。此时数列左边的元素都小于4，数列右边的元素都大于4，这一轮交换终告结束。

算法实现

public Quick{
    public static void sort(Comparable[] a) {
    int lo=0;
    int hi=a.length-1;
    sort(a,lo,hi);
}
    public static void sort(Comparable[] a,int lo,int hi) {
        //做安全性校验
        if (hi<=lo)
            return;
        //对数组进行分组（左子祖，右子组）
        int  mid=partition(a,lo,hi);
        //对左子祖进行排序
        sort(a,lo,mid-1);
        //对右子组进行排序
        sort(a,mid+1,hi);
    }
    public static int partition(Comparable[] a,int lo,int hi) {
        //确定分界值,默认为数组中的第一个元素
        Comparable key=a[lo];
        //定义两个指针，分别指向带切分元素的最小索引处和最大索引处的下一个位置
        int left=lo;
        int right=hi+1;
        //切分
        while (true) {
            //先从右到左扫，找到一个比分界值小的元素，停止
            while (less(key,a[--right])) {
                if (right==lo) {
                    break;
                }
            }
            //再从左到右扫，找到比分界值大的元素，停止
            while (less(a[++left],key)) {
                if (left==hi) {
                    break;
                }
            }
            //判断left>=right,如果是，结束循环，如果不是，交换位置
            if (left>=right) {
                break;
            }
            else
                exch(a,left,right);
        }
        //交换分界值
        exch(a,lo,right);
        return right;
    }
}

1.6优先队列

在某些情况下，我们需要获取数组中最大（最小）的元素，之后获取剩余元素中最大（最小）的元素。这时候就需要使用优先队列了。

二叉堆能很好地实现优先队列的基本操作。这是由二叉堆的性质决定的。 二叉堆是完全二叉树或者是近似完全二叉树。二叉堆有两种：最大堆和最小堆。最大堆：父结点的键值总是大于或等于任何一个子节点的键值 ；最小堆：父结点的键值总是小于或等于任何一个子节点的键值。 一般由数组实现。 在堆中，位置为k的节点的父节点位置是k/2（向下取余），子节点的位置是2k，2k+1。

堆的比较和交换方法

//比较
public void less(int i,int j){
    return pq[i].compareTo(pq[j])<0;
}
//交换
public void exch(int i,int j){
    Key t=pq[i];
    pq[i]=pq[j];
    pq[j]=t;
}

上浮算法（swim）

含义：如果堆的有序状态因为某个节点变得比它的父节点还要大而打破，那么我们要交换它和它的父节点来修复堆。

代码：

public void swim(int k){
    while (k>1 && less(k/2,k))
    {
        exch(k/2,k);
        k=k/2;
    }
}

下沉算法（sink）

含义：如果堆的有序状态因为某个节点变得比它的两个子节点或者其中之一小而打破，那么我们要交换它和子节点中的较大值来修复堆。

代码：

public void sink(int k){
    while (2*k<=N){
        int j=2*k;
        if (j<N && less(j,j+1))
            j++;
        if (!less(k,j))
            break;
        exch(k,j);
        k=j;
    }
}

入队操作

1.插入新节点5

2.新节点5上浮到合适位置。

出队操作

1.把原堆顶节点10“出队”

2.最后一个节点1替换到堆顶位置

3.节点1下沉，节点9成为新堆顶

完整算法

public class MaxPQ<key extends Comparable<key>>{
        private key[] pq;
        private int N=0;
        //构造方法
        public MaxPQ(int maxN){
            pq=(key[])new Comparable[maxN + 1];
        }

    public boolean isEmpty(){
            return N==0;
        }
        public void insert(key v){
            pq[++N]=v;
            swim(N);
        }
        public key delMax(){
            key max=pq[1];  //获取最大元素
            exch(1,N--);
            pq[N+1]=null;
            sink(1);
            return max;
        }
        //比较
        public boolean less(int i, int j){
            return pq[i].compareTo(pq[j])<0;
        }
        //交换
        public void exch(int i,int j){
            key t=pq[i];
            pq[i]=pq[j];
            pq[j]=t;
        }
        public void swim(int k){
            while (k>1 && less(k/2,k))
            {
                exch(k/2,k);
                k=k/2;
            }
        }
        public void sink(int k){
            while (2*k<=N){
                int j=2*k;
                if (j<N && less(j,j+1))
                    j++;
                if (!less(k,j))
                    break;
                exch(k,j);
                k=j;
            }
        }
}

1.7堆排序

实现步骤

①把无序数组构建成二叉堆。

②循环删除堆顶元素，移到集合尾部，调节堆产生新的堆顶。

图解

步骤一 构造初始堆。将给定无序序列构造成一个大顶堆（一般升序采用大顶堆，降序采用小顶堆)。

a.假设给定无序序列结构如下

2.此时我们从最后一个非叶子结点开始（叶结点自然不用调整，第一个非叶子结点 arr.length/2-1=5/2-1=1，也就是下面的6结点），从左至右，从下至上进行调整。

4.找到第二个非叶节点4，由于[4,9,8]中9元素最大，4和9交换。

这时，交换导致了子根[4,5,6]结构混乱，继续调整，[4,5,6]中6最大，交换4和6。

此时，我们就将一个无需序列构造成了一个大顶堆。

步骤二 将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。

a.将堆顶元素9和末尾元素4进行交换

b.重新调整结构，使其继续满足堆定义

c.再将堆顶元素8与末尾元素5进行交换，得到第二大元素8.

后续过程，继续进行调整，交换，如此反复进行，最终使得整个序列有序

算法实现

public class HeapSort {
    
    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);//重新对堆进行调整
        }

    }

    /**
     * 调整大顶堆（仅是调整过程，建立在大顶堆已构建的基础上）
     * @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;
    }
}

1.8各种算法的时间复杂度