Quick Syt est une sorte d'échange de division proposé par Crahoare en 1962. L'idée de base de cette méthode est:
1. Premiez d'abord un numéro de la séquence comme numéro de référence.
2. Dans le processus de partitionnement, mettez tous les nombres plus grands que ce nombre à sa droite, et tous les nombres plus petits ou égaux à sa gauche.
3. Répétez la deuxième étape pour les intervalles gauche et droit jusqu'à ce qu'il n'y ait qu'un seul nombre dans chaque intervalle.
L'algorithme a une idée claire, mais si la valeur limite n'est pas bien gérée pendant le processus de division d'intervalle, il est facile de provoquer des bogues. Voici deux réflexions plus claires pour guider l'écriture du code de division d'intervalle.
Le premier type de pensée est la réflexion dite de la méthode de fouille des fosts. Ce qui suit consiste à analyser le processus de méthode de creusement de puits en analysant un exemple:
En prenant un tableau comme exemple, prenez le premier numéro dans l'intervalle comme numéro de référence.
Initialement, gauche = 0; à droite = 9; X = a [gauche] = 72
Étant donné que le nombre dans un [0] a été enregistré sur x, il peut être compris comme creusant un trou dans le tableau A [0], et d'autres données peuvent être remplies ici.
Commencez à droite et recherchez un nombre de <= x. De toute évidence, lorsque la droite = 8, si les conditions sont remplies, déterrez un [8] et remplissez-la dans la fosse précédente une [gauche]. Une telle fosse a [0] est résolue, mais une nouvelle fosse a [8] est formée. Que dois-je faire? Simple, trouvez le numéro pour remplir la fosse A [8]. Cette fois, commencez à partir de gauche et trouvez un nombre supérieur à X. Lorsqu'il est laissé = 3, remplissez les conditions, déterrez un [3] et remplissez-le dans la fosse précédente A [à droite];
Le tableau devient:
Répétez les étapes ci-dessus et le tableau final deviendra le formulaire suivant:
On peut voir que les nombres avant un [5] sont plus petits que lui, et les nombres après un [5] sont plus grands que lui. Remplissez X dans la fosse d'un [5] et les données deviennent:
Par conséquent, répétez les étapes ci-dessus pour les deux sous-intervalles A [0… 4] et A [6… 9].
Résumé du nombre de trous creusés
1. I = l; j = r; Creusez le numéro de référence pour former la première fosse a [i].
2. J - de l'arrière à l'avant, trouvez le nombre plus petit que lui, déterrez ce nombre et remplissez la fosse précédente a [i].
3. I ++ trouve un nombre plus grand que de l'avant en arrière, et après l'avoir trouvé, déterrez ce nombre et remplissez-le dans la fosse précédente A [J].
4. Répétez les étapes 2 et 3 jusqu'à i == J, et remplissez le numéro de référence dans un [i].
Suivez cette méthode de partition, le code Java est rapidement trié comme suit:
Partition de classe publique {/ ** * En fonction de la division de base, la petite est à gauche et la grande est à droite, et la séquence entière n'est pas nécessaire pour être commandée * * @param ary * @param base * / static void tri (int [] ary, int bas) {int Left = 0; int droit = ary.length - 1; int LeftPoint = gauche, point droit = droit; while (true) {// Divisez en gauche et en droite à droite en même temps pour comparer, de gauche à droite, tandis que (point gauche <droit && ary [Leftpoint ++] <base); // Le point gauche est supérieur à la droite ou à l'Ary [Leftpoint gauche]> la base arrête de boucle while (Rightpoint> = Left && ary [point droit--]> base); // sur le système contraire.out.println ("L'indice qui doit être échangé à gauche:" + (LeftPoint-1)); System.out.println ("L'indice qui doit être échangé à droite:" + (point droit + 1)); // Les deux index qui ne remplissent pas les conditions sont obtenus ci-dessus, c'est-à-dire que les deux index qui doivent être échangés si (point gauche - 1 <point droit + 1) {// swap (Ary, point gauche - 1, point droit + 1); Util.printArray (ARY); point gauche = gauche; RightPoint = droite; } else {break; }}} Swap de void statique privé (int [] ary, int a, int b) {int temp = ary [a]; ary [a] = ary [b]; ary [b] = temp; } public static void main (string [] args) {int [] ary = util.generateInTarray (10); System.out.println ("Séquence originale:"); Util.printArray (ARY); Trier (Ary, 5); System.out.println ("tri:"); Util.printArray (ARY); }} résultat:
Séquence originale: [[2, 8, 4, 3, 7, 5, 1, 9, 0, 6] Index à échanger à gauche: 1 index à échanger à droite: 8 [2, 0, 4, 3, 7, 5, 1, 9, 8, 6] Échange à gauche: 4 index à échanger à droite: 6 [2, 0, 4, 3, 5, 5, 8, 6] Tri: [2, 0, 4, 3, 1, 5, 7, 9, 8, 6]
Un autre guide en pensant à la division d'intervalle:
Utilisez le premier élément du tableau comme valeur d'intervalle, partagez-le du deuxième élément jusqu'à ce que le résultat indiqué sur la figure soit formé.
Echangez ensuite les valeurs limites de droite et t de l'intervalle l <t pour former le résultat suivant:
De cette façon, vous pouvez écrire un code de tri rapide comme suit:
public void qsort (int array [], int Left, int droit) {if (gauche <droit) {int key = array [gauche]; int high = à droite; int bas = gauche + 1; while (true) {while (Low <= High && array [Low] <= key) Low ++; tandis que (Low <= High && array [high]> = key) high--; if (bas> haut) pause; échange (tableau, bas, haut); } swap (tableau, gauche, haut); printArray (tableau); QSORT (tableau, gauche, haut-1); QSORT (tableau, élevé + 1, à droite); }}