Matriz de shell y ordenación

1. Método de definición de matriz

1. Método uno

Nombre de matriz = (valor0 valor1 valor2…)

array1=(10 20 30 40 50)

2. Método dos

Nombre de matriz = ([0] = valor [1] = valor [2] = valor…)

array2=([0]=10 [1]=20 [2]=30 [3]=40 [4]=50)

3. Método tres

Nombre de lista = "valor0 valor1 valor2 ..."
Nombre de matriz = ($ nombre de lista)

abc="10 20 30 40 50"
array3=($abc)

4. Método cuatro

Nombre de matriz [0] = "valor"
Nombre de matriz [1] = "valor"
Nombre de matriz [2] = "valor"

array4[0]=10
array4[1]=20
array4[2]=30
array4[3]=40
array4[4]=50

Dos, los tipos de datos incluidos en la matriz

1. Tipo numérico

Tipo de carácter (cadena): use "" o '' para definir para evitar espacios en los elementos, y los elementos están separados por espacios

2. Obtenga la longitud de la matriz

echo $ {# Nombre de matriz [*]}

array1=(10 20 30 40 50)
echo ${#array1[*]}

3. Leer una tarea de índice

echo ${数组名[*]}——读取整个数组数值
echo ${数组名[x]}——读取索引x+1的数值

echo ${array1[*]}
echo ${array1[1]}
echo ${array1[3]}

4. Recorrido de matriz

#!/bin/bash
arr=(50 40 30 20 10)

for i in ${arr[@]}
do
    echo $i
done

5. Rebanado de matrices

Obtenga el valor de $ {nombre de matriz [@ o *]: posición inicial: longitud} y
genere la matriz completa, donde * es lo mismo que @

arry1=(10 20 30 40 50)          
echo ${arry1[*]}       
echo ${arry1[*]:0:2}   
echo ${arry1[*]:1:4}
echo ${arry1[*]:2:2}

6. Reemplazo de matriz

① Reemplazar un solo valor

array1[2]=88   

② Reemplazo múltiple (reemplazo temporal)

echo ${array1[*]/0/66}

7. Eliminación de matriz

①La matriz completa elimina el
nombre de la matriz no configurada

unset arry  

②Borrar la posición
especificada sin establecer el nombre de la matriz [número de índice]

unset array3[2]

8. Agrega elementos a la matriz.

①Método 1
Agregar individualmente el
nombre de la matriz [X] = Y

array3[2]=30

② Método dos (el elemento de valor medio no debe tener omisiones)
sin ninguna eliminación, el valor máximo del índice es la longitud del elemento menos uno.
Nombre de la matriz [$ # {Nombre de la matriz [*]}] = X

array3[${#array3[*]}]=88

③Método tres

Obtenga todos los elementos de la matriz de origen directamente más los nuevos elementos que se agregarán, y reasigne la matriz, actualice el índice de definición.
No se pueden omitir las comillas dobles; de lo contrario, si hay elementos en la matriz que contienen espacios, los elementos se dividirá en múltiplos por espacios. uno
no puede ser "@" reemplazado por "*", consistente con el rendimiento "@" si se reemplaza por asteriscos, sin las comillas simples, comillas dobles cuando todos los elementos en la matriz serán array_name como un elemento agregado a la matriz
Nombre de matriz media = ("$ {nombre de matriz [@]}" elemento numérico x elemento numérico y elemento numérico z)

array3=("${array3[@]}" 99 100)

④Método 4
Nombre de matriz + = (valor x valor y valor z)

array3+=(200 300 400)

Tres, pasar parámetros de matriz

#!/bin/bash

fun () {

 echo "函数收到的值为：$@"
  newarr=$@
  echo "新数组的值为：${newarr[@]}"

}

arr=(60 20 30 40 50)
echo "arr数组的值为：${arr[@]}"

fun ${arr[@]}

Cuarto, devuelve una matriz de una función.

1. Ejemplo 1

#!/bin/bash

test (){

  newarr=($@)
  sum=0
  for i in ${newarr[@]}
  do
   sum=$[$sum+$i]

  done
  echo $sum

}

arr=(10 20 30 40 50)
echo "原数组arr的值为:${arr[@]}"
res1=$(test ${arr[@]})
echo "新数组的所有数值和为：$res1"

2. Ejemplo 2

#!/bin/bash

test () {

  newarr=($@)
#  echo "函数接收的数组1为：${newarr[@]}"

  for ((i=0;i<${#newarr[@]};i++))
  do
    newarr[$i]=$[${newarr[$i]} * 2]

  done
  echo ${newarr[@]}

}

arr=(10 20 30 40 50)
echo "原数组的值为：${arr[@]}"
res1=$(test ${arr[@]})
echo "新数组的值为：${res1[@]}"
~                                

Cinco, algoritmo de clasificación

1. Clasificación de burbujas

①Concepto

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.

Idea básica:
la idea básica de la clasificación de burbujas es comparar los valores de dos elementos adyacentes. Si se cumplen las condiciones, los valores de los elementos se intercambian, el elemento más pequeño se mueve al frente de la matriz y el elemento más grande se mueve a la parte posterior de la matriz (es decir, el intercambio de dos La posición de cada elemento), de modo que el elemento más pequeño se eleva desde abajo hacia arriba como una burbuja.

Idea del algoritmo: el
algoritmo de burbujeo se implementa mediante un bucle de doble capa, donde el bucle exterior se utiliza para controlar el número de rondas de clasificación. En general, la longitud de la matriz a ordenar se reduce en 1, porque solo hay una matriz elemento dejado en el último bucle, y no se requiere comparación. La clasificación se ha completado. 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.

②Secuencia positiva

#!/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[@]}"

③ Orden inverso

#!/bin/bash
paixu () {
array=($@)
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 -lt $second ];then
         #把第一个数值赋予给一个临时变量temp
         temp=${array[$a]}
         #把第二个数值赋予给第一个数值
         array[$a]=${array[$a+1]}
         #再把第一个数值的值（临时变量temp）赋予给第二个数值
         array[$a+1]=$temp
       fi
    done
done
echo "排序后的数组顺序为：${array[@]}"
}
list=$@
paixu $list

2. Seleccione ordenar directamente

Clasificación de selección directa
En comparación con la clasificación de burbujas, la clasificación de selección directa tiene menos intercambios, por lo que es más rápida.

La idea básica:
compare la posición de clasificación especificada con otros elementos de la matriz por separado. Si se cumple la condición, el valor del elemento se intercambia. Tenga en cuenta que aquí se distingue la clasificación de burbujas. En lugar de intercambiar elementos adyacentes, se intercambia el elemento que cumple la condición con la posición de ordenación especificada (como 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 60 50 30 10 40)
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开始比较数值
     value=${arr[$b]}
     #判断如果从索引1开始比较的数值大于当前最大的数值，就记录最大的索引到ind
     if [ $value -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. Invierta el orden

#!/bin/bash

arr=(10 20 30 40 50)
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[@]}