Como usar o método de partição para quicksort em java

A parte mais difícil da técnica Java Quicksort é o divisória

método. Este método aceita dois parâmetros: os índices baixos e altos que marcam a parte da matriz que devem ser classificados. O esquema básico da divisória método é algo como isto:

Video: Como usar o algoritmo Quick Sort em java no netbeans (Exemplo)

  1. Escolher um ponto de articulação.

  2. Mover todos os elementos que são menos do que o ponto de articulação para o lado esquerdo da partição.

    Video: Método de Ordenação QuickSort

  3. Mover todos os elementos que são maiores do que o ponto de articulação para o lado direito da partição.

  4. Retornar o índice do ponto de articulação.

A técnica mais comum para dividir a matriz é para manter duas variáveis ​​de índice, com o nome Eu e j, que o trabalho a partir de ambas as extremidades da matriz na direcção do centro.

Video: Módulo_10_2012_2_Parte_6 - Ordenação por partição (Quicksort)

Primeiro, Eu começa no início da matriz e move-se para a frente até encontrar um valor que é maior do que o valor de pivô. Então j começa na extremidade oposta da matriz e move-se para trás até que encontra um valor que é menor que o ponto de articulação.

Nesse ponto, o divisória método tem um valor que é maior do que o ponto de articulação no lado esquerdo da matriz e um valor que é menor que o ponto de articulação no lado direito da matriz. Por isso, troca-los.

Video: 32- Quick Sort implementation in Java

Em seguida, o ciclo se repete: Eu é incrementado até que encontre um outro valor que é maior do que o valor de pivô, j é decrementado até que encontra um outro valor que é menor do que o valor de articulação, e os elementos são trocados. Este processo repete-se até que j é menos do que Eu, o que significa que os índices de ter atravessado o particionamento e é feito.

Aqui está algum código que coloca tudo junto:



partição int public static (int baixa, alta int) {int pivô = uma [baixa] -int i = baixo - 1-int j = alta + 1-tempo (i lt; j) {para (i ++ - a [i] lt; pivot- i ++) - para (j --- uma [j] gt; pivot- j -) - se (i lt; j) swap (i, j) -} retornar j-}

Observe que neste código, a matriz que está sendo classificada é uma estática int matriz chamada uma. As extremidades baixas e altas de partição para ser repartido são passados ​​como parâmetros, e o método começa por escolher o primeiro elemento na partição como o valor para o ponto de articulação. Em seguida, ele inicializa as variáveis ​​de índice Eu e j a partir dos parâmetros.

Note-se que 1 é subtraído do valor baixo e que uma é adicionado ao alto valor. As variáveis ​​índice de dar um passo para trás da matriz antes de o loop começa para que eles possam obter um bom começo.

o enquanto laço é utilizado para indicar quando o particionamento está terminado. Ele repete enquanto Eu é menos do que j. Após estas variáveis ​​índice de parar, o particionamento é feito, eo valor de j é retornado para indicar o ponto índice que divide a partição esquerda a partir da partição direita.

No corpo do enquanto circuito são dois sem corpo estranho para rotações. Estes para laços não têm corpos, porque o seu único propósito é mover seus valores de índice até encontrar um valor que é menor ou maior que o valor de pivô.

O primeiro para incrementa o circuito Eu índice variável até encontrar um valor que é maior do que o ponto de articulação. este para laço encontra o primeiro valor que pode precisar de ser movido para o outro lado da matriz.

Em seguida, o segundo para circuito diminui o j índice variável até encontrar um valor que é menor que o ponto de articulação. Portanto, este circuito encontra um valor que pode precisar ser trocado com o valor encontrado pelo primeiro para ciclo.

Finalmente, o E se instrução verifica se os índices de ter atravessado. Assumindo que eles não têm, um troca método é chamado para trocar os elementos. o troca método é misericordiosamente simples:

permuta public static void (int i, j int) {int temp = a [i] -a [i] = uma [j] -a [j] = temp-}

Este método move o Eu elemento para uma variável temporária, move o j elemento para o Eu elemento, e, em seguida, move-se a variável temporária para o j elemento.


Publicações relacionadas