Les nouvelles technologies changent constamment et la maîtrise de certaines fondations est une base solide pour l'apprentissage et la mise à jour constante à l'avenir. Je n'ai rien à faire récemment. Afin de revoir la structure de données que j'ai apprise auparavant, j'ai implémenté l'algorithme de tri dans la structure des données dans JS et une démo intégrée à la fin de cet article.
Tri simple
Tri bulle
Le tri des bulles est l'algorithme de tri le plus simple, avec un carré de la complexité temporelle n, et le code est le suivant:
fonction bubblesort (array) {for (var i = 0; i <array.length; i ++) {for (var j = array.length; j> 0; j--) {if (array [j] <array [j - 1]) {var temp = array [j - 1]; Array [J - 1] = Array [J]; Array [j] = temp; }} / * Résultats de sortie * / document.write ("Ceci est le + (i + 1) +" Deuxième boucle ・, le résultat est: "); pour (var k = 0; k <array.length; k ++) {document.write (array [k] +", ");} document.write (" <br /> "); / * le résultat de sortie fin * /}}Tri d'insert direct
Le tri à l'insertion directe est également un algorithme de tri simple, et la complexité du temps est également au carré par N, mais les performances sont légèrement meilleures que le tri des bulles. Le code est le suivant:
fonction insertsort (array) {var temp; for (var i = 1; i <array.length; i ++) {var temp = array [i]; pour (var j = i; j> 0 && temp <array [j - 1]; j--) {array [j] = array [j - 1]; } Array [J] = Temp / * Output Result * / Document.write ("Th? + I +" Le résultat de la commande des passes est: ") pour (var n = 0; n <array.length; n ++) {document.write (array [n] +", ");} document.write (" <br /> ") / * Le résultat de sortie fin * /}}Sélectionner le tri
Le tri de sélection est également un algorithme de tri simple, avec une complexité temporelle de n carré, et les performances sont également légèrement meilleures que le tri des bulles. Le code est le suivant:
fonction selectSort (array) {var min, temp; ; pour (var i = 0; i <array.length; i ++) {min = i; pour (var j = i + 1; j <array.length; j ++) {if (array [min]> array [j]) min = j; } if (min! = i) {temp = array [i]; array [i] = array [min]; Array [min] = temp; } / * Résultats de sortie * / document.write ("+ i +" Le résultat de la commande des passes est: ") pour (var n = 0; n <array.length; n ++) {document.write (array [n] +", ");} document.write (" <r /> ") / * Le résultat de sortie se termine * /}}}Tri complexe
Toite de la colline
Le tri des collines est une mise à niveau du tri des insertions. En 1959, Hill a éclaté par la complexité temporelle de N carré en modifiant la comparaison par paire dans un tri simple pour régler la comparaison du saut à la fin de step-lap. Le tri des collines passe du meilleur Nlonn au pire carré N selon la complexité temporelle différente des tailles de pas. Le code est le suivant:
La fonction doit (array) {var incrément = array.length; var i var temp; // Stockez Var Count = 0; do {incment = math.floor (incrément / 3) + 1; pour (i = incrément; i <array.length; i ++) {if (array [i] <array [i - incrément]) {temp = array [i]; pour (var j = i - incrément; j> 0 && temp <array [j]; j - = incrément) {array [j + incrément] = array [j]; } Array [j + incrément] = temp; / * Résultat de sortie * / count ++; Document.Write ("<br /> + Count +" Le résultat de l'ordre des passes est: ") pour (var n = 0; n <array.length; n ++) {document.write (array [n] +", ");} / * Le résultat de sortie se termine * /}}} while (incrément> 1)}Tri de tas
Le tri de tas est une mise à niveau pour sélectionner le tri. En construisant en continu un grand tas supérieur ou un petit tas supérieur, en sélectionnant la plus grande ou plus petite valeur et en la mettant à l'avant de la file d'attente pour le tri. La complexité temporelle du tri des tas dans tous les cas est NLogn, le code est le suivant:
fonction heapsort (array) {var temp; var i; for (i = math.floor (array.length / 2); i> = 0; i--) {heapadJust (array, i, array.length - 1); // Créez le tableau du tableau dans un grand tas supérieur} pour (i = array.length - 1; i> = 0; i--) {/ * échangez le nœud racine * / temp = array [i]; array [i] = array [0]; Array [0] = temp; / * Le tableau restant continue d'être intégré à un grand tas supérieur * / tasaDJust (tableau, 0, i - 1); / * Résultat de sortie * / document.write ("<br /> + (array.length - i) .toString () +" Le résultat de la commande des passes est: ") pour (var n = 0; n <array.length; n ++) {document.write (array [n] +", ");} / * Le résultat de sortie est en fin de compte * /}} Le tableau // max est l'indice final de la fonction du tableau heapadjuste (array, start, max) {var temp, j; (temp> = array [j]) Break;Fusion
Le tri de fusion est le seul tri stable en tri complexe. Il trie en divisant puis fusion le tableau à tri. Le carré de la complexité du temps de tri des fusions est n. Le code est le suivant:
// Source Source Array // DEST Target Array // S Démarrer l'indice Cibles Fonction cible MSORT (Source, Dest, S, T) {var M; // Choisissez la valeur intermédiaire var dest2 = new Array (); if (s == t) {dest [s] = source [s]; } else {m = math.floor ((s + t) / 2); msort (source, dest2, m + 1, t); Merge (dest2, dest, s, m, t); / * Résultat de sortie * / document.write ("<br /> + ++ count +" Le résultat du tri de pass est: ") pour (var n = 0; n <dest.length; n ++) {document.write (array [n] +", ");} / * le résultat de sortie Endrations * /}} // Fusing Trew // Stimter de Small to Big // Source Original Array // Desris Deuxième array Indice // Fonction de longueur totale Merge (source, dest, s, m, n) {pour (var j = m + 1, k = s; j <= n && s <= m; k ++) {if (source [s] <source [j]) {dest [k] = source [s ++]; if (s <= m) {pour (var l = 0; l <= m - s; l ++) {dest [k + l] = source [s + l];}} if (j <= n) {for (var l = 0; l <= n - j; l ++) {dest [k + l] = source [j + l];Tri rapide
Le type rapide est le type connu le plus rapide, avec une complexité temporelle de NloGn, et le code est le suivant:
Var Count = 0; fonction QuickSort (tableau, bas, haut) {var temp; if (low <high) {var keypoint = QuickSorthELP (tableau, bas, haut); Count ++; Document.Write ("<br /> Terminal? + Count +" Le résultat de la commande de la commande est ?: ") pour (var l = 0; l <array.length; l ++) {document.write (array [l] +", ");} Quicksort (Array, Low, Keypoint - 1); Quicksort (Array, KeypInte + 1, High);}} Low, haut) {while (Low <High) {while (Low < Array [High] = Temp;} Retour bas;Le résumé ci-dessus de diverses méthodes de tri (implémentation JS) dans la structure de données 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.