Tableau Shell et algorithme de tri (algorithme de tri de bulles; tri par sélection directe; tri inversé)

1. Méthode de définition des tableaux

Valeur de l'élément: (30 20 10 60 50 40)
Index: 0 1 2 3 4 5
Quatre méthodes

1.première méthode

Nom du tableau = (valeur0 valeur1 valeur2…)

2.Deuxième méthode
Nom du tableau = ([0] = valeur [1] = valeur [2] = valeur…)

3.Troisième méthode
Nom de la liste = "valeur0 valeur1 valeur2…"
Nom du tableau = ($ nom de la liste)

4.Méthode quatre
Nom du tableau [0] = "valeur"
Nom du tableau [1] = "valeur"
Nom du tableau [2] = "valeur"

Deux, les types de données inclus dans le tableau

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

Troisièmement, obtenez la longueur du tableau et obtenez la liste de données

Obtenez la longueur du tableau

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

Obtenir la liste des données

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

Lire une affectation d'index

echo ${array[索引号]}

Quatre, traversée du tableau

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

Cinq, tranchage de tableau

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

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

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

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

Six, remplacement de la baie

Méthode 1: remplacement unique

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

Méthode 2: remplacement temporaire de plusieurs remplacements (ne changera pas les données de la matrice d'origine)

array=(1 2 3 4 5)

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

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

Cinq, suppression de tableau

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

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

Six, ajoutez des éléments au tableau

première méthode:

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

Deuxième méthode:

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

Troisième méthode:

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

Les guillemets doubles ne peuvent pas être omis, sinon, lorsqu'il y a des éléments dans le tableau qui contiennent des espaces, les éléments seront divisés en plusieurs parties par des espaces. Vous ne pouvez pas remplacer "@" par " ". Si vous le remplacez par " ", il sera combiné avec "@" "" se comporte de la même manière, lorsque des guillemets doubles sont ajoutés, tous les éléments du tableau seront ajoutés au tableau en tant qu'élément

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

Méthode quatre:

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

Sept, passez les paramètres du tableau à la fonction

Si une variable de tableau est utilisée comme paramètre de fonction, la fonction ne prendra que la première valeur de la variable de tableau

#/bin/bash

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

Pour résoudre ce problème, vous devez décomposer les valeurs des variables de tableau en valeurs individuelles, puis utiliser ces valeurs comme paramètres de fonction. À l'intérieur de la fonction, recombinez tous les paramètres dans une nouvelle variable de tableau

#/bin/bash

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

Huit, la fonction passe des paramètres au tableau

Exemple 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"

Exemple 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[@]}"

Neuf, algorithme de tri de tableau

(1) Algorithme de tri des bulles

Semblable à la recrudescence des bulles, les données continueront à avancer dans le tableau de petite à grande ou de grande à petite.
2. L'idée de base: L'idée de base du tri des bulles est de comparer les valeurs de deux éléments adjacents, d'échanger les valeurs des éléments si les conditions sont remplies, de déplacer le plus petit élément vers l'avant du tableau et de déplacer le plus grand élément à l'arrière du tableau (c'est-à-dire, permutez les positions des deux éléments) de sorte que le plus petit élément monte du bas vers le haut comme une bulle.
3. Idée d'algorithme: l'algorithme de bullage est implémenté par une double boucle, dans laquelle la boucle externe est utilisée pour contrôler le nombre de tours de tri, généralement la longueur du tableau à trier moins 1 fois, car il n'y a qu'un seul élément du tableau laissé dans la dernière boucle, et aucune comparaison n'est requise. En même temps, le tableau a été trié. La boucle interne est principalement utilisée pour comparer la taille de chaque élément adjacent dans le tableau pour déterminer s'il faut échanger des positions.Le nombre de comparaisons et d'échanges diminue avec le nombre de tours de tri.

#!/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) Sélectionnez et triez directement

1. Tri par sélection directe
Par rapport au tri par bulles, le tri par sélection directe a moins d'échanges, il est donc plus rapide.
2. Idée de base: comparez respectivement la position de tri spécifiée avec d'autres éléments du tableau. Si la condition est remplie, la valeur de l'élément sera échangée. Notez que la différence entre le tri des bulles n'est pas d'échanger des éléments adjacents, mais d'échanger les éléments qui se rencontrent les conditions avec la position de tri spécifiée. (Par exemple, commencez le tri à partir du dernier élément), de sorte que la position triée se développe progressivement, et finalement le tableau entier devient le format trié

#!/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) Affichage inversé

1. Réorganisez le contenu du tableau d'origine dans l'ordre inverse.
2. Idée de base:
remplacez le dernier élément du tableau par le premier élément. L'avant-dernier élément est remplacé par le deuxième élément, et ainsi de suite, jusqu'à ce que tous les éléments du tableau soient inversés et remplacés

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