Java基础算法之快速排序（Quick Sort）

1、算法介绍（递归）

1. 首先确认一个分界值（这里使用中间的数），然后通过分界值将数组分为左右两部分。
2. 使用左右指针进行遍历，左指针指向大于分界值的数据，右指针指向小于分界值的数据，然后左右指针进行交换数据，交换后左指针进行前移，右指针进行后移
3. 将小于分界值的数据放到分界值的左边，将大于分界值的数据放到分界值的右边。
4. 然后将左右两边各取一个分界值，同样将小于分界值的数据放到分界值的左边，大于分界值的数据放到分界值的右边。

2、举例演示

原数组：[117, 101, 106, 100, 112, 60, 90, 110]

分界值：100

左指针指向：117

右指针指向：60

然后进行交换

交换后：[90, 101, 106, 100, 112, 60, 117, 110]

重复执行，知道分界值左边全部小于分界值和分界值右边全部大于分界值。

执行结果：[90, 60, 100, 106, 112, 101, 117, 110]

此时左指针指向下标：3

此时右指针指向下标：2

然后再将 [0, 左指针 - 1] 数组重复上面过程

然后再将 [右指针 + 1, 7] 数组重复上面过程

详细见图解

3、图解

4、代码实现

package sort;

import java.util.Arrays;

/**
 * <p>
 *
 * </p>
 *
 * @author: D
 * @since: 2020/9/10
 * @version: 1
 */
public class QuickSortDemo {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    117, 101, 106, 100, 112, 60, 90, 110};
        quickSort(arr, 0, arr.length - 1);
        System.out.println("排序后的结果： " + Arrays.toString(arr));
    }

    private static void quickSort(int[] arr, int left, int right) {
    
    
        System.out.println();
        System.out.printf("遍历的数组范围[%d, %d]", left, right);
        //左右下标
        int leftIndex = left;
        int rightIndex = right;
        int pivot = arr[(left + right) / 2];
        System.out.println();
        System.out.println("基准值 = " + pivot);
        int temp;
        //让比pivot小的放到左边，大的放到右边
        while (leftIndex < rightIndex) {
    
    
            //左边寻找大于等于pivot的值才推出
            while (arr[leftIndex] < pivot) {
    
    
                leftIndex++;
            }
            //右边边寻找小于等于pivot的值才推出
            while (arr[rightIndex] > pivot) {
    
    
                rightIndex--;
            }
            //如果成立 说明pivot左右两边的值已经是小于等于大于小于pivot的值
            if (leftIndex >= rightIndex) {
    
    
                break;
            }
            System.out.println("交换前结果： " + Arrays.toString(arr));
            System.out.println("当前左指针：" + leftIndex + "，指向的数据：" + arr[leftIndex]);
            System.out.println("当前右指针 = " + rightIndex+ "，指向的数据：" + arr[rightIndex]);
            // 左指针没有超过右指针 然后将左指针和右指针进行交换
            //交换
            temp = arr[leftIndex];
            arr[leftIndex] = arr[rightIndex];
            arr[rightIndex] = temp;

            //如果交换完后发现arr[leftIndex] == pivot的值 将右指针前移
            if (arr[leftIndex] == pivot) {
    
    
                System.out.println("交换完后发现arr[rightIndex] == pivot的值 将左指针后移");
                rightIndex--;
            }
            //如果交换完后发现arr[rightIndex] == pivot的值 将左指针后移
            if (arr[rightIndex] == pivot) {
    
    
                System.out.println("交换完后发现arr[rightIndex] == pivot的值 将左指针后移");
                leftIndex++;
            }

            System.out.println("交换的结果： " + Arrays.toString(arr));
            System.out.println("交换后左指针 = " + leftIndex);
            System.out.println("交换后右指针 = " + rightIndex);
        }
        System.out.println("之后的左右指针");

        //左右指针相同 将右指针前移 左指针后移
        if (leftIndex == rightIndex) {
    
    
            System.out.println("左右指针相同 将右指针前移 左指针后移");
            leftIndex++;
            rightIndex--;
        }
        System.out.println("leftIndex：" + leftIndex);
        System.out.println("rightIndex：" + rightIndex);
        System.out.println("left: " + left);
        System.out.println("right: " + right);

        // 两个条件都不满足则排序完成
        if (left < rightIndex) {
    
    
            quickSort(arr, left, rightIndex);
        }
        if (leftIndex < right) {
    
    
            quickSort(arr, leftIndex, right);
        }
    }
}

5、执行结果

6、其他排序

选择排序（Selection Sort）
插入排序（Insertion Sort）
希尔排序（Shell Sort）
冒泡排序（Bubble Sort）
堆排序（Heap Sort）