Las nuevas tecnologías cambian constantemente, y dominar algunas bases es una base sólida para el aprendizaje y actualizar constantemente las tecnologías en el futuro. No tengo nada que hacer recientemente. Para revisar la estructura de datos que aprendí antes, implementé el algoritmo de clasificación en la estructura de datos en JS y una demostración integrada al final de este artículo.
Clasificación simple
Burbuja
La clasificación de burbujas es el algoritmo de clasificación más simple, con un cuadrado de la complejidad del tiempo n, y el código es el siguiente:
función 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]; matriz [j - 1] = array [j]; matriz [j] = temp; }} /* Resultado de salida* /document.write ("Este es el + (i + 1) +" Segundo bucle ・, el resultado es: "); for (var k = 0; k <array.length; k ++) {document.write (array [k] +", ");} document.write (" br /> "); /* El resultado de la salida termina* /}}}}}}}}}}}}}}}}}}}}}}}}}}}Sorteo de inserción directa
La clasificación de inserción directa también es un algoritmo de clasificación simple, y la complejidad del tiempo también está cuadrada por N, pero el rendimiento es ligeramente mejor que la clasificación de burbujas. El código es el siguiente:
function insertSort (array) {var temp; for (var i = 1; i <array.length; i ++) {var temp = array [i]; for (var j = i; j> 0 && temp <array [j - 1]; j--) {array [j] = array [j - 1]; } array [j] = temp /* resultado de salida* /document.write ("th? + i +" El resultado del orden de los pases es: ") para (var n = 0; n <array.length; n ++) {document.write (array [n] +", ");} document.write (" <Br /> ") /* El resultado de la salida resulta* /}}}}}}}}}}}}}}}}}Seleccionar clasificación
La clasificación de la selección también es un algoritmo de clasificación simple, con una complejidad de tiempo de N al cuadrado, y el rendimiento también es ligeramente mejor que la clasificación de burbujas. El código es el siguiente:
función selectSort (array) {var min, temp; ; for (var i = 0; i <array.length; i ++) {min = i; for (var j = i+1; j <array.length; j ++) {if (array [min]> array [j]) min = j; } if (min! = i) {temp = array [i]; matriz [i] = matriz [min]; matriz [min] = temp; } /* Resultado de salida* /document.write ("+ i+" El resultado del orden de pases es: ") para (var n = 0; n <array.length; n ++) {document.write (array [n]+", ");} document.write (" <Br /> ") /* El resultado de la salida termina* /}}}Clasificación compleja
Ordena de la colina
La clasificación de Hill es una actualización de clasificación de inserción. En 1959, Hill superó la complejidad del tiempo de N Square al cambiar la comparación por pares en una clasificación simple para establecer la comparación de salto de lecho de paso. La clasificación de la colina va de la mejor NLOGN hasta el peor N cuadrado de acuerdo con la complejidad del tiempo diferente de los tamaños de pasos. El código es el siguiente:
function sillsort (array) {var increment = array.length; var i var temp; // almacenar var cuenta = 0; do {increment = Math.floor (incremento / 3) + 1; for (i = increment; i <array.length; i ++) {if (array [i] <array [i - increment]) {temp = array [i]; for (var j = i - increment; j> 0 && temp <array [j]; j - = increment) {array [j + increment] = array [j]; } array [j + increment] = temp; /* Resultado de salida*/ count ++; document.Write ("<Br />+ Count+" El resultado del orden de los pases es: ") para (var n = 0; n <array.length; n ++) {document.write (array [n]+", ");} /* El resultado de salida termina* /}}}} mientras (incremento> 1)}Clasificación de montón
La clasificación de Heap es una actualización para seleccionar la clasificación. Al construir continuamente un montón superior grande o un montón superior pequeño, seleccionando el valor más grande o más pequeño y colocándolo en el extremo frontal de la cola para clasificar. La complejidad del tiempo de la clasificación de montón en cualquier caso es nLogn, el código es el siguiente:
function HeApSort (Array) {var temp; var i; for (i = Math.floor (Array.Length / 2); i> = 0; i--) {HeapadJust (Array, I, Array.Length-1); // construye matriz de matriz en un montón superior grande} para (i = array.length-1; i> = 0; i--) {/*intercambia el nodo raíz*/temp = array [i]; matriz [i] = array [0]; matriz [0] = temp; /*La matriz restante continúa integrándose en un montón superior grande*/ Heapadjust (matriz, 0, i - 1); /* Resultado de salida*/document.write ("<br/>+ (array.length - i) .ToString ()+" El resultado del orden de los pases es: ") para (var n = 0; n <array.length; n ++) {document.write (array [n]+", ");}/* el resultado de salida final*/} // el subtrucito de STURA La matriz // max es el subíndice final de la función de matriz HeapadJust (array, start, max) {var temp, j; } if (temp> = array [j]) break;Fusionar
La clasificación de fusión es la única clasificación estable en la clasificación compleja. Se clasifica dividiendo y luego fusiona la matriz para ser ordenada. El cuadrado de la complejidad del tiempo de clasificación de fusión es n. El código es el siguiente:
// matriz de origen // matriz de destino de des // s Subscript de inicio // T Función de subíndice de destino MSort (fuente, Dest, S, T) {var m; // elige el valor intermedio var dest2 = new Array (); if (s == t) {des [s] = fuente [s]; } else {M = Math.Floor ((S + T) / 2); MSORT (fuente, Dest2, M+1, T); fusionar (Dest2, Dest, S, M, T); /* Resultado de salida*/document.write ("<Br/>+++ Count+" El resultado de la clasificación de pases es: ") para (var n = 0; n <dest.length; n ++) {document.write (array [n]+", ");}/* El resultado de la salida del resultado finaliza*/}} // fusioning dos matrices en orden de una reducción de origen pequeña a grande Subscripción de la segunda matriz // Función de longitud total (fuente, Dest, S, M, N) {for (var j = m+1, k = s; j <= n && s <= m; k ++) {if (fuente [s] <fuente [j]) {dest [k] = fuente [s ++]; if (s <= m) {para (var l = 0; l <= m - s; l ++) {dest [k+l] = fuente [s+l];Clasificación rápida
Quick Sort es el tipo más rápido conocido, con una complejidad de tiempo de NLOGN, y el código es el siguiente:
Var Count = 0; función Quicksort (Array, Low, High) {var temp; if (low <high) {var keyPoint = QuickSorthElp (Array, bajo, alto); contar ++; document.write ("<Br /> Terminal? + Count +" El resultado del orden del orden es?: ") para (var l = 0; l <array.length; l ++) {document.write (array [l] +", ");} rápida (array, bajo, keypoint - 1); rápida (array, keypoint + 1, high);}}} Low, High) {While (Low <High) {While (High && Array [Low] <= Array [High]) {High--; matriz [alta];El resumen anterior de varios métodos de clasificación (implementación JS) en la estructura de datos es todo el contenido que comparto con usted. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.