Algoritmo básico Java de classificação rápida (classificação rápida)

Classificação rápida (classificação rápida)

1. Introdução do algoritmo (recursivo)

Primeiro, confirme um valor de corte (Use o número do meio aqui) e, em seguida, divida a matriz em duas partes pelo valor de limite.
Use os ponteiros esquerdo e direito para percorrer, o ponteiro esquerdo aponta para os dados maiores que o valor de corte, o ponteiro direito aponta para os dados menores que o valor de corte e, em seguida, os ponteiros esquerdo e direito trocam dados. Após a troca, o ponteiro esquerdo se move para frente e o ponteiro direito se move para trás
Coloque os dados menores do que o valor de corte à esquerda do valor de corte e coloque os dados maiores que o valor de corte à direita do valor de corte.
Em seguida, pegue um valor de corte em cada um dos lados esquerdo e direito e também coloque os dados menores que o valor de corte à esquerda do valor de corte e coloque os dados maiores que o valor de corte à direita do valor de corte.

2. Exemplo de demonstração

Matriz original: [117, 101, 106, 100, 112, 60, 90, 110]

Valor de corte: 100

O ponteiro esquerdo aponta para: 117

Pontos do ponteiro direito: 60

Então troque

Após a troca: [90, 101, 106, 100, 112, 60, 117, 110]

Repita a execução, sabendo que o lado esquerdo do valor de corte é menor que o valor de corte e o lado direito do valor de corte é maior que o valor de corte.

Resultado da execução: [90, 60, 100, 106, 112, 101, 117, 110]

Agora, o ponteiro esquerdo aponta para o subscrito: 3

Agora, o ponteiro direito aponta para o subscrito: 2

Em seguida, repita o processo acima com a matriz [0, ponteiro esquerdo-1]

Em seguida, repita o processo acima com o array [ponteiro direito + 1, 7]

Veja o diagrama para detalhes

3. Diagrama

Diagrama de classificação rápida

4. Implementação do código

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);
        }
    }
}