Tipo rápido de algoritmo clássico

Cena aplicável:

Os subproblemas são da mesma natureza do problema original

Os subproblemas são independentes uns dos outros (diferentes da programação dinâmica)

Caso clássico 1: pesquisa binária

Idéia básica: a premissa é fornecer um array ordenado e, em seguida, realizar uma pesquisa binária.

Caso clássico 2: classificação rápida

Ideia básica:

1. Selecione um elemento pivô (o primeiro elemento)
2. Dois ponteiros dianteiro / traseiro, apontando para o início e o fim, respectivamente
3. Mova para trás para encontrar a primeira ocorrência de um valor menor que o pivô do elemento de referência
   Mova para frente para encontrar a primeira ocorrência de um valor maior que o pivô do elemento de referência
   
4. Altere os valores dos dois elementos e continue a mover o ponteiro. O objetivo é tornar a metade esquerda do último ponteiro sobreposto menor do que o pivô do elemento de referência e a metade do ponteiro é maior do que o pivô do elemento de referência
   até a frente == traseiro
   
5. Troque o elemento onde o ponteiro atual está localizado com o elemento pivô, de modo que a metade esquerda seja toda menor que o pivô do elemento de referência e a outra metade seja maior que o pivô do elemento de referência
   
6. Neste momento, de acordo com a ideia do algoritmo de divisão e conquista, o array é dividido em duas partes [2, 3, 1] e [6, 7, 5, 8] e, em seguida, classificado recursivamente novamente.
   

Código

/*
    快排: 找到index后，快排转化成了分治算法
    1. 先找到中间索引 index
    2. quickSort(Array, 0, index - 1);
    3. quickSort(Array, index + 1, end)
*/
#include <stdio.h>
#include <stdlib.h>

int arr[] = {4,7,6,5,3,2,8,1};

int GetIndex(int* arr, int low, int hight) {
    int pivot = low;
    int front = low;
    int rear = hight;
    int tmp=0;
    while (front != rear)
    {
        if(arr[rear] > arr[pivot] ) {
            rear--;
        }
        else {
            if(arr[front] < arr[pivot]) {
                front++;
            }
            else {
                tmp = arr[front];
                arr[front] = arr[rear];
                arr[rear] = tmp;
                rear--;
            }
        }   
    }
    
    tmp = arr[pivot];
    arr[pivot] = arr[front];
    arr[front] = tmp;
    return front;
}

void quickSort(int* arr, int low, int hight) {
    if(low> hight) {
        return;
    }
    int index = GetIndex(arr, low, hight);
    quickSort(arr, low, index - 1);
    quickSort(arr, index + 1, hight);
}

int main() {
    quickSort(arr, 0, sizeof(arr)/sizeof(arr[0]) -1);
    for (int i = 0; i < sizeof(arr)/sizeof(arr[0]); ++i) {
        printf("%d\t",arr[i]);
    }
    printf("\n");
}

Fácil de cometer erros

Ao mover o ponteiro, você precisa mover primeiro para trás e depois para frente. Caso contrário, alguns elementos da matriz estarão na ordem errada.

Conforme mostrado na figura acima, se você mover a frente primeiro, quando o valor do pivô for trocado no final, 6 e 4 serão trocados, então a metade esquerda do valor da matriz neste momento não será menor do que o pivô 4, então você não pode mover o ponteiro frontal primeiro