经典排序算法--快速排序

一、快速排序的基本思想：

　　快速排序使用了分治的思想，通过一趟排序将待排序列分割成两部分，其中一部分记录的关键字均比另一部分记录的关键字小。之后分别对这两部分记录继续进行排序，以达到整个序列有序的目的。

二、快速排序的三个步骤

1) 选择基准：在待排序列中，按照某种方式挑出一个元素，作为 “基准”（pivot）；

2) 分割操作：以该基准在序列中的实际位置，把序列分成两个子序列。如果为升序，则此时，在基准左边的元素都比该基准小，在基准右边的元素都比基准大；而基准则在排序后正确的位置上。

3) 递归地对两个序列进行快速排序，直到序列为空或者只有一个元素；

三、选择基准元的方式

对于分治算法，当每次划分时，算法若都能分成两个等长的子序列时，那么分治算法效率会达到最大。也就是说，基准的选择是很重要的。选择基准的方式决定了两个分割后两个子序列的长度，进而对整个算法的效率产生决定性影响。

最理想的方法是，选择的基准恰好能把待排序序列分成两个等长的子序列。

方法一：固定基准元（基本的快速排序）

　　选取第一个元素或最后一个元素作为基准元。

public static void sortCommon(int[] data,int low,int high){
        if(high>low){
            //进行一次排序，将基准元放置在正确顺序的位置上，并确定当前基准元位置
            int key = getStandard(data, low, high);
            //分别将基准元左侧和基准元右侧当做一个序列从新进行排序，知道序列的长度为1
            sortCommon(data, low, key-1);
            sortCommon(data, key+1, high);
        }
    }
    
    public static int getStandard(int[] data,int low,int high){
        //将基准元提取出来
        int tmp = data[low];
        while (low<high) {
            //从右往左查询，查找第一个小于基准元的元素，并将其放置在data[low]位置
            while(low<high&&data[high]>=tmp){
                high--;
            }
            data[low] = data[high];
            //从左往右查询，查找第一个大于基准元的元素，并将其放置在data[high]位置
            while(low<high&&data[low]<=tmp){
                low++;
            }
            data[high] = data[low];
        }
        //基准元归为
        data[low] = tmp;
        return low;
    }

 

方法二：随机基准元

思想：取待排序列中任意一个元素作为基准元。

引入的原因：在待排序列是部分有序时，固定选取基准元使快排效率底下，要缓解这种情况，就引入了随机选取基准元。

    public static void sortRandom(int[] data,int low,int high){
        if(high>low){
            //进行一次排序，将基准元放置在正确顺序的位置上，并确定当前基准元位置
            getStandardRandom(data, low, high);
            int key = getStandard(data, low, high);
            //分别将基准元左侧和基准元右侧当做一个序列从新进行排序，知道序列的长度为1
            sortRandom(data, low, key-1);
            sortRandom(data, key+1, high);
        }
    }
    
    private static void getStandardRandom(int[] data, int low, int high) {
        Random r = new Random();
        int ran = low+r.nextInt(high-low);
        //将基准元提取出来
        swap(data, low, ran);
    }

 

方法三：三数取中

引入的原因：虽然随机选取基准时，减少出现不好分割的几率，但是还是最坏情况下还是O(n^2），要缓解这种情况，就引入了三数取中选取基准。

分析：最佳的划分是将待排序的序列分成等长的子序列，最佳的状态我们可以使用序列的中间的值，也就是第N/2个数。可是，这很难算出来，并且会明显减慢快速排序的速度。这样的中值的估计可以通过随机选取三个元素并用它们的中值作为基准元而得到。事实上，随机性并没有多大的帮助，因此一般的做法是使用左端、右端和中心位置上的三个元素的中值作为基准元。显然使用三数中值分割法消除了预排序输入的不好情形，并且减少快排大约14%的比较次数。

举例：待排序序列为：8 1 4 9 6 3 5 2 7 0

左边为：8，右边为0，中间为6

我们这里取三个数排序后，中间那个数作为枢轴，则枢轴为6

注意：在选取中轴值时，可以从由左中右三个中选取扩大到五个元素中或者更多元素中选取，一般的，会有（2t＋1）平均分区法（median-of-(2t+1)，三平均分区法英文为median-of-three。

具体思想：对待排序序列中low、mid、high三个位置上数据进行排序，取他们中间的那个数据作为基准，并用0下标元素存储基准。

即：采用三数取中，并用0下标元素存储基准。

public static void sortMiddleOfThree(int[] data,int low,int high){
        if(high>low){
            //三数去中，并将中间数换到low位置上
            middleOfThree(data, low, high);
            //进行一次排序，将基准元放置在正确顺序的位置上，并确定当前基准元位置
            int key = getStandard(data, low, high);
            //分别将基准元左侧和基准元右侧当做一个序列从新进行排序，知道序列的长度为1
            sortMiddleOfThree(data, low, key-1);
            sortMiddleOfThree(data, key+1, high);
        }
    }
    private static void middleOfThree(int[] data, int low, int high) {
        int middle = (high-low)/2+low;
        if (data[middle] > data[high])
        {
            swap(data, middle, high);
        }
        if (data[low] > data[high])
        {
            swap(data, low, high);
        }
        if (data[middle] > data[low])
        {
            swap(data, middle, low);
        }      
    }

四.  两种优化的方法

优化一：当待排序序列的长度分割到一定大小后，使用插入排序

原因：对于很小和部分有序的数组，快排不如插排好。当待排序序列的长度分割到一定大小后，继续分割的效率比插入排序要差，此时可以使用插排而不是快排。

截止范围：待排序序列长度N = 10，虽然在5~20之间任一截止范围都有可能产生类似的结果，这种做法也避免了一些有害的退化情形。

—-摘自《数据结构与算法分析》Mark Allen Weiness 著

public static void sortThreeInsert(int[] data, int low, int high){
        if(high-low+1<10){
            insertSort(data);
            return;
        }else{
            //三数去中，并将中间数换到low位置上
            middleOfThree(data, low, high);
            //进行一次排序，将基准元放置在正确顺序的位置上，并确定当前基准元位置
            int key = getStandard(data, low, high);
            //分别将基准元左侧和基准元右侧当做一个序列从新进行排序，知道序列的长度为1
            sortThreeInsert(data, low, key-1);
            sortThreeInsert(data, key+1, high);
        }
    }

优化二：在一次分割结束后，可以把与Key相等的元素聚在一起，继续下次分割时，不用再对与key相等元素分割

举例：

待排序序列 1 4 6 7 6 6 7 6 8 6

三数取中选取基准：下标为4的数6

转换后，待分割序列：6 4 6 7 1 6 7 6 8 6

             基准key：6

本次划分后，未对与key元素相等处理的结果：1 4 6 6 7 6 7 6 8 6

下次的两个子序列为：1 4 6 和 7 6 7 6 8 6

本次划分后，对与key元素相等处理的结果：1 4 6 6 6 6 6 7 8 7

下次的两个子序列为：1 4 和 7 8 7

经过对比，我们可以看出，在一次划分后，把与key相等的元素聚在一起，能减少迭代次数，效率会提高不少

具体过程：在处理过程中，会有两个步骤

第一步，在划分过程中，把与key相等元素放入数组的两端

第二步，划分结束后，把与key相等的元素移到枢轴周围

public static void sortThreeInsertGather(int[] data, int low, int high){
        if(high-low+1<10){
            insertSort(data);
            return;
        }else{
            //三数去中，并将中间数换到low位置上
            middleOfThree(data, low, high);
            //进行一次排序，确定基准元位置，并将和基准元相等的元素，一直数组的两侧
            //first 和last 用来计算基准元
            int first = low;
            int last = high;
            //left和right 用来记录和基准元相等的元素
            int left = low;
            int right = high;
            //leftLength和rightLength用来记录左右两侧各有多少和基准元相等的元素
            int leftLength = 0;
            int rightLength = 0;
            int tmp = data[first];
            while(first<last){
                while(first<last&&data[last]>=tmp){
                    if(data[last]==tmp){
                        swap(data, last, right);
                        right--;
                        rightLength++;
                    }
                    last--;
                }
                data[first] = data[last];
                while(first<last&&data[first]<=tmp){
                    if(data[first]==tmp){
                        swap(data, first, left);
                        left++;
                        leftLength++;
                    }
                    first++;
                }
                data[last] = data[first];
            }
            data[first] = tmp;
            
            //一次排序完成，将两侧与基准元相等的元素移到基准元旁边
            int i= first-1;
            int j = low;
            while (j < left && data[i] != tmp)
            {
                swap(data, i, j);
                i--;
                j++;
            }
            i = last + 1;
            j = high;
            while (j > right && data[i] != tmp)
            {
                swap(data, i, j);
                i++;
                j--;
            }
            sortThreeInsert(data, low, first-1-leftLength);
            sortThreeInsert(data, first+1+rightLength, high);
        }
    }
    

以下是全部的测试程序源码：

package sortDemo;

import java.util.Random;

public class QuickSort {
    
    public static void main(String[] args) {
        Random r = new Random();
        int[] data = new int[100];
        for (int i = 0; i < data.length; i++) {
            data[i] = r.nextInt(10);
        }
        Long startTime = System.currentTimeMillis();
        print(data);
        Long endTime = System.currentTimeMillis();
        //sortCommon(data, 0, data.length-1);
        //sortRandom(data, 0, data.length-1);
        //sortMiddleOfThree(data, 0, data.length-1);
        //sortThreeInsert(data, 0, data.length-1);
        sortThreeInsertGather(data, 0, data.length-1);
        print(data);
        System.out.println("排序用时:"+(endTime-startTime));
        
        
        
    }
    
    public static void sortCommon(int[] data,int low,int high){
        if(high>low){
            //进行一次排序，将基准元放置在正确顺序的位置上，并确定当前基准元位置
            int key = getStandard(data, low, high);
            //分别将基准元左侧和基准元右侧当做一个序列从新进行排序，知道序列的长度为1
            sortCommon(data, low, key-1);
            sortCommon(data, key+1, high);
        }
    }
    
    public static int getStandard(int[] data,int low,int high){
        //将基准元提取出来
        int tmp = data[low];
        while (low<high) {
            //从右往左查询，查找第一个小于基准元的元素，并将其放置在data[low]位置
            while(low<high&&data[high]>=tmp){
                high--;
            }
            data[low] = data[high];
            //从左往右查询，查找第一个大于基准元的元素，并将其放置在data[high]位置
            while(low<high&&data[low]<=tmp){
                low++;
            }
            data[high] = data[low];
        }
        //基准元归为
        data[low] = tmp;
        return low;
    }
    
    public static void sortRandom(int[] data,int low,int high){
        if(high>low){
            //进行一次排序，将基准元放置在正确顺序的位置上，并确定当前基准元位置
            getStandardRandom(data, low, high);
            int key = getStandard(data, low, high);
            //分别将基准元左侧和基准元右侧当做一个序列从新进行排序，知道序列的长度为1
            sortRandom(data, low, key-1);
            sortRandom(data, key+1, high);
        }
    }
    
    private static void getStandardRandom(int[] data, int low, int high) {
        Random r = new Random();
        int ran = low+r.nextInt(high-low);
        //将基准元提取出来
        swap(data, low, ran);
    }
    
    public static void sortMiddleOfThree(int[] data,int low,int high){
        if(high>low){
            //三数去中，并将中间数换到low位置上
            middleOfThree(data, low, high);
            //进行一次排序，将基准元放置在正确顺序的位置上，并确定当前基准元位置
            int key = getStandard(data, low, high);
            //分别将基准元左侧和基准元右侧当做一个序列从新进行排序，知道序列的长度为1
            sortMiddleOfThree(data, low, key-1);
            sortMiddleOfThree(data, key+1, high);
        }
    }
    private static void middleOfThree(int[] data, int low, int high) {
        int middle = (high-low)/2+low;
        if (data[middle] > data[high])
        {
            swap(data, middle, high);
        }
        if (data[low] > data[high])
        {
            swap(data, low, high);
        }
        if (data[middle] > data[low])
        {
            swap(data, middle, low);
        }      
    }
    
    public static void sortThreeInsert(int[] data, int low, int high){
        if(high-low+1<10){
            insertSort(data);
            return;
        }else{
            //三数去中，并将中间数换到low位置上
            middleOfThree(data, low, high);
            //进行一次排序，将基准元放置在正确顺序的位置上，并确定当前基准元位置
            int key = getStandard(data, low, high);
            //分别将基准元左侧和基准元右侧当做一个序列从新进行排序，知道序列的长度为1
            sortThreeInsert(data, low, key-1);
            sortThreeInsert(data, key+1, high);
        }
    }
    
    public static void sortThreeInsertGather(int[] data, int low, int high){
        if(high-low+1<10){
            insertSort(data);
            return;
        }else{
            //三数去中，并将中间数换到low位置上
            middleOfThree(data, low, high);
            //进行一次排序，确定基准元位置，并将和基准元相等的元素，一直数组的两侧
            //first 和last 用来计算基准元
            int first = low;
            int last = high;
            //left和right 用来记录和基准元相等的元素
            int left = low;
            int right = high;
            //leftLength和rightLength用来记录左右两侧各有多少和基准元相等的元素
            int leftLength = 0;
            int rightLength = 0;
            int tmp = data[first];
            while(first<last){
                while(first<last&&data[last]>=tmp){
                    if(data[last]==tmp){
                        swap(data, last, right);
                        right--;
                        rightLength++;
                    }
                    last--;
                }
                data[first] = data[last];
                while(first<last&&data[first]<=tmp){
                    if(data[first]==tmp){
                        swap(data, first, left);
                        left++;
                        leftLength++;
                    }
                    first++;
                }
                data[last] = data[first];
            }
            data[first] = tmp;
            
            //一次排序完成，将两侧与基准元相等的元素移到基准元旁边
            int i= first-1;
            int j = low;
            while (j < left && data[i] != tmp)
            {
                swap(data, i, j);
                i--;
                j++;
            }
            i = last + 1;
            j = high;
            while (j > right && data[i] != tmp)
            {
                swap(data, i, j);
                i++;
                j--;
            }
            sortThreeInsert(data, low, first-1-leftLength);
            sortThreeInsert(data, first+1+rightLength, high);
        }
    }
    
    
    
    public static void insertSort(int[] a){
        //从下标为1开始比较，知道数组的末尾
        for (int i = 1; i < a.length; i++) {
            int j;
            //将要比较的元素，拿出待比较过后再插入数组
            int tmp = a[i];
            //一次与前一元素比较，如果前一元素比要插入的元素大，则互换位置
            for (j = i-1; j >=0&&a[j]>tmp; j--) {
                a[j+1] = a[j];
            }
            //将比较的元素插入
            a[j+1] = tmp;
        }
    }
    
    public static void print(int[] a){
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
        System.out.println();
    }
    
    private static void swap(int[] data,int i,int j){
        if(i==j){
            return;
        }
        data[i] = data[i] + data[j];
        data[j] = data[i] - data[j];
        data[i] = data[i] - data[j];
    }
}

学习整理自：http://www.cnblogs.com/HuoAA/p/4338424.html