shell脚本—数组

目录

• 一、数组
  • 1.1 定义方法
    • 1.1.1 定义方式1
    • 1.1.2 定义方式2
    • 1.1.3 定义方式3
    • 1.1.4 定义方式4
  • 1.2 数组包括的数据类型
  • 1.3 获取数组长度
  • 1.4 获取数据列表
  • 1.5 读取某索引赋值
  • 1.6 数组遍历
  • 1.7 数组切片
  • 1.8 数组替换
  • 1.9 数组删除
  • 1.10 数组追加
    • 1.10.1 按照索引进行逐个添加
    • 1.10.2 按照最大索引值进行向后添加
    • 1.10.3 建立新数组（老数组+新元素）
    • 1.10.4 老数组+=（新元素）
  • 1.11 向函数传递数组参数
    • 1.11.1 需求
    • 1.11.2 脚本命令
    • 1.11.3 操作验证
• 二、数组排序算法
  • 2.1 冒泡法
    • 2.1.1 分析
    • 2.1.2 脚本命令
    • 2.1.3 操作验证
  • 2.2 直接排序法
    • 2.2.1 分析
    • 2.2.2 脚本命令
    • 2.2.3 操作验证
  • 3.1 反转排序
    • 3.1.1 分析
    • 3.1.2 脚本命令
    • 3.1.3 操作验证

一、数组

1.1 定义方法

数组名=（元素1 元素2 元素3 元素4 ... 元素n）

注：每个元素都有自己的下标(下标值从0开始定义)，并且元素可以是字符串或是数字

1.1.1 定义方式1

1.num=(10 20 30 40 50) ---数组名=（各元素）
2.echo ${num[*]}       ---输出整个数组内容

1.1.2 定义方式2

1.num=([0]=10 [1]=20 [2]=30 [3]=40 [4]=50)  ---数组名=（[下标值]=元素值）
2.echo ${num[*]}       ---输出整个数组内容

1.1.3 定义方式3

1.aaa="10 20 30 40 50"  ---定义列表=“列表内容（元素值）”
2.num=($aaa)            ---数组名=（$列表名）
3.echo ${num[*]}        ---输出整个数组内容

1.1.4 定义方式4

1.num[0]="zhang san"    ---数组名[下标值]="元素"
2.num[1]="zhang san"               .                
3.num[2]="zhang san"               .
4.num[3]="zhang san"    ---数组名[下标值]="元素"
5.echo ${num[*]}        ---输出整个数组内容

1.2 数组包括的数据类型

1.数值类型

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

1.3 获取数组长度

echo ${#数组名[*或者@]}

1.4 获取数据列表

echo ${数组名[*或者@]}

1.5 读取某索引赋值

echo ${数组名[下标值（0开始）]}

1.6 数组遍历

1.7 数组切片

1.8 数组替换

1.9 数组删除

1.10 数组追加

1.10.1 按照索引进行逐个添加

1.10.2 按照最大索引值进行向后添加

1.10.3 建立新数组（老数组+新元素）

注：1.双引号不能省略，否则数组中存在包含空格的元素时会按空格将元素拆分成多个
2.不能将“@”替换为“”，如果替换为“”，不加双引号时与“@”的表现一致，加双引号时，会将数组array_name中的所有元素作为一个元素添加到数组中

1.10.4 老数组+=（新元素）

1.11 向函数传递数组参数

1.11.1 需求

1.向函数传递数组
2.求和

1.11.2 脚本命令

test1 (){
   echo "函数接收到的参数列表为：$@"
   newarr=($@)
   echo "新数组的值为：${newarr[@]}"
   sum=0
   for i in ${newarr[@]}
   do
     sum=$[$sum + $i]
   done
   echo "数组所有元素的累加值为：$sum" 
}


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

1.11.3 操作验证

二、数组排序算法

2.1 冒泡法

2.1.1 分析

1.类似气泡上涌的动作，会将数据在数组中从小到大或者从大到小不断的向前移动。
2.基本思想：
冒泡排序的基本思想是对比相邻的两个元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把大的元素移动到数组后面（也就是交换两个元素的位置），这样较小的元素就像气泡一样从底部上升到顶部。
3.算法思路：
冒泡算法由双层循环实现，其中外部循环用于控制排序轮数，一般为要排序的数组长度减1次，因为最后一次循环只剩下一个数组元素，不需要对比，同时数组已经完成排序了。而内部循环主要用于对比数组中每个相邻元素的大小，以确定是否交换位置，对比和交换次数随排序轮数而减少

2.1.2 脚本命令

arr=(63 4 24 1 3 15)
echo "原始数组的顺序为：${arr[@]}"
#获取数组长度
length=${#arr[@]}
#外层循环定义比较轮数，轮数为数组长度减1，从1开始
for((a=1;a<$length;a++))
do
  #这里使用变量b代表左边比较元素的下标
  for((b=0;b<$length-a;b++))
  do
     #定义左边比较元素的值
     left=${arr[$b]}
     #定义右边比较元素的值
     c=$[$b + 1]
     right=${arr[$c]}
     #如果左边的元素比右边的元素的值大就互换位置
     if [ $left -gt $right ];then
       #左边元素的值保存到临时变量tmp中
       tmp=$left
       #右边的元素值赋给左边元素
       arr[$b]=$right
       #再保存在临时变量中的值赋给右边元素
       arr[$c]=$tmp
     fi
  done
done
echo "新数组的顺序为:${arr[@]}"

2.1.3 操作验证

2.2 直接排序法

2.2.1 分析

1.与冒泡排序相比，直接选择排序的交换次数更少，所以速度会快些
2.基本思想：
将指定排序位置与其它数组元素分别对比，如果满足条件就交换元素值，注意这里区别冒泡排序，不是交换相邻元素，而是把满足条件的元素与指定的排序位置交换 （如从最后一个元素开始排序），这样排序好的位置逐渐扩大，最后整个数组都成为已排序好的格式

2.2.2 脚本命令

arr=(63 4 24 1 3 15)
echo "原始数组的顺序为：${arr[@]}"
#定义排序轮数
length=${#arr[@]}
for((a=1;a<$length;a++))
do
   max=0
   #通过比较获取拥有最大值的下标
   for ((b=1;b<=$length-a;b++))
   do
     #通过比较获取最大值元素的索引位置
      right=${arr[$b]}
      left=${arr[$max]}
      if [ $right -gt $left ];then
         max=$b
      fi
   done
   #把最大元素的值跟当前轮次最后一个元素的值进行交换
   #获取每轮最后一个元素的索引
   last=$[$length - $a]
   #把当前轮次的最后一个元素的值保存在临时变量中
   tmp=${arr[$last]}
   #把最大的元素的值赋给最后一个元素
   arr[$last]=${arr[$max]}
   #把原最后一个元素的值赋给原最大值的位置的元素
   arr[$max]=$tmp
done
echo "排序后的数组顺序为：${arr[@]}"

2.2.3 操作验证

3.1 反转排序

3.1.1 分析

以相反的顺序把原有数组的内容重新排序
基本思想：
把数组最后一个元素与第一个元素替换。倒数第二个元素与第二个元素替换，以此类推，直到把所有的数组元素反转替换完

3.1.2 脚本命令

arr=(1 2 3 4 5 6 7 8 9)
echo "原始数组的顺序为：${arr[@]}"
length=${#arr[@]}
for ((a=0;a<$length/2;a++))
do
    tmp=${arr[$a]}
    arr[$a]=${arr[$length-1-$a]}
    arr[$length-1-$a]=$tmp
done
echo "反转排序后的数组顺序为：${arr[@]}"

3.1.3 操作验证