目录
一：数组定义方法
1、方法一
数组名=（value0 value1 value2…）
2、方法二
数组名=（[0]=value [1]=value [2]=value…）
3、方法三
数组名=“value0 value1 value2…”
数组名=（$列表名）
4、方法四
数组名[0]=“value”
数组名[1]=“value”
数组名[2]=“value”
数组名[3]=“value”
5、判断数组是否完整
思路：通过数组最后一位与列表最后一位进行比对
（1）方法一
（2）方法二：通过脚本
[root@localhost ~]# vim test.sh
#!/bin/bash
a5=([0]=10 [1]=20 [3]=40 [4]=50) #定义数组
length=${#a5[@]} #定义数组的长度
lastnum=$[length - 1] #定义最后一位数的下标，长度减一
lastone=${a5[$lastnum]} #定义下标
curlast=$(echo ${a5[@]} | awk '{print $NF}') #定义最后一个字段
echo "a5数组的值为：${a5[@]}"
if [ $lastone -eq $curlast ];then #判断最后一位数值是否相等
echo "a5数组是完整的！" #相等则输出完整
else
echo "a5数组缺失元素！" #不相等则输出缺失
fi
二：获取数组值
1、获取数组长度
[root@localhost ~]# echo ${a1[@]}
10 20 30 40 50 60
[root@localhost ~]# echo ${#a1[@]}
6
[root@localhost ~]# echo ${#a1[*]}
6
2、获取数组数据列表
[root@localhost ~]# echo ${a1[*]}
10 20 30 40 50 60
[root@localhost ~]# echo ${a1[@]}
10 20 30 40 50 60
3、获取数组下标列表
[root@localhost ~]# echo ${!a1[@]}
0 1 2 3 4 5 
4、读取某下标赋值
[root@localhost ~]# echo ${a1[@]}
10 20 30 40 50 60
[root@localhost ~]# bl=${a1[3]}
[root@localhost ~]# echo $bl
40
5、数组遍历
[root@localhost ~]# for i in ${a1[@]}
> do
> echo $i
> done
10
20
30
40
50
60
6、求数组所有的数值的和
[root@localhost ~]# for i in ${a1[@]}
> do
> sum=$[sum + i]
> done
[root@localhost ~]# echo $sum
210
三：数组值的改变
1、数组切片
[root@localhost ~]# echo ${a1[@]}
10 20 30 40 50 60
[root@localhost ~]# echo ${a1[@]:0:2} #0为第一下标位，2为长度，2个字符
10 20
[root@localhost ~]# echo ${a1[*]:3:3} #3为第三下表位，3为长度，3个字符
40 50 60
2、数组替换
（1）临时替换，数组根本不会替换
[root@localhost ~]# echo ${a1[@]}
10 20 30 40 50 60
[root@localhost ~]# echo ${a1[@]/30/100}
10 20 100 40 50 60
[root@localhost ~]# echo ${a1[@]}
10 20 30 40 50 60
[root@localhost ~]# echo ${a1[@]/0/5}
15 25 35 45 55 65
[root@localhost ~]# echo ${a1[@]}
10 20 30 40 50 60
（2）永久替换需重新赋值
[root@localhost ~]# a6=(10 20 30 40 50 100)
[root@localhost ~]# echo ${a6[@]}
10 20 30 40 50 100
[root@localhost ~]# b1=${a6[@]/10/60} #将原数组的数据替换重新赋值一个新变量
[root@localhost ~]# echo ${b1[@]}
60 20 30 40 50 600 #100会认为10和0，所有也会替换
3、数组删除--unset
[root@localhost ~]# echo ${a1[@]}
10 20 30 40 50 60
[root@localhost ~]# unset a1[3] #删除数组下标位3的数值
[root@localhost ~]# echo ${a1[@]}
10 20 30 50 60
[root@localhost ~]# unset a1 #删除数组
[root@localhost ~]# echo ${a1[@]}
4、数组追加元素
（1）方法一
格式：数组名[下标位]=元素值
[root@localhost ~]# echo ${a2[@]}
20 30 50 10 40
[root@localhost ~]# a2[5]=77
[root@localhost ~]# echo ${a2[@]}
20 30 50 10 40 77
（2）方法二
格式：数组名[${数组名[@]}]=数值
[root@localhost ~]# echo ${a2[@]}
20 30 50 10 40 77
[root@localhost ~]# a2[${#a2[@]}]=88
[root@localhost ~]# echo ${a2[@]}
20 30 50 10 40 77 88数组完整时，会在数组最后一位追加
数组不完整时，会替换最后一位数值
（3）方法三
格式：数组名=（"${数组名[@]}" 元素值 ...） 注:双引号不能省略，否则，当数组中存在空格的元素时会按空格将元素拆分成多个
不能将“@”替换成“*”，如果替换为“*”，不加双引号时与“@”的表现一致，加双引号时，会将数组中的所有元素作为一个元素添加到数组中。
单引号时
双引号时
（4）方法四
格式：数组名+=（"元素名" "元素名"）
四：数组传参
1、数组传参
[root@localhost ~]# vim abc.sh
#!/bin/bash
test() {
one=($@)
echo "函数内的数组的元素列表为：${one[@]}"
echo $1
echo $2
echo $3
echo $4
echo $5
}
two=(11 22 33 44 55)
echo "函数外的数组的元素列表为：${two[@]}"
test ${two[@]}
2.、从函数返回数组
[root@localhost ~]# vim acc.sh
#!/bin/bash
test1() {
one=($@) #函数内的数组的元素列表为${one[@]}
for ((i=0;i<${#one[@]};i++)) #i小于${one[@]}所包含的数值个数，循环一次自加一
do
one[$i]=$[2 * ${one[$i]}] #定义新的数组值为原来数组值的2倍
done
echo ${one[@]}
}
two=(11 22 33 44 55)
echo "函数体外的数组的元素列表为：${two[@]}"
arr=($(test1 ${two[@]})) #调用函数
echo "新的数组值为：${arr[@]}"
五:数组排序算法
1、冒泡排序介绍
冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
运行流程：
比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
2.、冒泡排序事例
[root@localhost ~]# vim mpao.sh
#！/bin/bash
MAOPAO(){
arr=($@)
#获取数组的长度
length=${#arr[@]}
#外层循环用来定义比较轮数，比较轮数为数组长度减1，且从1开始
for ((a=1;a<length;a++));do
#内层循环用来确定比较元素的位置，比较相邻两个元素，较大的元素往后移，并且比较次数会随着比较轮数的增加而减少
for ((b=0;b<length-a;b++));do
#获取相邻两个元素的前面元素的值
first=${arr[$b]}
#获取相邻两个元素的后面元素的值
c=$[b + 1]
second=${arr[$c]}
#比较两个相邻元素的值大小，如果前面元素的值较大，则与后面元素交换位置
if [ $first -lt $second ];then
#使用临时变量保存前面元素的值，实现两个相邻元素交换位置
tmp=$first
arr[$b]=$second
arr[$c]=$tmp
fi
done
done
echo "冒泡排序后的数组的值为：${arr[@]}"
}
#### main ####
read -p "请输入一组列表：" num
array=($num)
echo "旧数组的值为：${array[@]}"
MAOPAO ${array[@]}
3.直接选择排序介绍
与冒泡排序相比，直接选择排序的交换次数更少，所以速度会快些。
运行流程：
将指定排序位置与其他数组元素分别对比，如果满足条件就交换元素值，注意这里区别冒泡排序，不是交换相邻元素，而是把满足条件的元素与指定的排序位置交换（如从最后一个元素开始排序），这样排序好的位置逐渐扩大，最后整个数组都成为排序好的格式。
4.直接选择排序事例
[root@localhost ~]# vim zhipai.sh
#!/bin/bash
arr=(19 30 1 50 66 99)
echo "排序前的数组值为；${arr[@]}"
length=${#arr[@]}
#外层循环定义排序的轮数，为数组长度减1，且从1开始
for ((a=1;a<length;a++))
do
#每轮比较的初始最大元素的下标，从0开始，即第一个元素
i=0
#内层循环定义用于与当前最大元素作比较的元素下标范围，从1开始，且每轮比较的最后一个元素下标会随着轮数增加而减少
for ((b=1;b<=length-a;b++))
do
#通过比较，获取当前轮数中最大元素的下标
if [ ${arr[$i]} -lt ${arr[$b]} ];then
i=$b
fi
done
#获取当前轮数的最后一个元素的下标
last=$[length - a]
#先用临时变量获取当前轮数的最后一个元素
tmp=${arr[$last]}
#将最大元素的值赋给当前轮数的最后一个轮数
arr[$last]=${arr[$i]}
#将临时变量的值，即原最后一个元素的值交换
arr[$i]=$tmp
done
echo "排序后的数组值为：${arr[@]}"
5.插入排序介绍
插入排序（Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
6. 插入排序事例
[root@localhost ~]# vim chapai.sh
#!/bin/bash
arr=(9 45 36 2 55 1 68)
echo "排序前数组值为：${arr[@]}"
length=${#arr[@]}
#外层循环定义待排序的元素下标位置
for ((a=1;a<length;a++))
do
#内层循环定义已排好的序列的元素的元素下标位置范围
for ((b=0;b<a;b++))
do
#将待排序的元素和前面已经排序好的元素依次比较，较小的数会交换到已排好序的元素位置，较大的数会放到待排序的元素位置
if [ ${arr[$a]} -lt ${arr[$b]} ];then
tmp=${arr[$a]}
arr[$a]=${arr[$b]}
arr[$b]=$tmp
fi
done
done
echo "排序后数组的值为：${arr[@]}"
7.反转排序介绍
以相反的顺序把原有的数组的内容重新排序
运行流程：
把数组最后一个元素与第一元素替换，倒数第二个元素与第二元素替换，以此类推，直到把所有数组元素反转替换。
8.反转排序事例
[root@localhost ~]# vim daopai.sh
#!/bin/bash
#定义数组
arr=(0 1 2 3 4 5 6 7 8 9)
echo "排序前数组的值为：${arr[@]}"
length=${#arr[@]}
#循环减半
for ((a=0;a<length/2;a++))
do
#获取第一个元素的值
tmp=${arr[$a]}
#获取当前轮数的最后一个元素下标，会随着轮数的增加而减少
last=$[length-1-a]
#替换最后一个元素
arr[$a]=${arr[$last]}
arr[$last]=$tmp
done
echo "排序后数组的值：${arr[@]}"
9. 睡眠排序
它的原理是将一组数字按照从小到大的顺序排序。这个算法的特殊之处在于它不使用任何比较操作或交换操作，而是利用了计算机的多线程和睡眠函数。通过数据在后台的睡眠时间进行排序，数值小的睡眠时间短，数值大的睡眠时间长。
[root@localhost ~]# vim shuimian.sh
#!/bin/bash
go() {
sleep `echo $1*0.01 | bc` #通过bc，进行浮点运算
echo $1
}
a=(6 9 2 5 3 78 99)
echo "初始数组值为：${a[@]}"
for i in ${a[@]};do
go $i &
done
sleep 1
10.希尔排序介绍
希尔排序（Shell Sort）是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL．Shell于1959年提出而得名。 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
11. 希尔排序事例
[root@localhost ~]# vim xier.sh
#!/bin/bash
array=(7 6 8 3 1 5 2 4)
echo "原数组值为：${array[*]}"
length=${#array[*]}
#把距离为gap的元素编为一个组，扫描所有组，每次循环减少增量
for ((gap=$length/2; gap>0; gap/=2))
do
for ((i=gap; i<$length; i++))
do
temp=${array[$i]}
#对距离为gap的元素组进行排序，每一轮比较拿当前轮次最后一个元素与组内其他元素比较，将数组大的往后放
for ((j=i-gap; j>=0&&temp<${array[$j]}; j-=gap))
do
array[$j+$gap]=${array[$j]}
done
#和最左边较大的元素调换位置
array[$j+$gap]=$temp
done
done
echo "排序后的数组值为：${array[*]}"
