八大排序之快速排序

1、基本思想

　　快速排序是 一種基於交換的排序算法，是對冒泡排序的改進。它的基本思想是，經過一趟快速排序，將待排記錄分割成獨立的兩部分，其中一部分的關鍵字均比另外一部分小；在分別對這兩部分進行排序排序，直至整個序列有序。 

2、操做步驟

　　

　　1.將待排記錄分隔成獨立的兩部分，其中一部分的關鍵字均比另外一部分小。選取第一個元素的關鍵字爲支點，即進一次快速排序後，支點左邊的元素的關鍵字均不大於支點的關鍵字，支點右邊的元素的關鍵字不小於支點的關鍵字。將這部分操做封裝成一個函數。

　　　　1).用一個臨時變量儲存支點，這樣，就有一個空位在左邊，即支點的位置，用以存放從右側選取的小於支點的元素。

　　　　2).從右邊開始，尋找比支點大的元素，找到以後將其放到左邊的空位上，這樣，空位就到右邊了，用以存放從左側選取的大於支點的元素。

　　　　3).從左邊開始，尋找比支點小的元素，找到以後將其放到右邊的空位上，這樣，空位就到了左邊，用以存放從右側選取的小於支點的元素。

　　　　4).重複2）3）操做，知道整個記錄遍歷。最後將支點放回到空位上。

　　　　進行上述操做後，待排記錄就分割成了知足條件的兩部分，支點也移動到了合適的位置。

 

　　2.分別對上述兩部分繼續分割直至區間爲一。這是一個遞歸的過程。

　　　　

3、實現代碼

　　測試工具類 點擊這裏

package sort;

import sort.util.*;

/*
    快速排序思路：
    1.以某個元素爲支點，改變支點位置，使得支點左邊的值都不大於它，右邊的值都不小於它
    2.對以支點劃分的兩個區間進行上述操做，直到區間長度爲0
    
    時間複雜度：O(nlog2(n)),在數組基本有序時退化爲O(n2)
    空間複雜度：O(log2(n)),遞歸須要棧空間
    穩定性：    不穩定，跳躍式移動
*/
public class QuickSort implements ISort {
    
    //劃分，默認以a[left]爲支點,返回劃分後支點的位置
    private int partition(int[] a , int left , int right) {
        int t = a[left];                                  
        while(left < right) {                                      //挖坑填數法
            while(left < right && a[right] >= t) {right--;}        //一開始，坑在a[left],因此先找右邊符合條件的數來填
            if(left < right) {a[left++] = a[right];}                 //填坑a[left] ,如今坑在a[right]了
            while(left < right && a[left] <= t) {left++;}          
            if(left <right){a[right--] = a[left];}
        } 
        a[left] = t;
        return left;
    }
    
    //遞歸調用劃分，直到區間長度爲0
    private void quicksort(int[] a , int left , int right) {       
        if(left < right){
            int dividePoint = this.partition(a , left , right);
            quicksort(a , left , dividePoint - 1);
            quicksort(a , dividePoint + 1 , right);
        }
    }
    
     //便於統一接口回調 
    public void sort(int[] a) {                                  
        this.quicksort(a , 0 , a.length - 1);
    }
    
    public static void main(String[] args) {
        int[] array = RandomArrayGenerator.getRandomArray(100 , 30);
        SortTestHelper.test(new QuickSort() , array);
    }
    
}

 測試結果：

 

4、總結分析

  　時間複雜度：O(nlog n )，當待排記錄有序時會退化爲O(n2)

　  空間複雜度：O(1)

　  快速排序綜合而言是比較優秀的排序算法，但因爲跳躍式的記錄交換，致使不穩定。