手撕代码 之 快速排序

1.实现快速排序算法

• 问题描述

  给定一个无序数组int[ ] a，使用快速排序算法进行排序。

• 解题思路

  对于快速排序，主要的解题思想就是分而治之。不论是从什么角度来理解，我们的方式都是在原数组中选择一个基准元素pivot，然后将小于pivot的元素全部移动到数组左侧，将大于pivot的元素全部移动到数组右侧，这样将数组分为两半，然后递归地对两侧分别继续进行排序，直到只有一个元素需要排序即可。
  为方便进行叙述，我们对数组int[ ] a进行排序，数组长度为len。
  • 思考角度1： 拆东墙补西墙
    我们将基准元素从数组中提取出来，将其位置空缺。首先从右向左遍历，将比第一个pivot小的元素填入空缺 位置，然后将该位置空缺；然后从左向右遍历数组，找到第一个比pivot大的元素填入新的空缺位置，继续将该位置空缺。依次类推进行下去，直到左右指针位置发生交叉，最后将最初提取出来的元素pivot填入最终的空缺位置，并以该位置将数组分为左右两侧。代码如下。

  public void _quicksort(int[] a, int _left, int _right){
        if(_left >= _right) return;
        int left = _left, right = _right;
        int pivot = a[left]; // 最初的pivot位置空缺
        while(left < right){
            while(a[right]>=pivot && right>left)
                right--;
            a[left] = a[right]; // 将右侧较小元素写入左侧空缺
            
            while(a[left]<=pivot && left

  • 思路2
    以上的思路已经很完整的描述了整个快速排序的思想，但是代码能不能更清晰明了一些呢？答案是肯定的。我们可以将对数组进行左右两半分割的代码提取出来写成一个函数，而这个函数的返回值正是数组左右两侧的分割位置，如下代码中的partition()。

  public void _quicksort(int[] a, int left, int right){
      if(left >= right)  return;
      int x = partiton(a, left, right); // 找到左右的分割点
      _quicksort(a, left, x-1);
      _quicksort(a, x+1, right);
  }
  
  public void quicksort(int[] a){
      int length = a.length;
      if(length == 0) return;
      _quicksort(a, 0, length-1);
  }
  

  那么这个partition()函数如何实现呢？从思路1的实现中也可以得到。下边直接上代码。

  public int partition(int[] a, int _left, int _right){
      if(_left >= _right) return _left;
      int left = _left, right = _right;
      int pivot = a[left]; // 最初的pivot位置空缺
      while(left < right){
          while(a[right]>=pivot && right>left)
              right--;
          a[left] = a[right]; // 将右侧较小元素写入左侧空缺
          
          while(a[left]<=pivot && left

• 思路3
  对于右侧的查找分界点的过程，以上两种思路均是从左右两侧进行搜索，我们也可以采用只从一侧进行搜索的方式。

初始状态时，pivot是最左侧位置left的元素，i指向left，j指向right。

从 i 右侧一个元素也就是 i+1 位置开始检测，如果它的值大于pivot，那么将其与 j 位置的元素进行互换，将 j 左移一个元素 j-- ，继续对 i+1 位置进行检测；而如果它的值小于pivot，直接对 i 右移一个元素 i++ 。

通过这种方式，使得比 pivot 大的元素全部都移到了数组的右侧，而比 pivot 小的元素全部都留在了数组左侧，实现了对数组进行分割的目的。

代码如下。

public static void quicksort_2(int[] a, int left, int right){
      if(left >= right)   return;
      int pivot = a[left];
      int i = left, j = right;
      while(i < j){
          if(a[++i]>pivot)
              swap(a, i--, j--);
      }
      swap(a, left, j);
      quicksort_2(a, left, j-1);
      quicksort_2(a, j+1, right);
}

public static void swap(int[] a, int i, int j){
      System.out.println("i: " + i + ", j: " + j);
      int temp = a[i];
      a[i] = a[j];
      a[j] = temp;
      Print(a);
}

2.快速排序拓展 之 数组中第K大（小）的元素

• 问题描述

  给定一个无序数组int[ ] a，找到数组中第K大（小）的元素。

• 解题思路

  不论是求第K大还是第K小，我们都可以通过 a.length-K 的方式进行转化，所以我们再次只探讨求第K小的元素。
  那么对于这个问题，最naive的想法很简单：我们只需要对数组进行从小到大进行排序，然后取出第K个元素就可以了。那么，能不能对其进行简化一下呢？
  或许我们仔细思考一下快速排序的算法过程，在每一轮的快速排序中，我们都会进行一次数组的左右分割。

  如果分割点恰好在第K个位置，那么这个位置的元素直接返回就OK了，right?
  那如果没有那么巧，分割点的位置在x(x!=K)。这种情况下，我们可以从以下两种情况来考虑：

  (1) x > K
  说明分割点左侧有超过K个数，而且这些数全部都是小于分割点位置的元素的。那么我们只需要继续从左侧继续寻找第K大的数不就可以了？

  (2) x < K
  说明分割点左侧只有x个元素不超过分割点元素，那么将这x个数刨除，我们只需要从剩下的元素中找到第(K-x)大的，就是我们要找的在整个数组中排在第K大的元素。
  代码如下，使用的分割方法是使用1.快速排序算法的思路3，因为其比较简洁，是我比较喜欢的方式。

  public static void swap(int[] a, int i, int j){
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
    
    public static int getRank_K(int[] a, int left, int right, int k){
        int i = left, j = right;
        int pivot = a[left];
        while(i < j){
            if(a[++i]>pivot)
                swap(a, i--, j--);
        }
        System.out.println("j: " + j);
        swap(a, left, j);
        if(j==k) return a[j];
        if(j < k)   return getRank_K(a, j+1, right, k); // 因为这里我们的数组下表并没有产生变化，所以这里仍然是K
        return getRank_K(a, left, j-1, k);
    }
    
    public static int rank_K(int[] a, int k){// a为非负整数数组
        int length = a.length;
        if(k >= length) return -1;
        
        return getRank_K(a, 0, length-1, k);
    }
  

3.快速排序拓展 之 数组中最大（小）的K个元素

• 问题描述

  给定一个无序数组int[ ] a，找到数组中最大（小）的K个元素。

• 解题思路

  不论是求第K大还是第K小，我们都可以通过 a.length-K 的方式进行转化，所以我们再次只探讨求最小的K个元素。
  对于这个问题，我们同样可以从快速排序的角度去思考：因为我们在快速排序的过程中，每次我们都会找到一个分割点，使得其左侧的元素都比它小，右侧的元素都比它大，那如果这个分割点恰好在位置（K-1），那从当前数组的起点到该位置是不是就是数组中最小的K个元素了呢？
  依照这个逻辑，再加上之前的代码，我们可以很容易地解决这个问题。

  public static void swap(int[] a, int i, int j){
    int temp = a[i];
    a[i] = a[j];
    a[j] = temp;
  }
    
  public static int partition(int[] a, int left, int right){
    int i = left, j = right;
    int pivot = a[left];
    while(i < j){
        if(a[++i]>pivot)
            swap(a, i--, j--);
    }
    swap(a, left, j);
    return j;
  }
    
  public static List getTopK(int[] a, int k){// a为非负整数数组
    List res = new ArrayList();
    int length = a.length;
    if(k>length || k<0 || length==0)    return res;
    int splitIindex = partition(a, 0, length-1);
    int start = 0, end = length-1;
    while(splitIndex != k-1){
      if(splitIndex > k-1){
        end = splitIndex - 1;
        splitIndex = partition(a, start, end);
      }else{
        start = splitIndex + 1;
        splitIndex = partition(a, start, end);
      }
    }
    for(int i=0; i