淺談快速排序的二三應用

 

大家都知道快排算法，快速排序算法的應用是非常廣泛的，這里舉出幾個例子，談一談快速排序算法的應用。快速排序的思想不僅用於單純的排序問題，對於很多查找類問題，快排算法能達到最小的時間復雜度，是最優解法之一。

首先先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）。