面试总结：QuickSort 解析

Quick Sort

http://en.wikipedia.org/wiki/Quicksort

Quicksort, or partition-exchange sort, is a sorting algorithm developed by Tony Hoarethat, on average, makes O(n log n) comparisons to sort n items. In the worst case, it makes O(n²) comparisons, though this behavior is rare. Quicksort is often faster in practice than other O(n log n) algorithms.^[1] Additionally, quicksort's sequential and localized memory references work well with a cache. Quicksort is a comparison sort and, in efficient implementations, is not a stable sort. Quicksort can be implemented with an in-place partitioning algorithm, so the entire sort can be done with only O(log n) additional space used by the stack during the recursion.^[2]

 

1. 平均复杂度：O(nLogn)

  1 package Algorithms.sort;
  2 
  3 /*********************************************************
  4  * 
  5  * 08-722 Data Structures for Application Programmers
  6  * Lab 5 Comparing MergeSort with QuickSort
  7  * 
  8  * A simple QuickSort implementation
  9  * 
 10  *********************************************************/
 11 
 12 import java.util.*;
 13 
 14 public class QuickSort {
 15     //private static final int SIZE = 100000;
 16     private static final int SIZE = 10000;
 17     private static Random rand = new Random();
 18 
 19     public static void main(String args[]) {
 20         int[] array = new int[SIZE];
 21 
 22         for (int i = 0; i < SIZE; i++)
 23             //array[i] = rand.nextInt();
 24             array[i] = i;
 25         
 26         //int[] array = {3, 4, 6, 1, 7, 8, 6};
 27 
 28         // reversely ordered
 29         /*
 30         for(int i=0;i<SIZE; i++) array[i] = SIZE - i;
 31          */
 32 
 33         quickSort(array);
 34 
 35         // to make sure sorting works.
 36         // add "-ea" vm argument
 37         assert isSorted(array);
 38         
 39         System.out.println(isSorted(array));
 40         //printArray(array);
 41     }
 42     
 43     public static void printArray(int[] arr) {
 44         System.out.println();
 45         for(int i: arr) {
 46             System.out.println(i + " ");
 47         }
 48     }
 49 
 50     public static void quickSort(int[] arr) {
 51         recQuickSort(arr, 0, arr.length - 1);
 52     }
 53 
 54     private static void recQuickSort(int[] arr, int left, int right) {
 55         // Just the input parameter.
 56         if (arr == null || left >= right) {
 57             return;
 58         }
 59 
 60         // we just set the right node to be pivot.
 61         int pivPosition = partition(arr, left, right, arr[right]);
 62 
 63         recQuickSort(arr, left, pivPosition - 1);
 64         recQuickSort(arr, pivPosition + 1, right);
 65     }
 66     
 67     // partition the array and return the new pivot position.
 68     private static int partition(int[] arr, int left, int right, int pivot) {
 69         // set the pivot.
 70         int l = left - 1 ;
 71         int r = right;
 72 
 73         /*
 74            example: 
 75            let 6 to be the pivot.
 76 
 77            (1) At the beginning:
 78            3 4 6 1 7 8 6
 79           l            r
 80             
 81 
 82            (2) After the first while loop:
 83            3 4 6 1 7 8 6 
 84                l r  
 85 
 86            (3) swap them, then continue to move i and j:
 87            3 4 1 6 7 8 6 
 88                l r                 
 89 
 90            (3) swap them, then continue to move i and j:
 91            3 4 1 6 7 8 6 
 92                  l     pivot
 93                  r
 94            (4) swap the left and the pivot.
 95            3 4 1 6 7 8 6 
 96                  l     pivot           
 97 
 98         */
 99 
100         while (true) {
101             // Find the first element which does not fulfill the rule
102             // It will not move out of range because the right node is pivot.
103             // 使用< 很重要，这样可以避免l跑到pivot的位置，就是right的位置
104             //while (l < r && arr[++l] <= pivot);
105             while (arr[++l] < pivot);
106 
107             // Find the first element which does not fulfill the rule
108             // Don't need to move r to be left of LEFT.
109             while (r > l && arr[--r] > pivot);
110 
111             // If r <= l, means that all the elements is in the right place.
112             if (r <= l) {
113                 break;
114             }
115 
116             // Swap the first two elements that does not fit the rule.
117             swap(arr, r, l);
118         }
119         
120         // The l pointer point to the first element which is bigger than the pivot.
121         // So we can put the pivot just here. Because put a big or equal one in the last will not change the rule that:
122         // all the smaller one is in the left and the right one is in the right.
123         swap(arr, l, right);
124 
125         return l;
126     }
127 
128     // private helper method to swap two values in an array
129     private static void swap(int[] arr, int dex1, int dex2) {
130         int tmp = arr[dex1];
131         arr[dex1] = arr[dex2];
132         arr[dex2] = tmp;
133     }
134 
135     /**********************************************************
136      * Check if array is sorted. A simple debugging tool
137      **********************************************************/
138     private static boolean isSorted(int[] array) {
139         return isSorted(array, 0, array.length - 1);
140     }
141 
142     private static boolean isSorted(int[] array, int lo, int hi) {
143         for (int i = lo + 1; i <= hi; i++)
144             if (array[i] < array[i - 1])
145                 return false;
146         return true;
147     }
148 
149 }

View Code

 

2. Worst case: O(n^2)

以下代码展示了一个worst case:

当数列是有序，并且每次选择最右边的值，那么quicksort退化为O(n^2)的复杂度：

TEST CASE:

RESULT(因为递归层数太多直接导致Stack over flow):

 

3. 稳定性

QuickSort并不稳定

http://bbs.csdn.net/topics/60524397

证明去Quick Sort是不稳定的，只需举出其不是稳定的例子即可。
例：
待排序数组: int a[] ={1, 2, 2, 3, 4, 5, 6};
在快速排序的随机选择比较子阶段，若选择a[2]为比较子，即数组中的第二个2，而把大于等于比较子的数均放置在大数数组中，则a[1],即数组中的第一个2。那么数组中的两个2非原序。
若选择a[1]为比较子，而把小于等于比较子的数均放置在小数数组中，则数组中的两个2顺序也非原序
这就说明，Quick Sort是不稳定的。

4. GITHUB:

https://github.com/yuzhangcmu/LeetCode_algorithm/blob/dce0192fe4e3d551c72c7753e2da74df74987c27/sort/QuickSort.java