Matriz de shell y algoritmo de clasificación (algoritmo de clasificación de burbujas; clasificación de selección directa; clasificación inversa)

1. Método de definición de matriz

Valor del elemento: (30 20 10 60 50 40)
Índice: 0 1 2 3 4 5
Cuatro métodos

1.método uno

Nombre de matriz = (valor0 valor1 valor2…)

2.Método dos
Nombre de matriz = ([0] = valor [1] = valor [2] = valor…)

3.Método tres
Nombre de lista = "valor0 valor1 valor2 ..."
Nombre de matriz = ($ nombre de lista)

4.Método cuatro
Nombre de matriz [0] = "valor"
Nombre de matriz [1] = "valor"
Nombre de matriz [2] = "valor"

Dos, los tipos de datos incluidos en la matriz

- 数值类型
- 字符类型（字符串）：使用" "或' '定义，防止元素当中有空格，元素按空格分割 

Tres, obtenga la longitud de la matriz y obtenga la lista de datos

Obtenga la longitud de la matriz

array=(1 2 3 4 5 6 7 8)                ///定义数组
echo ${#array[*]}或者 echo ${#array[@]}  ///获取数组长度

Obtener lista de datos

echo ${array[*]}或者 echo ${array[@]}///区别@加引号时数据每个是单个主体 *号是一个整体

Leer una tarea de índice

echo ${array[索引号]}

Cuatro, recorrido de matriz

#!/bin/bash
arr1=(1 2 3 4 5)
for i in ${arr1[@]}
do
echo $i
done

Cinco, corte de matriz

array=(1 2 3 4 5 6)
echo ${array[@]}           ///输出整个数组，此处*与@相同

echo ${array[@]:0:2}     ///获取 ${数组名[@或*]：起始位置：长度} 的值

echo ${array[*]:1:3}

echo ${array[*]:2:3}

Seis, reemplazo de matriz

Método 1: reemplazo único

array=(1 2 3 4 5 6)
echo ${array[@]}
array[0]=66
echo ${array[@]}

Método 2: reemplazo temporal de reemplazo múltiple (no cambiará los datos de la matriz original)

array=(1 2 3 4 5)

echo ${array[@]/4/66}   ///$(数组名[@或*]/查找字符（替换字符）
echo ${
     
     array[@]}        ///并会替换数组原有的数据

array=($array[@]/4/66)
echo ${array[@]}

Cinco, eliminación de matriz

array=(1 2 3 4 5 6)
unset array         #删除数组
echo ${array[@]}

array=(1 2 3 4 5 6)
unset array[2]      #删除第三个元素
echo ${array[*]}

Seis, agregue elementos a la matriz

método uno:

array=(1 2 3 4 5 6)
array[6]=7         ///在最后一个索引号添加比最后一个索引大的索引 在加上元素
array[7]=80

Método dos:

array[${#array[@]}]=7  ///根据数组长度添加索引添加元素，如果数组索引不是连续的则无法生效

Método tres:

array=（"${array[@]}" 1 2 3 4 5)

No se pueden omitir las comillas dobles; de lo contrario, cuando haya elementos en la matriz que contengan espacios, los elementos se dividirán en varias partes por espacios. No puede reemplazar "@" por " ". Si lo reemplaza por " ", se combinará con "@" "" se comporta de la misma manera, cuando se agregan comillas dobles, todos los elementos de la matriz se agregarán a la matriz como un elemento

for i in "${array[@]}"; do echo $i; done

Método cuatro:

array+=(10 20 30...)
#带添加元素必须使用()包围起来，并且多个元素用空格分割

Siete, pase los parámetros de la matriz a la función

Si se utiliza una variable de matriz como parámetro de función, la función solo tomará el primer valor de la variable de matriz

#/bin/bash

test1() {
    
    
  echo "接收到的数据为：$@"
  newarr=($1)
  echo "新数组的数据：${newarr[*]}"
}
arr=(1 2 3 4 5 6)
echo "arr数组的数据: ${arr[*]}"
test1 $arr

Para resolver este problema, debe descomponer los valores de las variables de la matriz en valores individuales y luego usar estos valores como parámetros de función. Dentro de la función, recombine todos los parámetros en una nueva variable de matriz

#/bin/bash

test2() {
    
    
  echo "接收到的数据为：$@"
  newarr=($@)
  echo "新数组的数据：${newarr[*]}"
}
arr=(1 2 3 4 5 6)
echo "arr数组的数据: ${arr[*]}"
test2 ${arr[@]}

Ocho, la función pasa parámetros a la matriz.

Ejemplo 1:

#/bin/bash

test3() {
    
    
newarray=($@)
sum=0
for i in ${newarray[@]}
 do
   sum=$[$sum+$i]
 done
 echo $sum
}
array=(1 2 3 4 5 6)
echo "初始array数组的值 ${array[@]}"
result=`test3 ${
     
     array[@]}`
echo "数组的和 $result"

Ejemplo 2

#/bin/bash

test(){
    
    
newarray=($@)
for  ((i=0; i<${#newarray[@]}; i++))
do
  newarray[$i]=$[${newarray[$i]} * 2]
done
echo ${newarray[@]}
}
array=(1 2 3 4 5 6)
echo "初始数组数据 ${array[@]}"
result=(`test ${
     
     array[@]}`)
echo "新数组 ${result[@]}"

Nueve, algoritmo de clasificación de matrices

(1) Algoritmo de clasificación de burbujas

De manera similar al aumento de las burbujas, los datos continuarán avanzando en la matriz de pequeños a grandes o de grandes a pequeños.
2. La idea básica: la idea básica de la clasificación de burbujas es comparar los valores de dos elementos adyacentes, intercambiar los valores de los elementos si se cumplen las condiciones, mover el elemento más pequeño al frente de la matriz y mover el elemento más grande a la parte posterior de la matriz (es decir, intercambiar las posiciones de los dos elementos) de modo que el elemento más pequeño se eleve de abajo hacia arriba como una burbuja.
3. Idea del algoritmo: el algoritmo de burbujeo se implementa mediante un ciclo doble, en el que el ciclo exterior se utiliza para controlar el número de rondas de clasificación, generalmente la longitud de la matriz a ordenar menos 1 vez, porque solo hay un elemento de matriz se deja en el último bucle y no se requiere comparación. Al mismo tiempo, se ha ordenado la matriz. El bucle interno se utiliza principalmente 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.

#!/bin/bash
read -p "输入需要排序的数组:" x
array=($x)
echo "旧数组为：${array[@]}"
#获取数组长度
length=${#array[@]}
for ((i=1;i<$length;i++))
do
    #确定数值位置，大的往后放，并且比较次数随着轮数增加而减少
    for ((a=0;a<$length-$i;a++))
    do
       #定义第一个和第二个比较的数值
       first=${array[$a]}
       second=${array[$a+1]}
       if [ $first -gt $second ];then
         #把第一个数值赋予给一个临时变量temp
         temp=${array[$a]}
         #把第二个数值赋予给第一个数值
         array[$a]=${array[$a+1]}
         #再把第一个数值的值（临时变量temp）赋予给第二个数值
         array[$a+1]=$temp
       fi
    done
done
echo "排序后的数组顺序为：${array[@]}"

(2) Seleccionar y ordenar directamente

1. Clasificación por selección directa
En comparación con la clasificación por burbujas, la clasificación por selección directa tiene menos intercambios, por lo que es más rápida.
2. Idea básica: compare la posición de clasificación especificada con otros elementos de la matriz respectivamente. Si se cumple la condición, el valor del elemento se intercambiará. Tenga en cuenta que la diferencia entre la clasificación de burbujas no es intercambiar elementos adyacentes, sino intercambiar los elementos que cumplen las condiciones con la posición de ordenación especificada (por ejemplo, comience a ordenar desde el último elemento), de modo que la posición ordenada se expanda gradualmente y, finalmente, toda la matriz se convierta en el formato ordenado

#!/bin/bash
arr=(20 30 10 60 40 50)
echo "原数组的值为：${arr[@]}"
length=${#arr[@]}
#定义排序轮数
for ((a=1;a<$length;a++))
    do
    #假设索引为0的元素是最大的
    index=0
    #定义和第一个元素比较的索引，来确定最大的元素索引
    for ((b=1;b<=$length-$a;b++))
    do
        #定义最大的元素的值
        max=${arr[$index]}
        #定义从索引1开始比较的元素的值
        element=${arr[$b]}
        #判断如果从索引1开始比较的元素的值大于当前最大元素的值，就记录最大值的索引到index
        if [ $element -gt $max ];then
           index=$b
        fi
    done
    #定义每一轮比较的最后一个元素的索引
    last=$[$length-$a]
    #把当前轮次的最后一个元素的值赋给临时变量temp
    temp=${arr[$last]}
    #把最大的值赋给当前轮次的最后一个元素
    arr[$last]=${arr[$index]}
    #把temp里的原来最后一个元素的值赋给原最大值所在索引的元素
    arr[$index]=$temp
done
echo "排序后的数组为：${arr[@]}"

(3) Pantalla inversa

1. Reordene el contenido de la matriz original en orden inverso
2. Idea básica:
Reemplace el último elemento de la matriz con el primer elemento. El penúltimo elemento se reemplaza con el segundo elemento, y así sucesivamente, hasta que todos los elementos de la matriz se invierten y reemplazan

#!/bin/bash
arr=(1 2 3 4 5)
length=${#arr[@]}
for ((i=0;i<$length/2;i++))
do
  temp=${arr[$i]}
  arr[$i]=${arr[$length-$i-1]}
  arr[$length-$i-1]=$temp
done
echo ${arr[@]}