面试总结：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)

package Algorithms.sort;

/*********************************************************
 * 
 * 08-722 Data Structures for Application Programmers
 * Lab 5 Comparing MergeSort with QuickSort
 * 
 * A simple QuickSort implementation
 * 
 *********************************************************/

import java.util.*;

public class QuickSort {
    //private static final int SIZE = 100000;
    private static final int SIZE = 10000;
    private static Random rand = new Random();

    public static void main(String args[]) {
        int[] array = new int[SIZE];

        for (int i = 0; i < SIZE; i++)
            //array[i] = rand.nextInt();
            array[i] = i;
        
        //int[] array = {3, 4, 6, 1, 7, 8, 6};

        // reversely ordered
        /*
        for(int i=0;i<SIZE; i++) array[i] = SIZE - i;
         */

        quickSort(array);

        // to make sure sorting works.
        // add "-ea" vm argument
        assert isSorted(array);
        
        System.out.println(isSorted(array));
        //printArray(array);
    }
    
    public static void printArray(int[] arr) {
        System.out.println();
        for(int i: arr) {
            System.out.println(i + " ");
        }
    }

    public static void quickSort(int[] arr) {
        recQuickSort(arr, 0, arr.length - 1);
    }

    private static void recQuickSort(int[] arr, int left, int right) {
        // Just the input parameter.
        if (arr == null || left >= right) {
            return;
        }

        // we just set the right node to be pivot.
        int pivPosition = partition(arr, left, right, arr[right]);

        recQuickSort(arr, left, pivPosition - 1);
        recQuickSort(arr, pivPosition + 1, right);
    }
    
    // partition the array and return the new pivot position.
    private static int partition(int[] arr, int left, int right, int pivot) {
        // set the pivot.
        int l = left - 1 ;
        int r = right;

        /*
           example: 
           let 6 to be the pivot.

           (1) At the beginning:
           3 4 6 1 7 8 6
          l            r
            

           (2) After the first while loop:
           3 4 6 1 7 8 6 
               l r  

           (3) swap them, then continue to move i and j:
           3 4 1 6 7 8 6 
               l r                 

           (3) swap them, then continue to move i and j:
           3 4 1 6 7 8 6 
                 l     pivot
                 r
           (4) swap the left and the pivot.
           3 4 1 6 7 8 6 
                 l     pivot           

        */

        while (true) {
            // Find the first element which does not fulfill the rule
            // It will not move out of range because the right node is pivot.
            // 使用< 很重要，这样可以避免l跑到pivot的位置，就是right的位置
            //while (l < r && arr[++l] <= pivot);
            while (arr[++l] < pivot);

            // Find the first element which does not fulfill the rule
            // Don't need to move r to be left of LEFT.
            while (r > l && arr[--r] > pivot);

            // If r <= l, means that all the elements is in the right place.
            if (r <= l) {
                break;
            }

            // Swap the first two elements that does not fit the rule.
            swap(arr, r, l);
        }
        
        // The l pointer point to the first element which is bigger than the pivot.
        // So we can put the pivot just here. Because put a big or equal one in the last will not change the rule that:
        // all the smaller one is in the left and the right one is in the right.
        swap(arr, l, right);

        return l;
    }

    // private helper method to swap two values in an array
    private static void swap(int[] arr, int dex1, int dex2) {
        int tmp = arr[dex1];
        arr[dex1] = arr[dex2];
        arr[dex2] = tmp;
    }

    /**********************************************************
     * Check if array is sorted. A simple debugging tool
     **********************************************************/
    private static boolean isSorted(int[] array) {
        return isSorted(array, 0, array.length - 1);
    }

    private static boolean isSorted(int[] array, int lo, int hi) {
        for (int i = lo + 1; i <= hi; i++)
            if (array[i] < array[i - 1])
                return false;
        return true;
    }

}

 

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