Leer este artículo ya no será un problema para el "algoritmo de clasificación de matrices" (algoritmo de clasificación de burbujas, algoritmo de clasificación directa, algoritmo de clasificación inversa)

Algoritmo de clasificación de burbujas (clasificación de burbujas)

Descripción general e idea básica del algoritmo

• 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 (en orden ascendente o descendente) a través del intercambio, al igual que las burbujas de dióxido de carbono en las bebidas carbonatadas eventualmente subirán a la parte superior. , de ahí el nombre "burbuja" Ordenar "
• La idea básica: la clasificación de burbujas es comparar los valores de dos elementos adyacentes, si se cumplen las condiciones correspondientes, intercambiar los valores de los elementos entre sí, mover el elemento más pequeño al frente de la matriz y mover el más grande elemento a la parte posterior de la matriz (es decir, intercambiar la posición de los dos elementos), de modo que el elemento más pequeño se eleve de abajo hacia arriba como una burbuja
• Idea del algoritmo: el algoritmo de burbujeo se realiza mediante un bucle doble. El
  bucle exterior se utiliza para controlar el número de rondas de clasificación (es decir, varias rondas de operaciones de clasificación). Generalmente, la longitud de la matriz a ordenar es "menos 1 "veces, porque sólo queda el último ciclo. No es necesario comparar el siguiente elemento de la matriz y la matriz ya se ha ordenado.
  El bucle interno se utiliza para comparar el tamaño de cada elemento adyacente en la matriz para determinar si se intercambian posiciones. El número de comparaciones e intercambios disminuye con el número de rondas de clasificación

Diagrama esquemático del proceso de clasificación.

Secuencia de comandos de comando

método uno

[root@localhost ~]# ./28.sh 
需排序数组的值为：61 6 22 1 4 13
排序后的新数组值为：1 4 6 13 22 61
[root@localhost ~]# vim 28.sh

#!/bin/bash

sz=(61 6 22 1 4 13)
echo "需排序数组的值为：${sz[@]}"

leng=${
    
    #sz[@]}                 
【获取数组长度】

for ((w=1;w<$leng;w++))        
【定义比较轮数，为数组长度减1，因为这里是小于，所以不用减1，并每次执行+1的操作】
do

  for ((e=0;e<$leng-$w;e++))  
【因为这里的变量e是用来定义第一个比较元素的索引值，所以从0开始，又因为最后一次比较是索引4和索引5进行比较，所以这里变量e的值小于数组长度
减变量w（减变量w而不直接减1是因为待比较元素的位置需要随着轮数的增加而减少）】
  do
  one=${
    
    sz[$e]}                
【定义第1个比较元素的值】
  two=${
    
    sz[$e+1]}
【定义第2个比较元素的值】
    if [ $one -gt $two ];then
【如果第1个元素的值大于第2个元素的值，则只需位置交换操作】
    sz1=$one
【把第一个元素的值赋给临时变量sz1】
    sz[$e]=$two
【把第二个元素的值赋给第一个元素】
    sz[$e+1]=$sz1
【再把第一个元素的值（sz1的值）赋给第二个元素】
    fi
  done

done

echo "排序后的新数组值为：${sz[*]}"  

Método dos (defina manualmente los valores de la matriz que deben ordenarse)

[root@localhost ~]# ./28-1.sh 
输入你需要排序的数组：33 2 28 5 44 32 18 29
需排序数组的值为：33 2 28 5 44 32 18 29
排序后的新数组值为：2 5 18 28 29 32 33 44
[root@localhost ~]# vim 28-1.sh 

#!/bin/bash
read -p "输入你需要排序的数组：" num     【将需要排序的数组值赋给变量num】
sz=($num)                             【与方式一的区别在于这里是通过变量num获取到值，而不是脚本内定义好值】
echo "需排序数组的值为：${sz[@]}"

leng=${
    
    #sz[@]}

for ((w=1;w<$leng;w++))
do

  for ((e=0;e<$leng-$w;e++))
  do
  one=${
    
    sz[$e]}
  two=${
    
    sz[$e+1]}

    if [ $one -gt $two ];then
    sz1=$one
    sz[$e]=$two
    sz[$e+1]=$sz1

    fi
  done

done

echo "排序后的新数组值为：${sz[*]}"  

Método tres (encapsular el algoritmo en una función y pasar el parámetro que se ordenará en el algoritmo a través de la función)

[root@localhost ~]# ./28-2.sh 88 91 102 32 45 27 1 13
需排序数组的值为：88 91 102 32 45 27 1 13
排序后的新数组值为：1 13 27 32 45 88 91 102
[root@localhost ~]# vim 28-2.sh 

sz=($@)
echo "需排序数组的值为：${sz[@]}"

leng=${
    
    #sz[@]}

for ((w=1;w<$leng;w++))
do

  for ((e=0;e<$leng-$w;e++))
  do
  one=${
    
    sz[$e]}
  two=${
    
    sz[$e+1]}

    if [ $one -gt $two ];then
    sz1=$one
    sz[$e]=$two
    sz[$e+1]=$sz1

    fi
  done

done

echo "排序后的新数组值为：${sz[*]}"  

}

#################main#################   【仅为注释从这以下为主代码】
list=$@                                  【将命令行获取到的数组值赋给变量list】
paixu $list                              【将变量list获得的值传参到函数paixu内】

Clasificación de selección recta (clasificación de selección recta)

Descripción general e idea básica del algoritmo

• En comparación con la clasificación de burbujas, el número de intercambios para la clasificación de selección directa es menor, por lo que la velocidad de cálculo será más rápida
• Idea básica: compare la posición de clasificación especificada con otros elementos de la matriz por separado e intercambie los valores de los elementos si se cumplen las condiciones
• La diferencia con la clasificación de burbujas: en lugar de intercambiar elementos adyacentes, los elementos que cumplen las condiciones se intercambian directamente con la posición de clasificación especificada (por ejemplo, clasificando desde el último elemento). De esta manera, la posición ordenada se expande gradualmente y, finalmente, toda la matriz se genera en un formato ordenado.

Diagrama esquemático del proceso de clasificación.

Secuencia de comandos de comando

[root@localhost ~]# ./29.sh 
待排序的数组值为：63 4 24 1 3 15
排序后的数组值为： 1 3 4 15 24 63
[root@localhost ~]# vim 29.sh

#!/bin/bash

sz=(63 4 24 1 3 15)
echo "待排序的数组值为：${sz[@]}"
leng=${
    
    #sz[@]}                           【定义排序的轮数】

for ((w=1;w<$leng;w++))
do

   jx=0                                  【假设所以为0的元素是最大，并将值赋给jx】
   for ((e=1;e<=$leng-$w;e++))           【定义和第一个元素比较的索引，用来确定最大的元素索引】   
   do

     max=${
    
    sz[$jx]}                      【定义最大的元素的值】
     cs=${
    
    sz[$e]}                        【定义从索引1开始比较的元素的值】

     if [ $cs -gt $max ];then            【判断如果从索引1开始比较的元素值大于当前最大元素的值时，则记录最大值的索引到变量jx】
        jx=$e
     fi
   done
qz=$[$leng-$w]                           【定义每一轮比较的最后一个元素的索引】
qz1=${
    
    sz[$qz]}                           【把当前轮次的最后一个元素的值赋给临时变量qz1】
sz[$qz]=${
    
    sz[$jx]}                       【把最大的值赋给当前轮次的最后一个元素】
sz[$jx]=$qz1                             【把qz1里的原来最后一个元素的值赋给原来最大值所在索引的元素】

done

echo "排序后的数组值为： ${sz[*]}"

Algoritmo de clasificación inversa (clasificación inversa)

Descripción general e idea básica del algoritmo

• Reordenar el contenido de la matriz original en orden inverso
• Idea básica: reemplace el último elemento de la matriz con el primer elemento, reemplace el penúltimo elemento con el segundo elemento, y así sucesivamente, hasta que todos los elementos de la matriz se inviertan y reemplacen

Secuencia de comandos de comando

[root@localhost ~]# ./30.sh 
待排序的数组为：3 4 24 31 43 65 89
反转排序后的数组顺序为：89 65 43 31 24 4 3
[root@localhost ~]# vim 30.sh

#!/bin/bash

sz=(3 4 24 31 43 65 89)
echo "待排序的数组为：${sz[@]}"

leng=${
    
    #sz[@]}                  【输出数组sz的长度值并赋给变量leng】

for ((w=0; w<$leng/2; w++))     【索引从0开始，/2是折半对调，所以是长度/2，且索引每次增加1次】
do
  one=${
    
    sz[$w]}                 【将第一个索引对应的元素赋值给变量one】  
  two=${
    
    sz[$leng-1-$w]}         【将最后一个索引对应的元素赋给变量two】

  sz1=$one
  sz[$w]=$two                   【将最后一个索引对应的元素赋给第一个索引对应的元素】
  sz[$leng-1-$w]=$sz1           【将第一个索引对应的元素赋给最后一个索引对应的元素】

done

echo "反转排序后的数组顺序为：${sz[@]}"