快速排序

一、快速排序算法

快速排序（Quicksort）是对冒泡排序的一种改进。

二、算法思想

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
步骤如下：

1.找到数组中的一个数为基准（一般是数组中的第一个数），然后从右向左找到第一个比基准数小的数，交换位置
2.然后以当前位置，从左到右的找到第一个比基准数大的数，交换位置
3.重复步骤1和2，直到左右两个位置相等，然后把基准数存入当前位置，此时 基准数左边的数字 <=基准数 <=基准数右边的数字
4.然后以当前基准数位置为分界，分为左右两个数组，进行排序，循环执行步骤1,2和3。
5.如果可排序区间只有一个元素，则说明当前循环排序完成

三、代码实现

package xzg.algorithm;

/**
 * 快速排序
 */
public class QuickSort {

    public static void main(String[] args) {
//        int[] heights = {181, 169, 187, 166,150,172, 163, 191, 189, 182};
        int[] heights = {5, 7, 1, 6, 8, 6};
        quickSortArr(heights, 0, heights.length - 1);
        System.out.println("------排序完成-------");
        // 输出排序后的结果
        for (int height : heights) {
            System.out.print(height + " ");
        }
    }


    /**
     * @param array 指定的数组
     * @param start 需要快速排序的数组索引起点
     * @param end   需要快速排序的数组索引终点
     */
    public static void quickSort(int[] array, int start, int end) {
        System.out.println("------排序前-------");
        for (int height : array) {
            System.out.print(height + " ");
        }
        System.out.println();
        // i相当于助手1的位置，j相当于助手2的位置
        int i = start, j = end;
        // 取第1个元素为基准元素
        int pivot = array[i];
        // 表示空位的位置索引，默认为被取出的基准元素的位置
        int emptyIndex = i;
        // 如果需要排序的元素个数不止1个，就进入快速排序(只要i和j不同，就表明至少有2个数组元素需要排序)
        while (i < j) {
            // 助手2开始从右向左一个个地查找小于基准元素的元素
            int jValue = array[j];
            while (i < j && pivot <= jValue) {
                j--;
            }
            if (i < j) {
                // 如果助手2在遇到助手1之前就找到了对应的元素，就将该元素给助手1的"空位"，j成了空位
                array[emptyIndex] = array[emptyIndex = j];
            }

            // 助手1开始从左向右一个个地查找大于基准元素的元素
            int iValue = array[i];
            while (i < j && iValue <= pivot) {
                i++;
            }
            if (i < j) {
                // 如果助手1在遇到助手2之前就找到了对应的元素，就将该元素给助手2的"空位"，i成了空位
                array[emptyIndex] = array[emptyIndex = i];
            }

            for (int height : array) {
                System.out.print(height + " ");
            }
            System.out.println();
        }
        // 助手1和助手2相遇后会停止循环，将最初取出的基准值给最后的空位
        array[emptyIndex] = pivot;
        System.out.println("------排序后-------");
        for (int height : array) {
            System.out.print(height + " ");
        }
        System.out.println();
        // =====本轮快速排序完成=====

        // 如果分割点i左侧有2个以上的元素，递归调用继续对其进行快速排序
        if (i - start > 1) {
            quickSort(array, 0, i - 1);
        }
        // 如果分割点j右侧有2个以上的元素，递归调用继续对其进行快速排序
        if (end - j > 1) {
            quickSort(array, j + 1, end);
        }
    }

    /**
     * 快速排序算法：

     * 算法思想：

     * 1.找到数组中的一个数为基准（一般是数组中的第一个数），然后从右向左找到第一个比基准数小的数，交换位置

     * 2.然后以当前位置，从左到右的找到第一个比基准数大的数，交换位置

     * 3.重复步骤1和2，直到左右两个位置相等，然后把基准数存入当前位置，此时 基准数左边的数字 <=基准数 <=基准数右边的数字

     * 4.然后以当前基准数位置为分界，分为左右两个数组，进行排序，循环执行步骤1,2和3
     * 5.如果可排序区间只有一个元素，则说明当前循环排序完成
     *
     * @param arr
     * @param start
     * @param end
     */
    public static void quickSortArr(int[] arr, int start, int end) {
        //数组左边位置，也是基准元素的初始化位置
        int left = start;
        //数组右边位置
        int right = end;
        //基准数
        int temp = 0;
        //当前排序区间只有一个元素
        if (left < right) {
            //以可排序区间的第一个数字为基准数据
            temp = arr[left];
            //当前排序区间元素大于1
            while (left != right) {
                while (left < right & temp <= arr[right]) {
                    //在当前排序区间中，从右向左找到第一个小于基准元素的数据所在的位置
                    right--;
                }
                //找到相关元素，把其赋值给原基准元素所在的位置
                arr[left] = arr[right];
                System.out.println("----------while---从右向左找到第一个小于基准元素---right=" + right+" left="+left);
                for (int height : arr) {
                    System.out.print(height + " ");
                }
                System.out.println();
                while (left < right && temp >= arr[left]) {
                    //在当前排序区间中，从左向右找到第一个大于基准元素的数据所在的位置
                    left++;
                }
                //找到相关元素，把其赋值给原基准元素所在的位置
                arr[right] = arr[left];
                System.out.println("----------while---从左向右找到第一个大于基准元素---right=" + right+" left="+left);
                for (int height : arr) {
                    System.out.print(height + " ");
                }
                System.out.println();
            }
            //基准元素归位,此时left=right
            arr[left] = temp;
            System.out.println("------排序后--基准元素归位---right=" + right+" left="+left);
            for (int height : arr) {
                System.out.print(height + " ");
            }
            System.out.println();
            //对基准元素右边的元素进递归排序
            quickSortArr(arr, right + 1, end);
            //对基准元素左边的元素进行递归排序
            quickSortArr(arr, start, left - 1);
        }
    }

}

输出结果

----------while---从右向左找到第一个小于基准元素---right=2 left=0
1 7 1 6 8 6 
----------while---从左向右找到第一个大于基准元素---right=2 left=1
1 7 7 6 8 6 
----------while---从右向左找到第一个小于基准元素---right=1 left=1
1 7 7 6 8 6 
----------while---从左向右找到第一个大于基准元素---right=1 left=1
1 7 7 6 8 6 
------排序后--基准元素归位---right=1 left=1
1 5 7 6 8 6 
----------while---从右向左找到第一个小于基准元素---right=5 left=2
1 5 6 6 8 6 
----------while---从左向右找到第一个大于基准元素---right=5 left=4
1 5 6 6 8 8 
----------while---从右向左找到第一个小于基准元素---right=4 left=4
1 5 6 6 8 8 
----------while---从左向右找到第一个大于基准元素---right=4 left=4
1 5 6 6 8 8 
------排序后--基准元素归位---right=4 left=4
1 5 6 6 7 8 
----------while---从右向左找到第一个小于基准元素---right=2 left=2
1 5 6 6 7 8 
----------while---从左向右找到第一个大于基准元素---right=2 left=2
1 5 6 6 7 8 
------排序后--基准元素归位---right=2 left=2
1 5 6 6 7 8 
------排序完成-------
1 5 6 6 7 8 
Process finished with exit code 0

四、算法分析

空间复杂度为O(log2n)
参考资料

https://www.cnblogs.com/MOBIN/p/4681369.html