快速排序算法

1 快排思想

• 快速排序概述：快速排序算法中,每一次递归时以第一个数为基准数,找到数组中所有比基准数小的.再找到所有比基准数大的.小的全部放左边,大的全部放右边,确定基准数的正确位置
• 分治思想【从小到大排序】

1）设定一个基准数据（第一个数）；

2）先从右往左找，找一个比基准数小的数据

3）再 从左往右找，找一个比基准数大的数据

4）交换对应索引处的元素

5）循环操作上面2~4的步骤，结束的标志是：左右指针相遇

6）交换基准元素和指针相遇处的元素

2 快排图解

3 代码实现

import java.util.Arrays;

public class QuickSort {
    public static void main(String[] args) {
        int[] arr01 = {9, 6, 12, 5, 4, 98, 12, 0, 3, 45};
        System.out.println("排序前数组元素：" + Arrays.toString(arr01));
        quickSortMinToMax(arr01, 0, arr01.length - 1);
        System.out.println("排序后数组元素【从小到大】：" + Arrays.toString(arr01));

        int[] arr02 = {88, 12, 34, 14, 56, 89, 74, 31, 16, 55, 100};
        System.out.println("排序前数组元素：" + Arrays.toString(arr02));
        quickSort(arr02, 0, arr02.length - 1);
        System.out.println("排序后数组元素【从大到小】：" + Arrays.toString(arr02));
    }

    //快速排序:从小到大
    public static void quickSortMinToMax(int[] arr, int startIndex, int endIndex) {
        if (startIndex >= endIndex) {
            return;
        } else {
            int intitLeftIndex = startIndex;
            int initRightIndex = endIndex;
            endIndex = partQuickSort(arr, startIndex, endIndex, intitLeftIndex);

            quickSortMinToMax(arr, intitLeftIndex, endIndex - 1);
            quickSortMinToMax(arr, endIndex + 1, initRightIndex);
        }
    }

    private static int partQuickSort(int[] arr, int startIndex, int endIndex, int intitLeftIndex) {
        int baseNumber = arr[startIndex];

        while (startIndex < endIndex) {
            //查找比基准数小的元素
            while (baseNumber <= arr[endIndex] && startIndex < endIndex) {
                endIndex--;
            }
            while (baseNumber >= arr[startIndex] && startIndex < endIndex) {
                startIndex++;
            }
            int temp = arr[startIndex];
            arr[startIndex] = arr[endIndex];
            arr[endIndex] = temp;
        }
        //基准数归位
        arr[intitLeftIndex] = arr[endIndex];
        arr[endIndex] = baseNumber;
        return endIndex;
    }

    //快速排序：从大到小
    public static void quickSort(int[] arr, int startIndex, int endIndex) {
        if (startIndex >= endIndex) {
            return;
        } else {
            int leftIndex = startIndex;
            int rightIndex = endIndex;
            int baseNumber = arr[startIndex];

            //当左右指针没有相遇时，循环查找，也就是右指针索引大于左指针索引的时候
            while (leftIndex < rightIndex) {
                //从大到小排序，初始索引处元素为基准数，大的需要移动到前边，所以右索引先开始查找比基准数大的元素
                while (baseNumber >= arr[rightIndex] && leftIndex < rightIndex) {
                    rightIndex--;
                }
                //左指针开始移动，查找比基准数小的元素
                while (baseNumber <= arr[leftIndex] && leftIndex < rightIndex) {
                    leftIndex++;
                }
                //左右指针找到满足条件的元素后，两个指针处元素交换位置
                int temp = arr[rightIndex];
                arr[rightIndex] = arr[leftIndex];
                arr[leftIndex] = temp;
            }
            //直到左右指针相遇，此时将右指针位置元素和基准数交换位置，基准数前面的数都比基准数大，后边的都比基准数小
            arr[startIndex] = arr[rightIndex];
            arr[rightIndex] = baseNumber;

            //以基准数为界，将数组分为左右两部分，分别排序，原理相同，所以使用递归，当开始索引和结束索引相同时即为递归出口
            //左分组
            quickSort(arr, startIndex, rightIndex - 1);
            //右分组
            quickSort(arr, rightIndex + 1, endIndex);
        }
    }
}

运行结果
排序前数组元素：[9, 6, 12, 5, 4, 98, 12, 0, 3, 45]
排序后数组元素【从小到大】：[0, 3, 4, 5, 6, 9, 12, 12, 45, 98]
排序前数组元素：[88, 12, 34, 14, 56, 89, 74, 31, 16, 55, 100]
排序后数组元素【从大到小】：[100, 89, 88, 74, 56, 55, 34, 31, 16, 14, 12]