Ordenación y recursión de burbujas

Ordenamiento de burbuja

1. Compara dos elementos adyacentes, si el anterior es más grande que el siguiente, intercambia posiciones.
2. Después de la primera ronda de comparación, el último elemento es el elemento más grande.
3. En este momento, el último elemento es el más grande, por lo que el último elemento no necesita estar involucrado en la comparación.

Principio de realización

Hay un nnúmero en la matriz , compare cada dos números adyacentes, si el primero es mayor que el segundo, intercambie las posiciones de los dos números; de esta manera, en la primera ronda, se puede seleccionar el número más grande y colocarlo en el end; luego, después n-1de la ronda (La longitud de la matriz-1), se completa la clasificación de todos los números.

Bien, busquemos primero el número más grande de la matriz y colóquelo al final de la matriz.

var arr = [3,4,1,2];
// 遍历数组，次数就是arr.length - 1
for (var i = 0; i < arr.length - 1; i++) {
    
    
	// 如果前一个数 大于 后一个数 就交换两数位置
	if (arr[i] > arr[i + 1]) {
    
    
		var temp = arr[i];
		arr[i] = arr[i + 1];
		arr[i + 1] = temp;
	}
}
console.log(arr)  // [3, 1, 2, 4]

Podemos encontrar el número más grande en la matriz y ponerlo al final. Repitiendo arr.length-1 tiempo, la matriz se puede organizar en orden ascendente.

var arr = [3,4,1,2];
// 遍历数组，次数就是arr.length - 1
for (var j = 0; j < arr.length - 1; j++) {
    
    
	// 这里 i < arr.length - 1 ，要思考思考合适吗？我们下面继续说
	for (var i = 0; i < arr.length - 1; i++) {
    
    
        if (arr[i] > arr[i + 1]) {
    
    
            var temp = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = temp;
        }
	}
}
console.log(arr)  // [1,2,3,4]

Aunque el código anterior ha implementado la clasificación de burbujas, como se menciona en los comentarios, el número de bucles for internos se escribe como i <arr.length-1, ¿es apropiado?

Pensemos en ello, cuando encontramos el número más grande por primera vez y lo ponemos al final, la próxima vez, cuando recorramos, ¿no podemos contar el último número? Debido a que es el más grande, no aparecerá. El número anterior es mayor que el siguiente, y la posición debe cambiarse. Por lo tanto, el número de bucles for internos se cambia a i <longitud de arr.-1 -j , que es apropiado, consulte el código a continuación.

var arr = [3, 4, 1, 2];
function bubbleSort (arr) {
    
    
  for (var j = 0; j < arr.length - 1; j++) {
    
    
    // 这里要根据外层for循环的 j，逐渐减少内层 for循环的次数
    for (var i = 0; i < arr.length - 1 - j; i++) {
    
    
      if (arr[i] > arr[i + 1]) {
    
    
        var temp = arr[i];
        arr[i] = arr[i + 1];
        arr[i + 1] = temp;
      }
    }
  }
  return arr;
}
bubbleSort(arr);

Pensamos en esta situación, cuando la matriz original es,

arr = [1,2,4,3];

Después de la primera ronda de clasificación de burbujas, la matriz se convierte en

arr = [1,2,3,4];

En este punto, la matriz se ha ordenado, pero de acuerdo con el código anterior, la matriz continuará ordenándose, por lo que agregamos un bit de bandera. Si no hay dos números para intercambiar después de un cierto ciclo, establezca el bit de bandera en verdadero, lo que indica que la clasificación está completa, de modo que podemos reducir la clasificación innecesaria y mejorar el rendimiento.

Método de clasificación por inserción (cortando la cola)

Divida la matriz a ordenar en dos partes e inserte el elemento con el índice más pequeño de la última parte en la posición apropiada de la primera parte cada vez

• A partir del primer elemento, se puede considerar que el elemento ha sido ordenado;
• Saque el siguiente elemento y escanee de atrás hacia adelante en la secuencia ordenada de elementos;
• Si el elemento (ordenado) es más grande que el nuevo elemento, mueva el elemento a la siguiente posición;
• Repita el paso 3 hasta que encuentre la posición donde el elemento ordenado es menor o igual que el nuevo elemento;
• Después de insertar el nuevo elemento en esta posición;
• Repita los pasos 2 ~ 5.

function InsertSort(arr) {
    
    
  let len = arr.length;
  let preIndex, current;
  for (let i = 1; i < len; i++) {
    
    
    preIndex = i - 1;
    current = arr[i];
    while (preIndex >= 0 && current < arr[preIndex]) {
    
    
      arr[preIndex + 1] = arr[preIndex];
      preIndex--;
    }
    arr[preIndex + 1] = current;
  }
  return arr;
}
 
 
var arr = [3,5,7,1,4,56,12,78,25,0,9,8,42,37];
InsertSort(arr);

Ordenación rápida

Después de leer las cosas anteriores, no sé si ha encontrado que si la cantidad de datos es demasiado grande y la matriz es más complicada en el trabajo real, causará problemas de rendimiento al mismo tiempo a través de dos recorridos. pánico, todavía podemos usar el método de clasificación rápida para resolver,快速排序对冒泡排序的一种改进

La idea de la realización es que el problema de clasificación de una matriz se considera como el problema de clasificación de dos matrices pequeñas, con un número como punto de referencia (el número en el medio), el más pequeño que el punto de referencia se coloca a la izquierda y el más grande que el punto de referencia se coloca a la derecha, y cada Una pequeña matriz puede seguir considerándose como dos matrices más pequeñas, y de forma recursiva, hasta que la longitud máxima de la matriz sea 2.

function quickSort(arr){
    
    
   //如果数组长度小于1，没必要排序，直接返回
   if(arr.length<=1) return arr;
   //pivot 基准索引，长度的一半
   let pivotIndex = Math.floor(arr.length/2);//奇数项向下取整
   //找到基准，把基准项从原数组删除
   let pivot = arr.splice(pivotIndex,1)[0];
   //定义左右数组
   let left = [];
   let right = [];
   //把比基准小的放left,大的放right
   arr.forEach(element => {
    
    
       if(element<pivot){
    
    
           left.push(element)
       }else{
    
    
           right.push(element)
       }
   });
   return quickSort(left).concat([pivot],quickSort(right))
}
var arr=[4,56,3,67,44,5,66];
console.log(quickSort(arr));//[3, 4, 5, 44, 56, 66, 67]

Código completo

var arr = [3, 4, 1, 2];
function bubbleSort (arr) {
    
    
  var max = arr.length - 1;
  for (var j = 0; j < max; j++) {
    
    
    // 声明一个变量，作为标志位
    var done = true;
    for (var i = 0; i < max - j; i++) {
    
    
      if (arr[i] > arr[i + 1]) {
    
    
        var temp = arr[i];
        arr[i] = arr[i + 1];
        arr[i + 1] = temp;
        done = false;
      }
    }
    if (done) {
    
    
      break;
    }
  }
  return arr;
}
bubbleSort(arr);

rendimiento

Complejidad temporal: complejidad temporal media O (n n), mejor caso O (n), peor caso O (n n)
complejidad espacial: O (1)
estabilidad: estable

Se refiere a la complejidad de tiempo de realizar un algoritmo que consume mucho tiempo.La
complejidad espacial implica ejecutar un tamaño final deseado de los
medios de estabilización de la memoria del programa , si a = b, b, un frente, a todavía ordenados frente a b
inestable Medios, si a = b, a está delante de b, las posiciones pueden intercambiarse después de la clasificación

para resumir

1. El bucle for externo controla el número de ciclos.
2. El bucle for interno intercambia dos números, encuentra el número máximo cada vez y lo organiza en el último
3. Configure un bit de bandera para reducir ciclos innecesarios

Recursividad

js
definición de implementación recursiva : la
función recursiva es llamar a esta función en el cuerpo de la función;

El uso de funciones recursivas debe prestar atención a las condiciones de terminación de la función para evitar bucles infinitos;

Forma de realización recursiva:
1. Declare una función nombrada, llame por el nombre de la función

function f(a){
    
    
    if(a<=1){
    
    
        return 1
    }else{
    
    
        return a*f(a-1)
    }
} 

Pero este uso provocará un error debido al cambio del nombre de la función f,

f = null
f ()  // Uncaught TypeError: f is not a function

2. Usa argumentos.callee en lugar del nombre de la función

Arguments.callee no se admite en modo estricto

3. Usa expresiones de función

var fun = (function f(a){
    
    
    if(a<=1){
    
    
        return 1
    }else{
    
    
        return a*f(a-1)
    }
})

// 或：

var f = function (a){
    
    
    if(a<=1){
    
    
        return 1
    }else{
    
    
        return a*f(a-1)
    }
}

var fun = f;

Valor de retorno recursivo

1. La función recursiva es equivalente a una especie de llamada cíclica, que debe evitar un bucle infinito y detener la llamada dada una condición.

2. El valor de retorno de una función recursiva debe devolver la función completa.

// 返回公约数的数组集合
let fun = (function f(a,n = 1,b=[]){
    
    
  if(a%n === 0) {
    
    
     b.push(n)            
    }
   n ++;
   if(n>a){
    
    
   return b
 }
 return f(a,n,b) // *** 要返回整个函数，不能只是return b
})
调用函数

fun(4)
[1, 2, 4]

Para devolver la función completa en ***,

Esto se debe a que cuando no se establece la condición de ejecución n> a, no hay valor de retorno. Por ejemplo, cuando la primera ejecución es n = 1, a = 4 y 1> 4 es falso, no hay valor de retorno y los valores posteriores no se devuelven.

// 可以参考这种形式，有return fun
fun (){
    
    
return fun(){
    
    
 return fun(){
    
    
   return 4
 }
}
}

// 可以参考这种形式，没有return fun
fun (){
    
    
fun(){
    
    
 fun(){
    
    
   return 4
 }
}
}