算法与数据结构之美-排序(下)

开篇思考

如何利用快排的思想，在O(n)内查找数组中的第K大元素？
leetcode:https://leetcode-cn.com/problems/kth-largest-element-in-an-array/

上篇博客中讲到了 冒泡、选择、插入排序，时间复杂度都是O(n^2),适用于小规模数据排序，本篇博客中将介绍归并排序和快速排序，适用于大规模的数据。

归并排序

原理

归并排序的使用的是分治思想，将一个数组分解成两个数组，在对前后两个部分进行排序后，在将两部分进行合并，就实现了数组的排序。排序过程如下图所示：

归并排序采用了分治的思想，分治通过递归来实现；递归算法的关键是推导出递推公式，然后找到终止条件：

• 递推公式

merge_sort(p,r) = merge(merge_sort(p,q),merge_sort(q+1,r));
merge_sort(p,r) 表示的是对下标为p到r的数组进行排序，
merge_sort(p,q)和merge_sort(q+1,r)数组前后两部分分别进行排序；
采用merge方法，将两个排序好的子数组进行排序即可；

• 终止条件

p>=r

merge是如何对两个已排序的数组进行排序？
首先，申请一个大小为r-p+1的临时数组tmp;
设定两个游标i，j分别指向A[p…q]和A[q+1…r]的第一个元素，在比较这两个元素A[i]和A[j],如果A[i]<=A[j],就把A[i]放入临时数组中，并且i后移一位，否则就是将A[j]放入数组tmp中，j后移一位；直到一个数组中的所有元素放入到数组tmp之后，再把另一个数组的剩余的元素以此加到tmp数组的末尾，最后在把tmp数组拷贝到原数组中A[p…r]中，即可。

归并排序代码

public class mergeSort {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数组长度:");
        int n = sc.nextInt();
        System.out.println("请输入数组:");
        int[] a = new int[n];
        for(int i = 0;i<n;i++)
        {
            a[i] = sc.nextInt();
        }
        mergeSortInternally(a,0,n-1);

        for(int i=0;i<n;i++)
        {
            System.out.println(a[i]+" ");
        }
    }

    //递归调用函数
    public static void mergeSortInternally(int[] a,int p,int r){
        //递归终止条件
        if(p>=r) return;
        int q = p+(r-p)/2;
        mergeSortInternally(a,p,q);
        mergeSortInternally(a,q+1,r);
        //最后将前后两部分在进行排序
        merge(a,p,q,r);
    }
    //merge排序函数
    public static void merge(int[] a,int p,int q,int r){
        int[ ] tmp = new int[r-p+1];  //创建临时数组
        int i = p;
        int j = q+1;
        int k = 0;//tmp数组的下标
        while(i<=q&&j<=r)
        {
            if(a[i]<=a[j])
            {
                tmp[k++] = a[i];
                i++;
            }else{
                tmp[k++] = a[j];
                j++;
            }
        }
        //判断两个数组中哪个还有剩余元素
        int start = i;
        int end = q;
        if(j<=r) {
            start = j;
            end = r;
        }
        //将剩余数组中的元素拷贝至temp数组中
        while(start <= end){
            tmp[k++] = a[start++];
        }
        //再将tmp数组中的元素全部拷贝到数组A中
        for(i = 0;i<=r-p;i++)
        {
            a[i+p] = tmp[i];
        }
    }
}

性能分析

• 归并排序是稳定的排序算法，稳定的关键在于merge函数，在合并的过程中如果A[p…q]和A[q+1…r]之间有值相同的元素，就可以先把A[p…q]中的元素放入到tmp数组中，就保证了值相同的元素在合并前后的顺序不变；
• 归并排序的时间复杂度是O(nlog(n));
• 归并排序不是原地排序，空间复杂度是O(n);

快速排序

原理分析

快速排序(Quicksort)：排序数组下标从p到r的一组数据，选择p到r之间的任意一个数据作为privot(分区点)，遍历p到r之间的数据，将小于privot的放到左边，将大于privot的放到右边，将privot放到中间；

采用分治递归的思想分别递归排序下标从p到q-1和q+1到r之间的数据，直到区间缩小为1，就是所有的数据都有序了。

递推公式：
quick_sort(p...r)=quick_sort(p...q-1)+quick_sort(q+1...r);
终止条件：
p>=r

快速排序中需要一个partition()分区函数，随机选择一个privot对A[p…r]分区，函数返回privot的下标；通过游标i将A[p…r-1]分为两部分，A[p…i-1]都是小于privot的，暂且叫"已处理区间",A[i…r-1]就是未处理区间；每次从未处理区间A[i…r-1]中取出一个元素A[j],与privot进行对比，如果小于privot,则将其加入已处理区间的尾部，就是A[i]的位置；

快速排序代码

import java.util.Scanner;

public class quickSort {
    public static void main(String[] args){
        Scanner sc  = new Scanner(System.in);
        System.out.println("请输入数组大小:");
        int N = sc.nextInt();
        System.out.println("请依次输入数组中的元素:");
        int[] a = new int[N];
        for(int i=0;i<N;i++)
            a[i] = sc.nextInt();
        quickSortInternally(a,0,N-1);
        for(int i=0;i<N;i++)
            System.out.println(a[i]+" ");
    }
    //快排递归函数，p,r为下标
     public static void quickSortInternally(int[] a,int p,int r){
         if(p>=r) return;
         int q = partition(a,p,r);//获取分区点
         quickSortInternally(a,p,q-1);
         quickSortInternally(a,q+1,r);
     }
     //获取分区点函数
     public static int  partition(int[] a,int p,int r){
         int privot = a[r];
         int i = p;
         for(int j = p;j<=r;j++)
         {
             if(a[j]<privot)
             {
                 swap(a,i,j);
                 i++;
             }
         }
         swap(a,i,r);
         return i;
     }

     //交换
    public static void swap(int[] a,int i,int j){
         int temp = a[i];
         a[i] = a[j];
         a[j] = temp;
    }
}

性能分析

• 快排是一种原地、不稳定排序算法；
• 快排的时间复杂度是O(nlogn),只有在极端情况下，才会退化成O(n^2);

解答开篇

选择数组区间A[0…n-1]的最后一个元素A[n-1]作为pivot，对数组A[0…n-1]原地分区，这样数组就分成了三部分，A[0…p-1]、A[p]、A[p+1…n-1]；

如果p+1=K，那A[p]就是要求解的元素；如果K>p+1, 说明第K大元素出现在A[p+1…n-1]区间，我们再按照上面的思路递归地在A[p+1…n-1]这个区间内查找。同理，如果K

代码

import java.util.Scanner;

public class kthSmallest {
      public static int kthSmallest(int[] a,int k ){
        if(a==null||a.length<k)
            return -1;
        //分区函数
        int partition = partition(a,0,a.length-1);
        while(partition+1!=k)
        {
            if(partition+1<k){
                partition = partition(a,partition+1,a.length-1);
            }else{
                partition = partition(a,0,partition-1);
            }
        }
        return a[partition];
    }
    //设定分区函数
    public static int partition(int[] a,int p,int r){

        int privot = a[r];
        int i=p;

        for(int j=p;j<r;j++){
            if(a[j]<=privot){
                swap(a,i,j);
                i++;
            }
        }
        swap(a,i,r);
        return i;
    }
    public static void swap(int[] a,int i,int j){
        if(i==j)
            return;
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}