演算法筆記_015:快速排序（Java）

標籤：swap   mat   指標   while   隨機函數   16px   res   數組排序   相對   

 目錄

1 問題描述

2 解決方案

2.1 快速排序原理簡介

2.2 具體編碼

 

 

1 問題描述

給定一組資料，使用快速排序得到這組資料的非降序排列。

 

 

2 解決方案 2.1 快速排序原理簡介

引用自百度百科：

快速排序（Quicksort）是對冒泡排序的一種改進。

快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通過一趟排序將要排序的資料分割成獨立的兩部分，其中一部分的所有資料都比另外一部分的所有資料都要小，然後再按此方法對這兩部分資料分別進行快速排序，整個排序過程可以遞迴進行，以此達到整個資料變成有序序列。

 

具體排序過程：

設要排序的數組是A[0]……A[N-1]，首先任意選取一個資料（通常選用數組的第一個數）作為關鍵資料，然後將所有比它小的數都放到它前面，所有比它大的數都放到它後面，這個過程稱為一趟快速排序。值得注意的是，快速排序不是一種穩定的排序演算法，也就是說，多個相同的值的相對位置也許會在演算法結束時產生變動。

 

一趟快速排序的演算法是：

1）設定兩個變數i、j，排序開始的時候：i=0，j=N-1（PS：即i從數組前開始向後遍曆，j從數組後開始向前遍曆）；

2）以第一個數組元素作為關鍵資料，賦值給key，即key=A[0]；

3）從j開始向前搜尋，即由後開始向前搜尋(j--)，找到第一個小於key的值A[j]，將A[j]和A[i]互換；

4）從i開始向後搜尋，即由前開始向後搜尋(i++)，找到第一個大於key的A[i]，將A[i]和A[j]互換；（PS：3）和4）步核心思想就是i向後遍曆遇到大於A[0]的元素，停下來等待；j向前遍曆遇到小於A[0]的元素，停下來等待；然後交換此時的A[i]和A[j]的值；交換完後，i依舊自增遍曆，j依舊自減遍曆）

5）重複第3、4步，直到i=j； (3,4步中，沒找到合格值，即3中A[j]不小於key,4中A[i]不大於key的時候改變j、i的值，使得j=j-1，i=i+1，直至找到為止。找到合格值，進行交換的時候i， j指標位置不變。另外，i==j這一過程一定正好是i+或j-完成的時候，此時令迴圈結束）。

下面來看一個具體排序樣本：

給定一組資料：5,3,1,9,8,2,4,7存入數組中

 

快速排序效能分析：

 

2.2 具體編碼

 

package com.liuzhen.chapterFive;public class Quicksort {    /*     * 該函數功能使用快速排序返回數組A的非降序序列     * 輸入數組A[0..n]，其子數組為A[start..end]     */    public static void getQuicksort(int[] A,int start,int end){        if(start < end){            int s = HoarePartition(A,start,end);   //s是分裂位置，即排序結果序列的最終位置            getQuicksort(A,start,(s-1));            getQuicksort(A,(s+1),end);        }    }        /*     * 以數組第一個元素為中軸，對子數組進行劃分     * 返回分裂點在數組排序結果中的最終位置     */    public static int HoarePartition(int[] A,int start,int end){        int p = A[start];        int i = start+1;        int j = end;        if(i == j){            if(A[j] >= p)   //此時分裂點右方只有一個元素，且大於分裂點處值                return start;        }        while(i < j){            while(A[i] < p){                if(i == end)                    break;                i = i+1;            }            while(A[j] >= p){                    if(j == (start+1)){                    if(A[j] >= p)    //此時為分裂點右方全部是大於等於p的元素                        return start;                    break;                }                j = j-1;            }            swapArray(A,i,j);        }        swapArray(A,i,j);    //當i>=j撤換最後一次交換        swapArray(A,j,start);        return j;    }        /*     * 交換數組中兩個不同位置上的元素值     */    public static void swapArray(int[] A,int m,int n){        int temp = A[m];        A[m] = A[n];        A[n] = temp;    }        //初始化一個隨機數組    public static int[] initArray(int n){        int[] result = new int[n];        for(int i = 0;i < n;i++)            result[i] = (int)(Math.random()*100); //採用隨機函數隨機產生1~100之間的數        return result;                }        public static void main(String[] args){        int[] A = initArray(200);        getQuicksort(A,0,(A.length-1));        System.out.println();        for(int i = 0;i < A.length;i++){            if(i%10 == 0)                System.out.println();            System.out.print(A[i]+"\t");        }    }}

 

運行結果：

0    0    0    0    1    1    1    2    2    2    2    2    3    3    4    4    4    7    7    7    7    8    8    8    9    9    11    12    12    12    13    13    14    14    15    15    16    16    17    17    18    18    19    19    19    20    20    21    23    24    24    24    24    25    25    25    25    25    26    26    26    27    27    28    28    28    29    29    29    30    30    31    31    34    34    34    35    36    37    37    39    40    40    41    42    42    43    44    44    44    45    45    45    45    47    48    48    48    50    50    50    50    50    51    51    52    53    55    55    56    56    56    57    57    58    58    58    59    60    60    61    62    63    63    63    64    65    65    65    65    66    66    67    68    69    69    69    70    70    72    72    72    74    75    75    76    76    76    76    77    77    77    78    79    79    80    81    81    81    81    82    82    82    83    83    84    84    86    86    86    86    87    87    87    87    87    87    87    87    88    88    89    89    89    90    92    93    93    93    95    95    96    96    96    97    98    98    99    99    99    

 

演算法筆記_015:快速排序（Java）