数据结构----排序算法（6）：快速排序详解及代码实现

6.0 概述

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

分治法：

快速排序也属于交换排序，每一轮挑选一个基准元素，并让其他比它大的元素移动到数列的一边，比它小的元素移动到数列的另一边，从而把数列拆成了两个部分。

6.1 算法描述

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

 

• 从数列中挑出一个元素，称为 “基准”（pivot）；（基准值特别影响性能）我们可以随机选择出一个基准元素与首字母交换
• 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
• 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

 

6.2 算法分析

最佳情况：平均情况：T(n) = O(nlogn)　

                    在分治法的思想下，原数列在每一轮都被拆分成两部分，每一部分在下一轮又分别拆分成两部分，直到不可再分为止。每一轮的比较和交换，需要把数组全部元素都遍历一遍，时间复杂度是O（n），平均情况下遍历logn轮，因此时间复杂度是O（nlong）

空间复杂度： O(logn) （栈占用的空间）

稳定性： 不稳定

6.3 元素的交换

1.双边交换法

     选定left指针和right指针分别指向队头和队尾，注意点：从right指针开始，让指针所指向的元素和基准元素做比较，如果大于或等于pivot，则指针向左移动，如果小于pivot，则right指针停止移动，切换到left指针移动，如果left指针大于pivot，则交换left和right的位置，否则，left指针向右移动。

代码：

public class QuickSort {
    public static void sort(int[] arr) {
        if (arr == null || arr.length <= 1) return;
        // 包左不包右
        quickSort(arr, 0, arr.length);
    }

    private static void quickSort(int[] arr, int low, int high) {
        if (high - low <= 1) return;
        // 快速排序的主要操作
        int partition = partition(arr, low, high);//得到基准元素位置
        //根据基准元素，分成两部分递归
        quickSort(arr, low, partition);
        quickSort(arr, partition + 1, high);
        // print(arr);
    }
//双边循环法
    private static int partition(int[] arr, int low, int high) {
        int pivot = arr[low];//取第一个位置作为基准元素
        int left = low;
        int right = high-1;
        while (left < right) {
            while (left < right && arr[right] >= pivot) {
                right--;
            }
            arr[left] = arr[right];
            while (left < right && arr[left] <= pivot) {
                left++;
            }
            arr[right] = arr[left];
        }
        //privot赋值到指针重合点
        arr[left] = pivot;
        print(arr);
        return left;//返回指针重合点处
    }

    public static void print(int[] arr) {
        if (arr == null) return ;
        for(int i : arr) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
    public static void main(String[] args) {
        int[] arr = {6, 9, 1, 4, 5, 8,8 ,7, 0, 2, 3,10};
        System.out.print("排序前：");
        print(arr);
        sort(arr);
        System.out.print("排序后：");
        print(arr);
    }
}

2.单边交换法

与双边交换法比较，虽然双边更直观，但是代码实现比较繁琐，而单边法则简单多了，只从数组的一边进行遍历和交换。

思路：首先选定基准元素pivot。同时，设置一个mark指针指向数列起始位置，这个mark指针代表小于基准元素的区域边界。

 

 

 

 

 

代码： 

public class QuickSort {
    public static void sort(int[] arr) {
        if (arr == null || arr.length <= 1) return;
        // 包左不包右
        quickSort(arr, 0, arr.length);
    }

    private static void quickSort(int[] arr, int low, int high) {
        if (high - low <= 1) return;
        // 快速排序的主要操作
        int partition = partition(arr, low, high);//得到基准元素位置
        //根据基准元素，分成两部分递归
        quickSort(arr, low, partition);
        quickSort(arr, partition + 1, high);
        // print(arr);
    }

    private static int partition(int[] arr, int low, int high) {
        int pivot = arr[low];//取第一个位置作为基准元素
        int mark=low;
        for(int i=low+1;i<high;i++){
            if(arr[i]<pivot){
                //第一步：mark右移
                mark++;
                //第二步：交换元素
                int temp=arr[mark];
                arr[mark]=arr[i];
                arr[i]=temp;
            }
        }
        //mark处与第一个元素交换位置
        arr[low]=arr[mark];
        arr[mark]=pivot;
        return mark;
    }
    //单边排序法

    public static void print(int[] arr) {
        if (arr == null) return ;
        for(int i : arr) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
    public static void main(String[] args) {
        int[] arr = {6, 9, 1, 4, 5, 8,8 ,7, 0, 2, 3,10};
        System.out.print("排序前：");
        print(arr);
        sort(arr);
        System.out.print("排序后：");
        print(arr);
    }
}