Ordenação rápida
princípio
O algoritmo Quick Sort (Quick Sort), abreviado como quick sort, usa a ideia de dividir para conquistar. A ideia de classificação rápida é: se quisermos classificar a sequência entre m-> n, escolhemos qualquer um entre m -> n Um dado de elemento é usado como ponto de partição (Pivô), e então percorremos todos os elementos entre m-> n, colocamos os elementos menores que pivô à esquerda, os elementos maiores que pivô à direita e pivô ao meio, de modo que toda a sequência é Dividida em três partes, os elementos entre m-> k-1 são menores que o pivô, o meio é o pivô e os elementos entre k + 1-> n são maiores que o pivô. Então, de acordo com a ideia de recursão dividir e conquistar, a sequência de elementos do intervalo em ambos os lados é processada até que o intervalo seja reduzido a 1, o que significa que toda a sequência já está em ordem.
O algoritmo é descrito da seguinte maneira:
- Escolha um elemento da sequência e chame-o de "pivô";
- Reordene a sequência, todos os elementos menores que o valor de referência são colocados na frente da referência e todos os elementos maiores que o valor de referência ficam atrás da referência (o mesmo número pode ir para qualquer lado). Após a saída da partição, o benchmark está no meio da sequência. Isso é chamado de operação de partição;
- Classifique recursivamente as subseqüências de elementos menores que o valor de referência e as subseqüências de elementos maiores que o valor de referência até que o intervalo seja reduzido a 1.
Código
public class QuickSort {
public static void main(String[] args) {
int[] arr = {
5, 2, 6, 9, 0, 3, 4};
quickSort(arr,0,arr.length-1);
System.out.println(Arrays.toString(arr));
}
public static void quickSort(int[] arr, int begin, int end) {
if (arr.length <= 1 || begin >= end) {
return;
}
//进行分区得到分区下标
int pivotIndex = partition(arr, begin, end);
//分区左侧进行快排
quickSort(arr, begin, pivotIndex - 1);
//分区右侧进行快排
quickSort(arr,pivotIndex+1,end);
}
public static int partition(int[] arr, int begin, int end) {
//默认使用 最后一个元素作为基准点
int pivot = arr[end];
//定义分区后的pivot元素下标
int pivotIndex = begin;
for (int i = begin; i < end; i++) {
判断如果该区间内如果有元素小于 pivot 则将该元素从区间头开始一直向后填充 有点类似选择排序
if (arr[i] < pivot) {
if (i > pivotIndex) {
swap(arr,i,pivotIndex);
}
pivotIndex++;
}
}
swap(arr,pivotIndex,end);
//得到基准点
return pivotIndex;
}
//交换元素
public static void swap(int[] arr, int i, int j) {
int temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
}
1: Qual é a complexidade de tempo de classificação rápida?
A complexidade de tempo da classificação rápida é a melhor e a complexidade média é O (nlogn), apenas em casos extremos ela se tornará O (n ^ 2).
2: Qual é a complexidade do espaço de classificação rápida?
Através da implementação do código de agendamento rápido, descobrimos que o agendamento rápido não requer espaço de armazenamento adicional, e todas as operações podem ser concluídas no espaço estabelecido, portanto, a complexidade do espaço do agendamento rápido é O (1), o que significa que o agendamento rápido é um algoritmo de classificação no local.
3: O quicksort é um algoritmo de classificação estável?
Como o processo de particionamento envolve operações de troca, se houver dois elementos idênticos na matriz, como a sequência 6, 3, 5, 9, 4, após a primeira operação de particionamento, os dois 6 são opostos. A ordem mudará. Portanto, o quicksort não é um algoritmo de classificação estável.
4: Semelhanças e diferenças entre classificação rápida e mesclagem
Em primeiro lugar, a classificação e a mesclagem rápidas usam a ideia de dividir e conquistar a recursão. A operação de partição correspondente na classificação rápida. A fórmula recursiva e o código recursivo também são muito semelhantes, mas o processo de classificação por mesclagem é de baixo para cima , da parte para o todo., Lide primeiro com os subproblemas e depois mescle. A classificação rápida é o oposto: seu processo de processamento é de cima para baixo, do todo para a parte, primeiro particionando e, em seguida, lidando com os subproblemas. Embora a classificação por mesclagem seja um algoritmo de classificação estável com complexidade de tempo O (nlogn), é um algoritmo de classificação fora do lugar. O principal motivo é que a função de mesclagem não pode ser executada no local (na matriz). A classificação rápida pode realizar a classificação in-situ projetando funções de partição no local (in-array) inteligentes, que resolvem o problema de mesclagem e classificação ocupando muita memória.