目录
一、数组的概念
二、数组定义方法
三、数组
1.获取数组长度
2.获取数组数据列表
3.获取数组下标列表
4.读取某下标赋值
5.数组遍历
6.数组切片
7.数组替换
8.数组删除
四、数组追加元素
五、向函数传数组参数
编辑六、数组排序算法
1.冒泡排序
2.直接选择排序
3.反转排序
一、数组的概念
数组（Array）是有序的元素序列
若将有限个类型相同的变量的集合命名，那么这个名称为数组名。
组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。
用于区分数组的各个元素的数字编号称为下标
数组是在编程中，为了处理方便， 把具有相同类型的若干元素按有序的形式组织起来的一种形式
这些有序排列的同类数据元素的集合称为数组
二、数组定义方法
(30 20 10 60 50 40)
0 1 2 3 4 5
方法一：
数组名=(value0 value1 value2 ...)
#以空格间隔，如果值为字符类型，需要加单引号或双引号
数组名=（value0 value1 value2 ...）
方法二：
数组名=([0]=value [1]=value [2]=value ...)
#以空格间隔，“ [ ] ”里表示元素的下标，第一个元素从0开始
数组名=（[0]=value [1]=value [2]=value ...）
方法三：
列表名="value0 value1 value2 ..."
数组名=($列表名)
列表名="value0 value1 value2 ..."
数组名=($列表名)方法四：
数组名[0]="value"
数组名[1]="value"
数组名[2]="value"
数组名 [0]="value"
数组名 [1]="value"
数组名 [2]="value"数组包括的数据类型
●数值类型
●字符类型
使用" "或' '定义
三、数组
1.获取数组长度
arr_number=(1 2 3 4 5)
arr_length=${#arr_number[*]}
${#arr_number[@]}
echo $arr_length
2.获取数组数据列表
echo ${arr_number[*]}
echo ${arr_number[@]}
3.获取数组下标列表
echo ${!arr_number[*]}
4.读取某下标赋值
arr_index2=${arr_number[2]}
echo $arr_index2
5.数组遍历
#!/bin/bash
arr_number=(1 2 3 4 5)
for v in ${arr_number[@]}
do
echo $v
done
6.数组切片
arr=(1 2 3 4 5)
echo ${arr[@]} #输出整个数组echo ${arr[@]:0:2} #获取 ${数组名[@或*]:起始位置:长度} 的值
echo ${arr1[*]:1:3}
echo ${arr[@]:2:3}
7.数组替换
arr=(1 2 3 4 5)
echo ${arr[@]/4/66} #${数组名[@或*]/查找字符/替换字符}
echo ${arr[@]} #并不会替换数组原有内容arr=(${arr[@]/4/66}) #要实现改变原有数组，可通过重新赋值实现
echo ${arr[@]}
8.数组删除
arr=(1 2 3 4 5)
unset arr #删除数组
echo ${arr[*]}arr=(1 2 3 4 5)
unset arr[2] #删除第三个元素
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)
待添加元素必须用“()”包围起来，并且多个元素用空格分隔
[root@localhost ~]# array1=(10 20 30 40 50)
[root@localhost ~]# echo ${array1[*]}
10 20 30 40 50
[root@localhost ~]# echo ${!array1[@]}
0 1 2 3 4
[root@localhost ~]# array1[5]=60
[root@localhost ~]# echo ${!array1[@]}
0 1 2 3 4 5
[root@localhost ~]# echo ${array1[*]}
10 20 30 40 50 60
五、向函数传数组参数
如果将数组变量作为函数参数，函数只会取数组变量的第一个值。
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=($@)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[*]}"
[root@localhost ~]# vim 14.sh
#!/bin/bash
test1() {
echo "函数接收到的参数列表：$@"
}
arr1=(50 40 30 20 10)
test1 $arr1
[root@localhost ~]# bash 14.sh
函数接收到的参数列表：50
[root@localhost ~]# vim 14.sh
#!/bin/bash
test1() {
echo "函数接收到的参数列表：$@"
}
arr1=(50 40 30 20 10)
test1 ${arr1[@]}
六、数组排序算法
1.冒泡排序
类似气泡上涌的动作，会将数据在数组中从小到大或者从大到小不断的向前移动。
基本思想：
冒泡排序的基本思想是对比相邻的两个元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把大的元素移动到数组后面（也就是交换两个元素的位置），这样较小的元素就像气泡一样从底部上升到顶部。
算法思路
冒泡算法由双层循环实现，其中外部循环用于控制排序轮数，一般为要排序的数组长度减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 ]
then
#把第一个元素值保存到临时变量中
temp=$first
#把第二个元素值赋给第一个元素
array[$j]=$second
#把临时变量（也就是第一个元素原值）赋给第二个元素
array[$k]=$temp
fi
done
done
#输出排序后的数组
echo "new_array：${array[*]}"2.直接选择排序
与冒泡排序相比，直接选择排序的交换次数更少，所以速度会快些。
基本思想：
将指定排序位置与其它数组元素分别对比，如果满足条件就交换元素值，注意这里区别冒泡排序，不是交换相邻元素，而是把满足条件的元素与指定的排序位置交换（如从最后一个元素开始排序），这样排序好的位置逐渐扩大，最后整个数组都成为已排序好的格式。
#!/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=$[$length-$i]
#把当前轮次的最后一个元素的值保存在临时变量中
temp=${array[$last]}
#把最大的元素的值赋给最后一个元素
array[$last]=${array[$index]}
#把原最后一个元素的值赋给原最大值的位置的元素
array[$index]=$temp
done
echo ${array[*]}3.反转排序
以相反的顺序把原有数组的内容重新排序。
基本思想：
把数组最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换，以此类推，直到把所有数组元素反转替换。
#!/bin/bash
array=(10 20 30 40 50 60)
length=${#array[*]}
for ((i=0; i<$length/2; i++))
do
temp=${array[$i]}
array[$i]=${array[$length-$i-1]}
array[$length-$i-1]=$temp
done
echo ${array[*]}
