浅谈快速排序的二三应用

大家都知道快排算法，快速排序算法的应用是非常广泛的，这里举出几个例子，谈一谈快速排序算法的应用。快速排序的思想不仅用于单纯的排序问题，对于很多查找类问题，快排算法能达到最小的时间复杂度，是最优解法之一。

首先先java实现一个快速排序函数：

    private int partition(int[] arr, int l, int h){
        int p = arr[l];
        int i=l; int j = h+1;
        while(true){
            while(i!=h && arr[++i]<p);
            while(j!=l && arr[--j]>p);
            
            if(i >= j){
                swap(arr, i, j);
                break;
            }
        }
        swap(arr, l, j);
        return j;
    }

1. 求一个数组里面最小的k个数

通过调用快速排序的 partition() 方法，会返回一个整数 j ，要让得 a[l..j-1] 小于等于 a[j]，且 a[j+1..h] 大于等于 a[j]，此时 a[j] 就是数组的第 j 大元素。可以利用这个特性找出数组的第 K 个元素，这种找第 K 个元素的算法称为快速选择算法。这种算法时间复杂度为O(N) + O(1)。使用最小堆求解的话时间复杂度不变。代码如下：

    public List<Integer> GetLeastNumbers(int[] nums, int k){
        List<Integer> ret = new ArrayList<>();
        if(nums.length == 0 || k>nums.length || k<0)
        return new ArrayList<Integer>();
        
        findKthSmallest(nums, k-1);
        
        for (int i = 0; i < k; i++)
            ret.add(nums[i]);
        return ret;
    }
    
    private void findKthSmallest(int[] nums, int k) {
        int l = 0;
        int h = nums.length-1;
        
        while(l<h){
        int res = partition(nums, l, h);
        
        if(res == k){
            return;
            
        }else if(res<k){
            l= res+1;
        }else{
            h=res-1;
        }
        }        
    }

    private int partition(int[] arr, int l, int h){
        int p = arr[l];
        int i=l; int j = h+1;
        while(true){
            while(i!=h && arr[++i]<p);
            while(j!=l && arr[--j]>p);
            
            if(i >= j){
                swap(arr, i, j);
                break;
            }
        }
        swap(arr, l, j);
        return j;
    }

    private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
        
    }

2 求数组中出现次数超过一半的数

容易理解次数超过一半的那个数必然是这个数组的中位数，依次可以使用快排来寻找数组的中位数，时间复杂度为O（n），java代码如下所示

    public int MoreThanHalfNum(int[] nums){

        if(nums.length == 0 || nums == null)
        return 0;
        
        int ret = 0;
        int end = nums.length-1;
        int start = 0;
        int middle =  end/2;
        
        int index = partition(nums, start, end);
        
        while(index != middle){
            if(index < middle) index=partition(nums, index+1, end);
            if(index > middle) index=partition(nums, start, index-1);
        }
        
        ret = nums[middle];
     
        return ret;
    }

    private int partition(int[] arr, int l, int h){
        int p = arr[l];
        int i=l; int j = h+1;
        while(true){
            while(i!=h && arr[++i]<p);
            while(j!=l && arr[--j]>p);
            
            if(i >= j)
                break;
            
            swap(arr, i, j);
            
        }
        swap(arr, l, j);
        return j;
    }

    private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
        
    }

 时间复杂度为o（n）。