Comment utiliser la méthode de partition pour le tri rapide en java

La partie la plus difficile de la technique Java Quicksort est le partition Procédé. Cette méthode accepte deux paramètres: les indices faibles et élevées qui marquent la partie du réseau qui doit être triée. Le schéma de base de la partition méthode va quelque chose comme ceci:

1. Choisissez un point de pivot.

2. Mettre tous les éléments qui sont inférieure au point vers le côté gauche de la cloison de pivotement.

3. Déplacer tous les éléments qui sont plus que le point sur le côté droit de la partition de pivot.

4. Retour l'index du point de pivot.

La technique la plus courante pour le partitionnement du réseau est de maintenir deux variables d'index, nommé je et j, ce travail à partir de deux extrémités de la matrice vers le centre.

Premier, je commence au début de la rangée et se déplace vers l'avant jusqu'à ce qu'il rencontre une valeur qui est supérieure à la valeur de pivotement. alors j commence à l'extrémité opposée de la matrice et se déplace vers l'arrière jusqu'à ce qu'il trouve une valeur qui est inférieure au point de pivot.

À ce moment, la partition Procédé a une valeur qui est supérieure au point sur le côté gauche de la matrice de pivot et une valeur qui est inférieure au point sur le côté droit de l'ensemble de pivot. Alors il les swaps.

Ensuite, le cycle se répète: je est incrémenté jusqu'à ce qu'il trouve une autre valeur qui est supérieure à la valeur de pivotement, j est décrémenté jusqu'à ce qu'il trouve une autre valeur qui est inférieure à la valeur de pivot, et les éléments sont inversés. Ce processus se répète jusqu'à ce que j est inférieur à je, ce qui signifie que les indices ont franchi et le partitionnement est effectué.

Voici un code qui met tout ensemble:

public static partition int (int bas, int haute) {int = un pivot [faible] -int i = faible - 1 int j = 1 + haute-tout (i lt; j) {for (i ++ - a [i] lt; pivot- i ++) - pour (j --- un [j]> pivot- j -) - si (i lt; j) swap (i, j) - j-}} return

Notez que dans ce code, le réseau étant triés est un statique int tableau nommé un. Les extrémités hautes et basses de la partition d'être partitionnés sont passés en tant que paramètres, et la méthode commence par le choix du premier élément de la partition que la valeur pour le point de pivot. Ensuite, il initialise les variables d'index je et j à partir des paramètres.

Notez que 1 est soustrait de la valeur basse et que 1 est ajouté à la valeur haute. Les variables d'index prennent un pas en arrière dans le tableau avant le bouclage commence afin qu'ils puissent prendre un bon départ.

La tandis que boucle est utilisée pour indiquer le moment où la séparation est terminée. Il se répète tant que je est inférieur à j. Après l'arrêt de ces variables d'index, le cloisonnement est fait, et la valeur de j est renvoyé pour indiquer le point d'indice qui divise la partition gauche de la bonne partition.

Dans le corps de la tandis que boucle sont deux étrange bodyless pour boucles. Ces pour boucles ne sont pas des organismes parce que leur seul but est de déplacer leurs valeurs d'index jusqu'à ce qu'ils trouvent une valeur qui est soit inférieure ou supérieure à la valeur de pivot.

La première pour incrémente la boucle je variable d'index jusqu'à ce qu'il trouve une valeur qui est supérieure au point de pivotement. Ce pour boucle trouve la première valeur qui pourraient avoir besoin d'être déplacé de l'autre côté du tableau.

Ensuite, la seconde pour décrémente la boucle j variable d'index jusqu'à ce qu'il trouve une valeur qui est inférieure au point de pivot. Donc, cette boucle trouve une valeur qui peut avoir besoin d'être remplacée par la valeur trouvée par le premier pour boucle.

Enfin, la si contrôles de déclaration que les indices ont franchi. En supposant qu'ils ne l'ont pas, un échange méthode est appelée à échanger les éléments. La échange méthode est heureusement simple:

échange public static void (int i, int j) {int temp = a [i] -a [i] = a [j] -a [j] = tentation}

Cette méthode déplace le je élément d'une variable temporaire, déplace le j l'élément de je élément, et se déplace ensuite la variable temporaire à la j élément.