0.1 Clasificación de algoritmos
Diez algoritmos de clasificación comunes se pueden dividir en dos categorías:
Clasificación comparativa: el orden relativo entre los elementos se determina por comparación. Dado que su complejidad temporal no puede exceder O (nlogn), también se denomina clasificación comparativa de tiempo no lineal.
Clasificación no comparativa: el orden relativo de los elementos no se determina mediante comparación. Puede atravesar el límite inferior de tiempo según la clasificación comparativa y ejecutarse en tiempo lineal, por lo que también se denomina clasificación no comparativa de tiempo lineal.
0.2 complejidad del algoritmo
0.3 Conceptos relacionados
Estable: si a está originalmente delante de b, y a = b, a todavía está delante de b después de la clasificación.
Inestable: si a está originalmente delante de b, y a = b, a puede aparecer detrás de b después de ordenar.
Complejidad del tiempo: el número total de operaciones en datos ordenados. Refleja la ley del número de operaciones cuando n cambia.
Complejidad espacial: se refiere a
la medida del espacio de almacenamiento requerido cuando el algoritmo se ejecuta en la computadora, también es función del tamaño de los datos n.
1. Clasificación de burbujas (clasificación de burbujas)
La clasificación de burbujas es un algoritmo de clasificación simple. Ha visitado repetidamente la secuencia para clasificar, comparando dos elementos a la vez e intercambiándolos si están en el orden incorrecto. El trabajo de visitar la secuencia se repite hasta que no se necesitan más intercambios, lo que significa que la secuencia ha sido ordenada. El origen del nombre de este algoritmo se debe a que cuanto más pequeño sea el elemento, "flotará" lentamente hacia la parte superior de la secuencia a través del intercambio.
1.1 Descripción del algoritmo
Compare elementos adyacentes. Si el primero es mayor que el segundo, intercambie los dos;
haga el mismo trabajo para cada par de elementos adyacentes, desde el primer par al principio hasta el último par al final, de modo que el último elemento sea el más grande Cuente;
repita los pasos anteriores para todos los elementos excepto el último;
repita los pasos 1 ~ 3 hasta que se complete la clasificación.
1.2 Demostración de animación
1.3 Implementación del código
función bubbleSort (arr) { var len = arr.length; for (var i = 0; i <len-1; i ++) { for (var j = 0; j <len-1-i; j ++) { if (arr [j]> arr [j + 1]) {// Comparación por pares de elementos adyacentes var temp = arr [j + 1]; // Intercambio de elementos arr [j + 1] = arr [j]; arr [j] = temp; } } } return arr; } 2. Orden de selección (Selection-sort) es un algoritmo de ordenación simple e intuitivo. Su principio de funcionamiento: primero encuentre el elemento más pequeño (grande) en la secuencia sin clasificar, guárdelo al comienzo de la secuencia ordenada y luego continúe encontrando el elemento más pequeño (grande) de los elementos restantes sin clasificar, y luego colóquelo en la secuencia ordenada Al final. Y así sucesivamente, hasta que todos los elementos estén ordenados.
2.1 Descripción del algoritmo
La selección y ordenación directa de n registros puede obtener resultados ordenados mediante n-1 veces de selección y ordenación directa. El algoritmo específico se describe a continuación:
Estado inicial: el área desordenada es R [1 ... n], el área ordenada está vacía; cuando
comienza la clasificación i-ésima (i = 1,2,3 ... n-1), el área ordenada actual y el área desordenada son respectivamente R [1 ... i-1] y R (i ... n). Este viaje de clasificación selecciona el registro R [k] con la clave más pequeña del área desordenada actual, y lo intercambia con el primer registro R del área desordenada para hacer R [1 ... i] y R [i + 1 ... n) Conviértase en una nueva área ordenada con el número de registros aumentado en uno y una nueva área desordenada con el número de registros disminuido en uno respectivamente; el
pase n-1 finaliza y la matriz se ordena.
2.2 Demostración de imágenes en movimiento
2.3
Función de implementación de código selectionSort (arr) { var len = arr.length; var minIndex, temp; for (var i = 0; i <len-1; i ++) { minIndex = i; for (var j = i + 1; j <len; j ++) { if (arr [j] <arr [minIndex]) {// encontrar el número más pequeño minIndex = j; // guardar el índice del número más pequeño } } temp = arr [i]; arr [i ] = arr [minIndex]; arr [minIndex] = temp; } return arr; } 2.4 El análisis de algoritmos es uno de los algoritmos de clasificación más estables, porque no importa qué datos ingresen, es O (n2) complejidad de tiempo, por lo que se usa Cuando se trata de eso, cuanto menor sea el tamaño de los datos, mejor. La única ventaja puede ser que no ocupa espacio de memoria adicional. En teoría, la clasificación selectiva también puede ser el método de clasificación en el que la mayoría de la gente piensa.
3. Orden de inserción
( Orden de inserción) La descripción del algoritmo de Orden de inserción es un algoritmo de ordenación simple e intuitivo. Funciona construyendo una secuencia ordenada.Para datos no clasificados, escanee de atrás hacia adelante en la secuencia ordenada, busque la posición correspondiente e insértela.
3.1 Descripción del algoritmo
En términos generales, la ordenación por inserción se implementa en una matriz utilizando in situ. El algoritmo específico se describe a continuación:
Comenzando desde el primer elemento, el elemento puede considerarse ordenado;
saque el siguiente elemento y escanee de atrás hacia adelante en la secuencia de elementos ordenados;
si el elemento (ordenado) es mayor que el nuevo elemento, mueva el elemento hacia la parte inferior Una posición;
repita el paso 3 hasta que encuentre la posición del elemento ordenado que es menor o igual que el nuevo elemento;
inserte el nuevo elemento en la posición;
repita los pasos 2 a 5.
3.2 Demostración de películas
3.2
Función de implementación de código insertionSort (arr) { var len = arr.length; var preIndex, current; for (var i = 1; i <len; i ++) { preIndex = i-1; current = arr [i]; while ( preIndex> = 0 && arr [preIndex]> current) { arr [preIndex + 1] = arr [preIndex]; preIndex–; } arr [preIndex + 1] = current; } return arr; } 3.4 Análisis de algoritmos y ordenación por inserción en la implementación En lo anterior, generalmente se usa la clasificación en el lugar (es decir, la clasificación que solo necesita O (1) espacio adicional), por lo que en el proceso de escaneo de atrás hacia adelante, es necesario cambiar repetidamente los elementos ordenados al elemento más nuevo Proporcione espacio de inserción.
4. Shell Sort (Shell Sort)
Shell inventado en 1959, el primer algoritmo de clasificación O (n2) innovador, es una versión mejorada de la ordenación por inserción simple. La diferencia entre este y el ordenamiento por inserción es que primero comparará los elementos más lejanos. La clasificación de colinas también se denomina clasificación incremental reducida.
4.1 Descripción del algoritmo
Primero divida la secuencia completa de registros a clasificar en varias subsecuencias para la clasificación por inserción directa, la descripción específica del algoritmo:
Seleccione una secuencia incremental t1, t2, ..., tk, donde ti> tj, tk = 1; de
acuerdo con el número de secuencias incrementales k, la secuencia se ordena por k veces;
cada pasada se ordena, de acuerdo con el incremento correspondiente ti, esperando La secuencia de clasificación se divide en varias subsecuencias de longitud my cada subtabla se inserta y clasifica directamente. Cuando solo el factor de incremento es 1, toda la secuencia se trata como una tabla y la longitud de la tabla es la longitud de toda la secuencia.
4.2 Demostración de animación
4.3
Función de implementación de código shellSort (arr) { var len = arr.length; for (var gap = Math.floor (len / 2); gap> 0; gap = Math.floor (gap / 2)) { // Nota: Esto es diferente de la demostración de la animación. La animación se ejecuta en grupos. La operación real es que varios grupos se ejecutan alternativamente para (var i = gap; i <len; i ++) { var j = i; var current = arr [i]; while (j-gap> = 0 && current <arr [j-gap]) { arr [j] = arr [j-gap]; j = j-gap; } arr [j] = actual; } } return arr; } 4.4 Análisis de algoritmos El núcleo de la clasificación Hill reside en el establecimiento de la secuencia de intervalos. La secuencia de intervalos se puede configurar de antemano o la secuencia de intervalos se puede definir dinámicamente. El algoritmo para definir dinámicamente la secuencia de intervalos fue propuesto por Robert Sedgewick, coautor de "Algorithm (4th Edition)".
5. Merge Sort (Merge Sort) Merge Sort
es un algoritmo de clasificación eficaz basado en operaciones de fusión. Este algoritmo es una aplicación muy típica de Divide and Conquer. Combine las subsecuencias ordenadas existentes para obtener una secuencia completamente ordenada; es decir, primero haga cada subsecuencia en orden y luego haga las subsecuencias en orden. Si dos listas ordenadas se combinan en una lista ordenada, se denomina combinación bidireccional.
5.1 Descripción del algoritmo
Divida la secuencia de entrada de longitud n en dos subsecuencias de longitud n / 2;
use la clasificación por combinación en estas dos subsecuencias respectivamente; combine
las dos subsecuencias ordenadas en una secuencia ordenada final.
5.2 Demostración de películas
5.3 代码
实现 función mergeSort (arr) { var len = arr.length; if (len <2) { return arr; } var middle = Math.floor (len / 2), left = arr.slice (0, middle), right = arr.slice (centro); return merge (mergeSort (izquierda), mergeSort (derecha)); }
función fusionar (izquierda, derecha) { var result = [];
while (left.length>0 && right.length>0) {
if (left[0] <= right[0]) {
result.push(left.shift());
} else {
result.push(right.shift());
}
}
while (left.length)
result.push(left.shift());
while (right.length)
result.push(right.shift());
return result;
}
5.4 Análisis de algoritmos La
clasificación por fusión es un método de clasificación estable. Al igual que el ordenamiento por selección, el rendimiento del ordenamiento por combinación no se ve afectado por los datos de entrada, pero funciona mucho mejor que el ordenamiento por selección porque siempre tiene una complejidad de tiempo O (nlogn). El precio es la necesidad de espacio de memoria adicional.
6.
La idea básica de la clasificación rápida : separe los registros que se clasificarán en dos partes independientes mediante una clasificación, y las palabras clave de una parte de los registros son más pequeñas que las palabras clave de la otra parte. Algunos registros continúan ordenándose para lograr el orden de toda la secuencia.
6.1 Descripción del algoritmo
La clasificación rápida utiliza dividir y conquistar para dividir una cadena (lista) en dos sublistas (sublistas). El algoritmo específico se describe a continuación:
Elija un elemento de la secuencia y llámelo "pivote";
reordene la secuencia para que todos los elementos más pequeños que el valor de referencia se coloquen delante de la referencia y todos los elementos mayores que el valor de referencia se coloquen detrás de la referencia (el mismo número). Puedes ir a cualquier lado). Una vez que la partición sale, el punto de referencia se encuentra en el medio de la secuencia. Esto se denomina operación de partición;
ordena de forma recursiva las submatrices de elementos más pequeños que el valor de referencia y las submatrices de elementos mayores que el valor de referencia.
6.2 Demostración de películas
6.3 代码
实现 función quickSort (arr, left, right) { var len = arr.length, partitionIndex, left = typeof left! = 'Number'? 0: izquierda, derecha = tipo de derecha! = 'Número'? len - 1: derecha;
if (left < right) {
partitionIndex = partition(arr, left, right);
quickSort(arr, left, partitionIndex-1);
quickSort(arr, partitionIndex+1, right);
}
return arr;
}
función partición (arr, izquierda, derecha) {// 分区 操作
var pivote = izquierda, // 设定 基准 值 （pivote）
índice = pivote + 1;
for (var i = índice; i <= derecha; i ++) { if (arr [i] <arr [pivote]) { swap (arr, i, índice); índice ++; } } intercambio (arr, pivote, índice - 1); return index-1; }
función swap (arr, i, j) { var temp = arr [i]; arr [i] = arr [j]; arr [j] = temp; } 7. Ordenar en montón (Ordenar en montón ) Sí Se refiere a un algoritmo de clasificación diseñado utilizando la estructura de datos del montón. El apilamiento es una estructura que se aproxima a un árbol binario completo y, al mismo tiempo, satisface la naturaleza del apilamiento: es decir, la clave o índice del nodo hijo es siempre menor (o mayor) que su nodo padre.
7.1 Descripción del algoritmo
Construya la secuencia inicial de palabras clave que se ordenarán (R1, R2 ... Rn) en un montón superior grande, que es el área desordenada inicial;
intercambie el elemento superior R [1] con el último elemento R [n] en este caso para obtener nuevas regiones desordenadas (R1, R2, ...... RN- 1) y las nuevas regiones ordenados (Rn de), satisfaciendo R [1,2 ... n-1] <= R [n];
Desde Después del intercambio, la nueva parte superior del montón R [1] puede violar la naturaleza del montón, por lo que el área desordenada actual (R1, R2, ... Rn-1) debe ajustarse a un nuevo montón, y luego R [1] y el área desordenada deben ajustarse nuevamente Se intercambia el último elemento y se obtiene una nueva área desordenada (R1, R2 ... Rn-2) y una nueva área ordenada (Rn-1, Rn). Este proceso se repite hasta que el número de elementos en el área ordenada es n-1 y se completa todo el proceso de clasificación.
7.2 Demostración de animación
7.3 Implementación de código
var len; // Debido a que varias funciones declaradas requieren longitud de datos, establezca len como una variable global
función buildMaxHeap (arr) {// 建立 大 顶 堆
len = arr.length;
for (var i = Math.floor (len / 2); i> = 0; i–) { heapify (arr, i); } }
función heapify (arr, i) {// 堆 调整
var izquierda = 2 * i + 1,
derecha = 2 * i + 2,
mayor = i;
if (left < len && arr[left] > arr[largest]) {
largest = left;
}
if (right < len && arr[right] > arr[largest]) {
largest = right;
}
if (largest != i) {
swap(arr, i, largest);
heapify(arr, largest);
}
}
función de intercambio (arr, i, j) { var temp = arr [i]; arr [i] = arr [j]; arr [j] = temp; }
function heapSort (arr) { buildMaxHeap (arr);
for (var i = arr.length - 1; i > 0; i--) {
swap(arr, 0, i);
len--;
heapify(arr, 0);
}
return arr;
}
8. Counting Sort
no es un algoritmo de clasificación basado en la comparación, su núcleo es convertir los valores de los datos de entrada en claves y almacenarlos en un espacio de matriz adicional. Como una especie de complejidad de tiempo lineal, la ordenación por recuento requiere que los datos de entrada sean un número entero con un cierto rango.
8.1 Descripción del algoritmo
Encuentre los elementos más grandes y más pequeños en la matriz a ordenar;
cuente el número de ocurrencias de cada elemento con el valor i en la matriz y guárdelo en el i-ésimo elemento de la matriz C;
acumule todos los conteos (desde el primero en C) Comience con un elemento, agregue cada elemento al elemento anterior);
Llene la matriz de destino hacia atrás: coloque cada elemento i en el elemento C (i) de la nueva matriz y reste C (i) cada vez que coloque un elemento Vaya a 1.
8.2 Demostración de películas
8.3 代码 实现
función counttingSort (arr, maxValue) { var bucket = new Array (maxValue + 1), sortedIndex = 0; arrLen = arr.length, bucketLen = maxValue + 1;
for (var i = 0; i < arrLen; i++) {
if (!bucket[arr[i]]) {
bucket[arr[i]] = 0;
}
bucket[arr[i]]++;
}
for (var j = 0; j < bucketLen; j++) {
while(bucket[j] > 0) {
arr[sortedIndex++] = j;
bucket[j]--;
}
}
return arr;
}
8.4 Análisis de algoritmos La
clasificación por conteo es un algoritmo de clasificación estable. Cuando los elementos de entrada son n números enteros entre 0 y k, la complejidad del tiempo es O (n + k) y la complejidad del espacio también es O (n + k), y su velocidad de clasificación es más rápida que cualquier algoritmo de clasificación por comparación. Cuando k no es muy grande y la secuencia está relativamente concentrada, la clasificación por conteo es un algoritmo de clasificación muy eficaz.
9. La clasificación por cubeta
es una versión mejorada de la clasificación por conteo. Utiliza la relación de mapeo de funciones, y la clave de la eficiencia radica en la determinación de la función de mapeo. El principio de funcionamiento de la clasificación de depósitos: suponiendo que los datos de entrada se distribuyen uniformemente, los datos se dividen en un número limitado de depósitos y cada depósito se clasifica por separado (es posible utilizar otro algoritmo de clasificación o seguir utilizándolo de forma recursiva Se realiza la clasificación de cubos).
9.1 Descripción del algoritmo
Establecer una matriz cuantitativa como un depósito vacío;
recorrer los datos de entrada y poner los datos uno por uno en el depósito correspondiente;
clasificar cada depósito que
no esté vacío ; nunca clasificar los depósitos que no estén vacíos Los datos se empalman.
9.2 Demostración de imágenes
9.3 代码
实现 función bucketSort (arr, bucketSize) { if (arr.length === 0) { return arr; }
var i;
var minValue = arr[0];
var maxValue = arr[0];
for (i = 1; i < arr.length; i++) {
if (arr[i] < minValue) {
minValue = arr[i]; // 输入数据的最小值
} else if (arr[i] > maxValue) {
maxValue = arr[i]; // 输入数据的最大值
}
}
// 桶的初始化
var DEFAULT_BUCKET_SIZE = 5; // 设置桶的默认数量为5
bucketSize = bucketSize || DEFAULT_BUCKET_SIZE;
var bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1;
var buckets = new Array(bucketCount);
for (i = 0; i < buckets.length; i++) {
buckets[i] = [];
}
// 利用映射函数将数据分配到各个桶中
for (i = 0; i < arr.length; i++) {
buckets[Math.floor((arr[i] - minValue) / bucketSize)].push(arr[i]);
}
arr.length = 0;
for (i = 0; i < buckets.length; i++) {
insertionSort(buckets[i]); // 对每个桶进行排序，这里使用了插入排序
for (var j = 0; j < buckets[i].length; j++) {
arr.push(buckets[i][j]);
}
}
return arr;
}
9.4 Análisis de algoritmos La
clasificación de depósitos se utiliza mejor en tiempo lineal O (n). La complejidad temporal de la clasificación de depósitos depende de la complejidad temporal de clasificar los datos entre cada depósito, porque la complejidad temporal de otras partes es O (norte). Obviamente, cuanto más pequeños se dividen los depósitos, menos datos hay entre cada depósito y menos tiempo se tarda en ordenar. Pero el consumo de espacio correspondiente aumentará.
10. Orden de Radix (Orden de Radix) El orden de
Radix se ordena según el orden inferior, luego se recopila, luego se clasifica según el orden superior y luego se recopila, y así sucesivamente, hasta el orden más alto. A veces, algunos atributos tienen un orden de prioridad, primero se ordenan por prioridad baja y luego por prioridad alta. El orden final es que la prioridad alta es la primera y la prioridad baja con la misma prioridad alta es la primera.
10.1 Descripción del algoritmo
Obtenga el número máximo en la matriz y obtenga la cantidad de dígitos;
arr es la matriz original, y cada bit se toma del bit más bajo para formar la matriz de
base ; la base se cuenta y ordena (usando las características de clasificación de conteo para números de rango pequeño);
10.2 Demostración de imágenes en movimiento
10,3 代码 实现
contador var = [];
función radixSort (arr, maxDigit) { var mod = 10; var dev = 1; for (var i = 0; i <maxDigit; i ++, dev * = 10, mod = 10) { for (var j = 0; j <longitud de arr.; j ++) { var bucket = parseInt ((arr [j]% mod) / dev); if (contador [cubo] == nulo) { contador [cubo] = []; } contador [cubo]. empujar (arr [j]); } var pos = 0; for (var j = 0; j <counter.length; j ++) { var value = null; if (contador [j]! = nulo) { mientras ((valor = contador [j] .shift ())! = nulo) { arr [pos ++] = valor; } } } } return arr;
}
10.4 Análisis de algoritmos La
clasificación por cardinalidad se basa en la clasificación por separado y la recopilación por separado, por lo que es estable. Sin embargo, el rendimiento de la clasificación de radix es ligeramente peor que el de la clasificación de cubos. Cada asignación de cubos de una clave requiere O (n) tiempo de complejidad, y obtener una nueva secuencia de claves después de la asignación requiere O (n) de complejidad de tiempo. Si los datos que se van a ordenar se pueden dividir en d palabras clave, la complejidad temporal de la ordenación por base será O (d 2n). Por supuesto, d es mucho más pequeño que n, por lo que es básicamente lineal.
La complejidad espacial de la ordenación por base es O (n + k), donde k es el número de cubos. En términos generales, n >> k, por lo que el espacio extra necesita alrededor de n.