Shell编程之数组

Posted 2021-05-21 Zmac111

Shell编程之数组

• 一、数组定义的方法
• • 方法1
  • 方法2
  • 方法3
  • 方法4
• 二、数组的相关概述
• • 1.数组包括的数据类型
  • 2.获取数组长度
  • 3.获取数据列表
  • 4.读取某个下标赋值
• 三、数组的操作
• • 1.数组遍历
  • 2.数组切片
  • 3.数组替换
  • 4.数组删除
  • 5.数组追加元素
  • • 方法1 ：单个添加，需要知道数组中有多少参数，以及没有对数组进行任何删减
    • 方法2：利用数组长度来增加
    • 方法3：直接获取源数组的全部元素再加上新要添加的元素，一并重新赋予该数组，重新刷新定义索引（用$@）
  • 方法4：待添加元素用“()”包起来，多个元素则用空格分隔
• 四、数组传参给函数
• 五、从函数返回数组
• 六、排序算法
• • 1.冒泡排序
  • 2.直接选择排序
  • 3.反转排序
• 总结

一、数组定义的方法

方法1

数组名=（value0 value1 value2 …）

方法2

数组名=（[0]=value [1]=value [2]=value …)

方法3

列表名=“value0 value1 value2 …”
数组名=（$列表名）

方法4

数组名[0]=“value”
数组名[1]=“value”
数组名[2]=“value”

二、数组的相关概述

1.数组包括的数据类型

(1)数值类型
(2)字符类型（字符串）
使用" " 或 ’ ’ 定义，防止元素当中有空格，元素按空格分割

2.获取数组长度

arr_number=(1 2 3 4 5)
echo ${#arr_number[*]} 或 echo ${#arr_number[@]} 

3.获取数据列表

echo ${arr_number[*]}
或
echo ${arr_number[@]}

4.读取某个下标赋值

arr_index2=${arr_number[2]}
echo $arr_index2

实操

三、数组的操作

1.数组遍历

2.数组切片

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

注：切片是重新输出数组，即使下标一开始没有赋值，也不会影响输出

3.数组替换

格式：${数组名[*或@]/源参数值/将要替换的参数值}
arr2=(1 2 3 4 5)
#临时替换:将数组arr1中的参数值3替换为66,但原来的数组中的参数值并不会改变
echo ${arr2[*]/3/66}     
echo ${arr2[*]}

#永久替换:可通过重新赋值实现
arr2=(${arr2[*]/3/66})   
echo ${arr2[*]}

实操1，临时替换和永久替换

实操2，数组中两个60，替换第一个

4.数组删除

格式：unset 数组名[索引]     #删除单个
      unset 数组名          #删除整个数组

5.数组追加元素

方法1 ：单个添加，需要知道数组中有多少参数，以及没有对数组进行任何删减

举例
arr4=(1 2 3 4 5 6 7)
echo ${arr4[*]}
arr4[7]=8          #指定索引添加参数
echo ${arr4[*]}

方法2：利用数组长度来增加

arr4=(1 2 3 4 5 6 7)
echo ${arr4[*]}
arr4[${#arr4[*]}]=8  #根据长度添加参数
echo ${arr4[*]}

注：特殊情况如果在定义数组时，中间缺了下标，则不能使用

方法3：直接获取源数组的全部元素再加上新要添加的元素，一并重新赋予该数组，重新刷新定义索引（用$@）

arr4=(1 2 3 4 5 6 7)
echo ${arr4[*]}
arr4=("${arr4[@]}" 8 9 10)  #加上新参数重新定义数组
echo ${arr4[*]}
双引号不能省略，否则数组中存在包含空格的元素时会按空格将元素拆分成多个
不能将“@”替换为“*”，如果替换为“* ”，不加双引号时与“@”的表现一致，加双引号时，会将数组array_name中的所有元素作为一个元素添加到数组中

补充：$ @和$*的区别

$@和$*的区别
定义时不加""两者没有区别
加上""
$* 将数组中的数据作为一个整体使用
$@ 将数组中每个参数分别作为单个的个体使用

举例

方法4：待添加元素用“()”包起来，多个元素则用空格分隔

arr5=(1 2 3 4 5 6 7)
echo ${arr5[*]}
arr5+=(8 9 11)   #添加参数，这种方法用的比较多
echo ${arr5[*]}

四、数组传参给函数

（1）如果将数组变量作为函数参数,函数只会取数组变量的第一个值

#!/bin/bash 

test1 () {
   echo "函数接受到的参数列表：$@"
   newarr=$@
   echo "函数中新的数组的值为：${newarr[@]}" 
}

arr=(30 20 10 40 50)
echo "原始数组的值为：${arr[*]}"
test1 $arr                       #将数组变量作为函数的参数，只会取数组变量的第一个值

（2）解决这个问题则需要将数组变量的值分解成单个的值，然后将这些值作为函数参数使用。在函数内部，再将所有的参数重新组合成一个新的数组变量

#!/bin/bash 

test1 () {
   echo "函数接受到的参数列表：$@"
   newarr=$@
   echo "函数中新的数组的值为：${newarr[@]}" 
}

arr=(30 20 10 40 50)
echo "原始数组的值为：${arr[*]}"
test1 ${arr[*]}

五、从函数返回数组

#!/bin/bash

#用于求数组中所有元素的累加和
test2 () {
   newarr1=($@)
   arrlist=${newarr1[*]}
   sum=0

   for i in $arrlist
   do
     sum=$[$sum+$i]
   done
   echo $sum

}

#用于把原数组中所有元素值乘以2后生成一个新的数组并输出
test3 () {
    newarr2=($@)
    length=${#newarr2[@]}
    for ((j=0;j<=$length-1;j++))
    do
      newarr2[$j]=$[${newarr2[$j]} * 2]
    done
    echo ${newarr2[*]}

}
######main######

arry=(10 20 30 40 50)
echo "原数组的列表为：${arry[@]}"
res1=`test2 ${arry[@]}`
echo "test1中的新数组的累加和为：$res1"

实操

六、排序算法

1.冒泡排序

基本思想：
冒泡排序的基本思想是对比相邻的两个元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把大的元素移动到数组后面（也就是交换两个元素的位置），这样较小的元素就像气泡一样从底部上升到顶部。

算法思路：
冒泡算法由双层循环实现，其中外部循环用于控制排序轮数，一般为要排序的数组长度减1次，因为最后一次循环只剩下一个数组元素，不需要对比，同时数组已经完成排序了。而内部循环主要用于对比数组中每个相邻元素的大小，以确定是否交换位置，对比和交换次数随排序轮数而减少。

#!/bin/bash
read -p "请输入一个数组列表：" list
#定义一个初始数组
arr=($list)
echo "原数组的顺序为：${arr[@]}"
#获取数组的长度
length=${#arr[@]}

#冒泡排序
#定义比较轮数，为数组长度减1，并且要从1开始
for ((i=1;i<$length;i++))
do
  #确定每次比较的元素下标，比较相邻2个元素，大的往后放，小的往前放，并且每轮比较的次数要随着轮数递减
  for ((j=0;j<$length-$i;j++))
  do
  #获取第一个元素的值
  first=${arr[$j]}
  #获取第二个元素的值
  k=$[$j+1]
  second=${arr[$k]}
  #比较第一个元素和第二个元素的值，如果第一个元素值大于第二个元素值则两个元素位置交换
  if [ $first -gt $second ]
  then
    #先把第一个元素值保存在临时变量temp中
    temp=${arr[$j]}
    #把第二个元素的值赋给第一个元素
    arr[$j]=$second
    #把原来第一个元素的值赋给第二个元素
    arr[$k]=$temp
  fi
  done
done
 echo "排序后新的数组顺序为：${arr[@]}"

2.直接选择排序

与冒泡排序相比，直接选择排序的交换次数更少，所以速度更快。

基本思想：
将指定排序位置与其他数组元素分别对比，如果满足条件就交换元素值，注意这里区别冒泡排序，不是交换相邻元素，而是把满足条件的元素与指定的排序位置交换（如从最后一个元素开始排序），这样排序好的位置逐渐扩大，最后整个数组都成为已排序好的格式。

#!/bin/bash

read -p "请输入一个数组列表：" list
arr=($list)
length=${#arr[@]}
echo "原数组的顺序为：${arr[@]}"
for ((i=1;i<$length;i++))
do
  #先假设最大元素下标为0
  index=0
  #用于确定实际最大元素的下标，从第二个元素开始比较，最后一个元素下标随着比较轮数递减
  for ((j=1;j<=$length-$i;j++))
  do
    if [ ${arr[$j]} -gt ${arr[$index]} ]
    then
        index=$j
    fi
  done

  #在确定好当前轮次最大元素下标后，开始最大元素的值和当前轮次最后一个元素进行交换
  last=$[$length-$i]
  temp=${arr[$last]}
  arr[$last]=${arr[$index]}
  arr[$index]=$temp

done
  echo "排序后的新数组的顺序为：${arr[@]}"

3.反转排序

以相反的顺序把原有数组的内容重新排序

基本思想：
把数组最后一个元素与第一个元素替换。倒数第二个元素与第二个元素替换，以此类推，直到把所有的数组元素反转替换完

#!/bin/bash

read -p "请输入一个数组列表：" list

arr=($list)
length=${#arr[*]}
echo "反转前数组的顺序为：${arr[*]}"

for ((i=0;i<$length/2;i++))
do
  temp=${arr[$i]}
  arr[$i]=${arr[$length-1-$i]}
  arr[$length-1-$i]=$temp
done
echo "反转排序后新数组顺序为：${arr[*]}"

总结

（1）数组概念及3种排序方法（冒泡排序、直接选择排序、反转排序）
（2）注意数组定义时，一开始下标没有赋值时，数组切片时，数组会重新进行排序，正常输出（下标从0开始）
（3）利用数组长度来增加数组元素时，如果在定义数组时，中间缺了下标，则不能使用。