Siga la cuenta oficial de WeChat de "Big Front-end Private Kitchen" e ingrese la contraseña [Guía de entrevista] para recibir 107 páginas de preguntas de la entrevista front-end de forma gratuita.
clasificación de matrices
La clasificación es el proceso de procesar algorítmicamente una matriz desordenada en una matriz ordenada. Hoy presentaremos dos algoritmos de clasificación de uso común: clasificación por burbujas y clasificación por selección.
Ordenamiento de burbuja
La idea básica es:
Recorra repetidamente la matriz y compare los elementos adyacentes. Si el elemento anterior es más grande que el siguiente, cámbielos. Después de la primera pasada, el elemento más grande "flotará" hasta la última posición de la matriz. Después de la segunda pasada, finalmente, el segundo elemento más grande "flotará" hasta la penúltima posición, y este proceso se repetirá hasta que no queden elementos que deban intercambiarse. Finalmente, se ordena toda la matriz.
1. Primero preparemos una matriz desordenada.
var arr = [3, 1, 5, 6, 4, 9, 7, 2, 8]
A continuación usaremos código para ordenar la matriz.
2. No te preocupes por el bucle ahora, veamos el contenido de la matriz y cambiemos su posición.
// 假定我现在要让数组中的第 0 项和第 1 项换个位置
// 需要借助第三个变量
var tmp = arr[0]
arr[0] = arr[1]
arr[1] = tmp
Después de aprender a intercambiar datos en dos ubicaciones, podemos continuar
3. Recorra la matriz por primera vez y coloque la más grande al final.
for (var i = 0; i < arr.length; i++) {
// 判断，如果数组中的当前一个比后一个大，那么两个交换一下位置
if (arr[i] > arr[i + 1]) {
var tmp = arr[i]
arr[i] = arr[i + 1]
arr[i + 1] = tmp
}
}
// 遍历完毕以后，数组就会变成 [3, 1, 5, 6, 4, 7, 2, 8, 9]
Después de la primera vez, el último de la matriz será el número más grande y luego ejecutamos el código anterior varias veces. Ejecutar tantas veces como elementos haya en la matriz.
4. ¿Cuántas veces recorrer según la longitud de la matriz?
for (var j = 0; j < arr.length; j++) {
for (var i = 0; i < arr.length; i++) {
// 判断，如果数组中的当前一个比后一个大，那么两个交换一下位置
if (arr[i] > arr[i + 1]) {
var tmp = arr[i]
arr[i] = arr[i + 1]
arr[i + 1] = tmp
}
}
}
// 结束以后，数组就排序好了
5. Dar algunas optimizaciones.
Imagine que en el proceso de clasificación de burbujas de una matriz de longitud 9, después de la octava clasificación, los últimos 8 elementos de la matriz se han ordenado en orden. En este momento, el elemento más pequeño al final de la matriz debe haber flotado hacia el frente. Por lo tanto, el noveno recorrido ordenado no tiene sentido porque el elemento más pequeño ya está en la posición correcta y no se producirá ningún intercambio de posición.
Por lo tanto, en este caso, podemos omitir el noveno recorrido de clasificación y finalizar el algoritmo directamente. Esto se puede utilizar como optimización: después de una determinada clasificación, si el final de la matriz ya está ordenado, podemos finalizar la clasificación directamente sin continuar atravesando toda la matriz.
for (var j = 0; j < arr.length - 1; j++) {
for (var i = 0; i < arr.length; i++) {
// 判断，如果数组中的当前一个比后一个大，那么两个交换一下位置
if (arr[i] > arr[i + 1]) {
var tmp = arr[i]
arr[i] = arr[i + 1]
arr[i + 1] = tmp
}
}
}
Después de la primera pasada de clasificación, el elemento más grande de la matriz ya está al final. En el segundo paso de clasificación, no es necesario comparar los dos últimos elementos de la matriz (el elemento más grande y el segundo más grande) porque no se producirá ningún intercambio de posiciones.
En el tercer paso de clasificación, no es necesario comparar los últimos tres elementos de la matriz (del mayor al tercer elemento más grande). Porque las posiciones del elemento mayor al tercero ya son correctas y no volverán a cambiar. Por analogía, en el enésimo paso de clasificación, solo necesitamos comparar los primeros n-1 elementos de la matriz. Debido a que las posiciones de los últimos n-1 elementos de la matriz ya son correctas, no se necesita más comparación.
for (var j = 0; j < arr.length - 1; j++) {
for (var i = 0; i < arr.length - 1 - j; i++) {
// 判断，如果数组中的当前一个比后一个大，那么两个交换一下位置
if (arr[i] > arr[i + 1]) {
var tmp = arr[i]
arr[i] = arr[i + 1]
arr[i + 1] = tmp
}
}
}
6. En este punto, se completa la clasificación de burbujas.
La clasificación por selección
primero asume que el número 0 en la matriz es el índice del número más pequeño, y luego atraviesa la matriz. Siempre que haya un número menor que el mío, reemplace el índice registrado anteriormente. Una vez completado el recorrido de la matriz, se puede encontrar el índice más pequeño. Luego cambie el índice más pequeño a la posición 0 y luego realice el segundo recorrido. Supongamos que el primero es el índice del número más pequeño. Después de recorrer la matriz una vez, encuentre el índice del número más pequeño. que el mío, y cámbielo una vez completado el recorrido, posición, etc., también puede ordenar la matriz.
1. Prepare una matriz
var arr = [3, 1, 5, 6, 4, 9, 7, 2, 8]
2. Suponga que el número 0 de la matriz es el índice del número más pequeño.
var minIndex = 0
3. Recorra la matriz, juzgue, siempre que el número sea menor que el mío, luego reemplace el índice del registro original
var minIndex = 0
for (var i = 0; i < arr.length; i++) {
if (arr[i] < arr[minIndex]) {
minIndex = i
}
}
// 遍历结束后找到最小的索引
// 让第 minIndex 个和第 0 个交换
var tmp = arr[minIndex]
arr[minIndex] = arr[0]
arr[0] = tmp
4. Repita el código anterior según la longitud de la matriz.
for (var j = 0; j < arr.length; j++) {
// 因为第一遍的时候假定第 0 个，第二遍的时候假定第 1 个
// 所以我们要假定第 j 个就行
var minIndex = j
// 因为之前已经把最小的放在最前面了，后面的循环就不需要判断前面的了
// 直接从 j + 1 开始
for (var i = j + 1; i < arr.length; i++) {
if (arr[i] < arr[minIndex]) {
minIndex = i
}
}
// 遍历结束后找到最小的索引
// 第一堂的时候是和第 0 个交换，第二趟的时候是和第 1 个交换
// 我们直接和第 j 个交换就行
var tmp = arr[minIndex]
arr[minIndex] = arr[j]
arr[j] = tmp
}
5. Algunas optimizaciones.
Como antes, una vez completada la penúltima clasificación, se ha ordenado. La última vez no es necesaria.
for (var j = 0; j < arr.length - 1; j++) {
var minIndex = j
for (var i = j + 1; i < arr.length; i++) {
if (arr[i] < arr[minIndex]) {
minIndex = i
}
}
var tmp = arr[minIndex]
arr[minIndex] = arr[j]
arr[j] = tmp
}
Antes de intercambiar variables, podemos hacer un juicio: si el índice que obtenemos después de recorrerlo es consistente con el índice actual, entonces demuestra que el actual es el más pequeño en este momento, por lo que no hay necesidad de intercambiar. Finalmente, tenemos que juzgar que el índice más pequeño es diferente del índice actual, sólo cuando
for (var j = 0; j < arr.length - 1; j++) {
var minIndex = j
for (var i = j + 1; i < arr.length; i++) {
if (arr[i] < arr[minIndex]) {
minIndex = i
}
}
if (minIndex !== j) {
var tmp = arr[minIndex]
arr[minIndex] = arr[j]
arr[j] = tmp
}
}
En este punto, se completa la clasificación de selección.