Le tri du tas fait référence à un algorithme de tri conçu à l'aide de la structure des données du tas. L'empilement est une structure qui est approximativement entièrement binaire et satisfait les propriétés de l'empilement: c'est-à-dire que la valeur ou l'indice des clés d'un nœud enfant est toujours plus petit que (ou supérieur à) son nœud parent.
La complexité du temps moyenne du tri du tas est de (nlogn).
Étapes d'algorithme:
1. Créez un tas h [0..n-1]
2. Échangez la tête de tas (maximum) et la queue de tas
3. Réduisez la taille du tas de 1 et appelez Shift_down (0). Le but est d'ajuster les données supérieures du nouveau tableau à la position correspondante.
4. Répétez l'étape 2 jusqu'à ce que la taille du tas soit 1
tas:
Le tas est en fait un arbre complètement binaire, et tout nœud non feuille de son nœud non-feuille satisfait ses propriétés: clé [i] <= key [2i + 1] && key [i] <= key [2i + 2] ou key [i]> = key [2i + 1] && key> = key [2i + 2] que le mot clé de la notation non-le bière n'est pas plus grand ou moins que ce qui n'est pas le but. Le tas est divisé en un grand tas supérieur et un petit tas supérieur. Une clé satisfaisante [i]> = clé [2i + 1] && key> = key [2i + 2] est appelée un grand tas supérieur. Une clé satisfaisante [i] <= key [2i + 1] && key [i] <= key [2i + 2] est appelée un petit tas supérieur. D'après les propriétés ci-dessus, nous pouvons voir que les mots clés en haut du grand tas supérieur sont certainement les plus grands de tous les mots clés, et les mots clés en haut du petit tas supérieur sont les plus petits de tous les mots clés.
Idée de tri de tas:
La fonctionnalité du plus grand mot-clé (mot-clé minimum) enregistré en haut du grand tas supérieur (petit tas supérieur) rend simple à sélectionner le plus grand enregistrement (enregistrement minimum) de désordre à chaque fois. L'idée de base est (Big Top Tas): 1) Construisez la séquence initiale de mots clés à tri (R1, R2… .rn) en un grand tas supérieur, qui est la zone désordonnée initiale; 2) Échangez l'élément de haut du tas r [1] avec le dernier élément r [n], puis obtenez une nouvelle zone désordonnée (R1, R2,… RN-1) et une nouvelle région ordonnée (RN) et satisfaire R [1,2… n-1] <= r [n]; 3) Étant donné que le nouveau tas de tas R [1] après l'échange peut violer les propriétés du tas, il est nécessaire d'ajuster la zone désordonnée actuelle (R1, R2,… RN-1) à un nouveau tas, puis d'échanger R [1] avec le dernier élément de la zone désordonnée à nouveau pour obtenir une nouvelle zone désordonnée (RN). Répétez ce processus jusqu'à ce que le nombre d'éléments dans la zone ordonnée soit N-1 et que l'ensemble du processus de tri soit terminé. Le processus de fonctionnement est le suivant: 1) Initialiser le tas: construire R [1..N] en tant que tas; 2) Échangez l'élément supérieur du tas R [1] de la zone actuelle non ordonnée avec le dernier enregistrement de l'intervalle, puis ajustez la nouvelle zone non ordonnée à un nouveau tas. Par conséquent, pour le tri du tas, les deux opérations les plus importantes sont de construire le tas initial et de régler le tas. En fait, la construction du tas initial est en fait un processus d'ajustement du tas, mais la construction du tas initial est d'ajuster tous les nœuds non-feuilles.
Un exemple d'illustration
Étant donné un tableau de mise en forme a [] = {16,7,3,20,17,8}, trier le trier. Tout d'abord, construisez un arbre binaire complet basé sur l'élément de tableau et obtenez
Ensuite, vous devez construire le tas initial, puis démarrer le réglage du dernier nœud non-feuille. Le processus d'ajustement est le suivant:
Après l'échange de 20 et 16, 16 entraîne que 16 ne répondent pas aux propriétés du tas, il doit donc être réajusté.
Cela donne le tas initial.
Lorsqu'il est ajusté en premier, il devient un gros tas supérieur.
Autrement dit, chaque ajustement consiste à sélectionner le plus grand dans le nœud parent, le nœud enfant gauche et le nœud enfant droit à échanger avec le nœud parent (après l'échange, le nœud enfant échangé peut provoquer l'échange du nœud enfant doit être ajusté à nouveau après chaque échange). Avec le tas initial, vous pouvez le trier.
À ce moment, 3 est situé en haut de la pile et les propriétés ne sont pas pleines de la pile. Vous devez vous ajuster et continuer à vous ajuster.
De cette façon, l'intervalle entier est déjà ordonné. D'après le processus ci-dessus, nous pouvons voir que le tri des tas est en fait une sorte de tri de sélection, un tri de sélection d'arbres. Mais afin de sélectionner directement l'ordre, afin de sélectionner l'enregistrement maximum dans R [1 ... N], les temps N-1 doivent être comparés, puis de sélectionner l'enregistrement maximum dans R [1 ... N-2], N-2 fois, il faut comparer. En fait, bon nombre de ces comparaisons N-2 ont été effectuées dans les comparaisons N-1 précédentes, et le tri de sélection des arbres utilise simplement les caractéristiques de l'arbre pour sauver certains des résultats de comparaison précédents, de sorte que le nombre de comparaisons peut être réduit. Pour les séquences de mots clés, au pire, chaque nœud doit comparer les temps log2 (n), de sorte que sa complexité de temps le pire des cas est NLogn. Le tri de tas est un tri instable et ne convient pas au tri avec moins de disques. Tant de choses ont été décrites ci-dessus. En bref, la pratique de base du tri des tas est: Tout d'abord, utilisez les données d'origine pour construire un grand (petit) tas comme zone non ordonnée d'origine, puis, chaque fois que l'élément de haut du tas est retiré et placé dans la zone ordonnée. Étant donné que l'élément supérieur du tas est retiré, nous avons mis le dernier élément dans le tas dans le haut du tas, de sorte que les propriétés du tas sont détruites. Nous devons réajuster le tas et continuer n fois, puis les éléments n dans la zone non ordonnés sont placés dans la zone ordonnée et le processus de tri est terminé.
(La pile de construction est du bas en haut)
Application pratique:
En pratique, nous effectuons un tri de tas pour obtenir la valeur maximale ou minimale dans certaines conditions. Par exemple: 10 valeurs maximales doivent être trouvées parmi 100 nombres. Par conséquent, nous définissons un tas de taille 10, construisons les dix premières données en 100 dans un petit tas supérieur (le haut du tas), puis les comparons avec le haut du tas des 11e données en 100 données. Si le haut du tas est plus petit que les données actuelles, le haut du tas est apparu, appuyez sur les données actuelles dans le haut du tas, puis déplacez les données du haut du tas vers une certaine position.
Code:
classe publique test0 {static int [] arr; // tableau du tas, tableau valide test public0 (int m) {arr = new int [m];} static int m = 0; static int size = 0; // utilisé pour marquer les données valides dans le tas public void addtosmall (int v) {// int [] a = le tas {16,4,5,9,1,10,11,12,13,14,15,2,3,6,7,8,111,222,333,555,66,67,54}; // La taille du tas est de 10 // arr = new int [10]; if (size <arr.length) {arr [size] = v; add_sort (size); // add_sort1 (size); size ++;} else {arr [0] = v; add_sort1 (0);}} public void imprimésmall () {for (int (0);}} public void imprimésMall () {for (int i = 0; i <size; i ++) {System.out.println (arr [i]);}} public void del () {size -; arr [0] = arr [9]; add_sort1 (0);} public void small (int index) {if (m <arr.length) {add_sort (index); m ++;} else {add_sort1 (index); m ++;}} public void add_sort (int index) {// petit tas supérieur, build tas / * * coordonnées du nœud parent: index * Left de gauche: index * 2 * Node droit: index * 2 + 1 * L'enfant gauche * Si le dernier du tableau est uniforme, c'est le bon enfant si le nœud enfant est plus grand que le nœud parent, l'échange de valeur est effectué. Si l'enfant droit est supérieur à l'enfant gauche, l'échange de valeur est effectué * * / int Par; if (index! = 0) {if (index% 2 == 0) {par = (index-1) / 2; if (arr [index] <arr [par]) {swap (arr, index, par); add_sort (par);} if (arr [index]> arr [par * 2]) {swap (arrond, par * 2); dex] <arr [par]) {swap (arr, index, par);} add_sort (par);}} else {par = index / 2; if (arr [index] <arr [par]) {swap (arr, index, par); add_sort (par);} if (arr [index] <arr, par * 2 + 1]) {swap (arr, index, index, index, index, index, index, index, index, index, index, Par * 2 + 1); if (arr [index] <arr [par]) {swap (arr, index, par);} add_sort (par);}}}} public void add_sort1 (int index) {// ajuster le tas supérieur / * ajuster le haut en bas * Tant que le nœud enfant est plus grand que l'index de la valeur du Node du parent, l'index * max = 0; if (gauche <10 && arr [gauche] <arr [index]) {max = gauche;} else {max = index;} if (droite <10 && arr [droite] <arr [max]) {max = droit;} if (max! = index) {swap (arr, max, index); add_sort1 (max);}}} TEST CODE: package big top haf; Importer java.util.scanner; public class main_test0 {public static void main (String args []) {scanner scan = new scanner (System.in); System.out.println ("(petit top0 top0 Test = new test0 (m); int [ {16,4,5,9,1,10,11,12,13,14,15,2,3,6,7,8}; for (int i = 0; i <a.length; i ++) {test.addtosmall (a [i]);} test.printmall ();}}}}}}}}}L'exemple de tri de tas Java ci-dessus (tas de big top, petit tas de top) est tout le contenu que je partage avec vous. J'espère que vous pourrez vous faire référence et j'espère que vous pourrez soutenir Wulin.com plus.