shell脚本之数组

数组定义方法

(30 20 10 60 50 40) #元素，以空格为分割，从左往右，元素1，元素2…；用括号括起来的，注意和列表"1 2 3 4 5"区分
0 1 2 3 4 5 #索引，每个元素对应的下标序号，从0开始

方法一：

数组名=(value0 value1 value2...)

方法二：

数组名=([0]=value [1]=value [2]=value...)

方法三：

列表名="value0 valuel value2..."
数组名=($列表名）

方法四： #也可以修改或者添加值

数组名[0]="value"
数组名[1]="value"
数组名[2]="value"

数组包括的数据类型

• 数值类型
• 字符类型：
  使用""或’'定义

获取数组长度

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

echo Sarr_length

获取数据列表

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

读取某下标赋值

arr_index2=${arr_number[2]}
echo sarr_index2

数组遍历

#!/bin/bash` `arr_number=(12345)
for v in ${arr_number[@]}
do
echo $v
done

数组切片

arr=(1 2 3 4 5)
echo ${arr[@]} #输出整个数组

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

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

echo ${arr[@]:2:3}

数组替换

arr=(1 2 3 4 5)

echo ${arr[@]/4/66} #${数组名[@或*]/查找字符/替换字符}
echo ${arr[@]} #并不会替换数组原有内容

arr=(${arr[@]/4/66}) #要实现改变原有数组，可通过重新赋值实现
echo ${arr[@]}

数组删除

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

数组追加元素

方法一：

array_name[index]=value

方法二：

array_name[${#array_name[@]}]=value

但是，中间的元素不能有缺漏，删掉一个

方法三：

array_name=("${array_name[@]}"value1...valueN)
双引号不能省略，否则，当数组array_name中存在包含空格的元素时会按空格将元素拆分成多个
不能将"@“替换为”**"，如果替换为"*"，不加双引号时与"@"的表现一致，加双引号时，会将数组array_name中的所有元素作为一个元素添加到数组中
for i in "${array_name [@]}"; do echo $i; done

方法四：

array_name+=(value1...valueN)

待添加元素必须用"()"包围起来，并且多个元素用空格分隔

向函数传数组参数

如果将数组变量作为函数参数，函数只会取数组变量的第一个值。
test1() {
echo"接收到的参数列表：$@"
newarrary=($1)
echo"新数组的值为：${newarrary[*]}"
}

array=(3 2 1 4 5)
echo "原始数组的值为：${array[*]}"
test1 $array

解决这个问题则需要将数组变量的值分解成单个的值，然后将这些值作为函数参数使用。在函数内部，再将所有的参数重新组合成一个新的数组变量。
test2() {
newarrary=($(echo $@))
echo"新数组的值为：${newarrary[*]}"
}

array=(3 2 1 4 5)
echo"原始数组的值为：${array[\*]}" test2 ${array[*]}

从函数返回数组

test2() {
  newarrary=(`echo $`)

  sum=0
  for value in ${newarrary[*]}
  do
    sum=$[$sum+$value]
  done
  echo $sum
}

test3() {
  newarrary=(`echo $@`)
  for ((i=0; i<=$[$# - 1]; i++))
  {
    newarrary[$i]=$[${newarrary[$i]} * 2]
  }
  echo ${newarrary[*]}
}

array=(3 2 1 4 5)
echo"原始数组的值为：${array[*]}"
result1=`test2 ${array[*]}`
echo"新数组的和为：$result1"

result2=(``test3 ${array[*]}`)
echo"新数组的值为：${result2[*]}"

数组排序算法：

冒泡排户

类似气泡上涌的动作，会将数据在数组中从小到大或者从大到小不断的向前移动。

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

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

#!/bin/bash
array=(63 4 24 1 3 15)
echo "old_array: ${array[*]}"
length=${#array[*]}
#定义比较轮数，比较轮数为数组长度减1,从1开始
for ((i=1; i<$length; i++))
do
  #确定比较元素的位置，比较相邻两个元素，较大的数往后放，比较次数随比较轮数而减少
  for ((j=0;j<$length-i;j++
  do
    #定义第一个元素的值
    first=${array[$j]}
    #定义第二个元素的值
    k=$[$j+1]
    second=${array[$k]}
    #如果第一个元素比第二个元素大就互换
    if [ $first -gt $second ]

直接选择排序

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

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

#!/bin/bash
array=(63 4 24 1 3 15)
length=${#array[*]}
#定义排序轮数
for ((i=1; i<$length; i++))
do
  index=0
  #确定用于比较的第一个元素的索引范围
  for ((j=1; j<=$length-i; j++))
  do
    #通过比较获取最大值元素的索引位置
    if [ ${array[$j]} -gt ${array[$index]} ];then
       index = $j
	fi
  done
  #获取每轮最后一个元素的索引
  last=$[$lengt-$i]
  #把当前轮次的最后一个元素的值保存在临时变量中
  temp=${array[$last]}
  #把最大的元素的值赋给最后一个元素
  array[$last]=${array[$index]}
  #把原最后一个元素的值赋给原最大值的位置的元素
  array[$index]=$temp
done

echo ${array[*]}

反转排序

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

#!/bin/bash
array=(10 20 30 40 50 60)
length=${#array[*]}
for ((i=0; i<$length/2; i++))
do
  temp=${array[$i]}
  array[Si]=${array[$length-$i-1]}
  array[$length-Si-1]=$temp
done

echo ${array[*]}