shell编程数组与冒泡算法排序详解

• 一 数组的四种表达方式
• 二 数组的增删改查操作
• 三 数组传参
• 3.1 主程序向函数传数组参数
• 3.2 从函数返回数组到主程序
• 四 冒泡算法排序

一 数组的四种表达方式

方法1：
数组名=(value0 value1 value2 …)
方法2：
数组名=([0]=value [1]=value [2]=value)
方法3：
列表名=“value0 value1 value2 …”
数组名=($列表名)
方法4：
数组名[0]=“value”
数组名[1]=“value”
数组名[2]=“value”
……

二 数组的增删改查操作

获取数组的长度
arr_length=${#arr_number[*]}
数组切片

[root@localhost ~]# a=(1 2 3 4 5)
[root@localhost ~]# echo ${a[*]}  		//输出整个数组
1 2 3 4 5
[root@localhost ~]# echo ${a[@]:0:2}  #${数组名[@或*]:起始位置：长度]
1 2 
[root@localhost ~]# echo ${a[@]:2:3}
3 4 5
注意：将数组切片之后，返回的是字符串，以空格作为分隔符

数组替换

arr=(1 2 3 4 5)
echo ${arr[@]/4/66}  //${数组名[@或*]/查找字符/替换字符}
1 2 3 66 5
echo ${arr[@]}       //并不会替换数组原有内容
1 2 3 4 5
a=(${arr[@]/4/66})		//要实现改变原有数组，可通过重新赋值实现
echo ${arr[*]}
1 2 3 66 5

删除数组

[root@localhost ~]# arr=(1 2 3 4 5)
[root@localhost ~]# unset arr		//删除整个数组

[root@localhost ~]# unset arr[2]		//删除第三个元素
[root@localhost ~]# echo ${arr[*]}
1 2 4 5

数组添加元素

方法1 array_name[index]=value
方法2 array_name[${#array_name[@]}]=value
方法3 array_name=("${array_name[@]}" value1 ... valueN)
方法4 array_name+=(value1 value 2 ... valueN)

注意：
"${array_name[@]}"中双引号不能省略，否则当数组array_name中出现包含
空格的元素时会按空格将元素拆分成多个

不能把@替换成*，否则在加双引号时会把数组array_name中的所有元素作为一个元素添加到数组中

三 数组传参

3.1 主程序向函数传数组参数

在函数中调用数组的时候可能会出现下面的问题

#!/bin/bash
test1() {
echo "函数接收到的列表为：$@"
newarray=$1
echo ${newarray[*]}
}
array=（3 2 1 4 5）
echo "原始的数组值为${array[*]}"
test1 $array

运行结果如下图所示

此时需要将数组变量的值分解成单个的值，然后把这些值作为函数参数使用。在函数内部，再将所有的参数重新组合成一个新的数组变量。
演示代码如下：

#!/bin/bash
test2() {
newarray=($(echo $@))		//$@会把接收到的所有的位置参数都表示出来，并且分割成单个元素。此处也可以写成newarray=($@)
echo "新数组的值为：${newarray[*]}"
}
array=（3 2 1 4 5）
echo "原始的数组值为${array[*]}"
test2 ${array[*]}		//此处{}必加，表示把这个数组看作一个整体

运行结果如下

3.2 从函数返回数组到主程序

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

array=(3 2 1 4 5)
result=($(test3 ${array[*]}))
echo "新数组的值为：${result[*]}"

四 冒泡算法排序

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

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

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

代码实现

#!/bin/bash
paixu() {
array=($1)
for ((i=1;i<${#array[*]};i++)) ##比较轮数为数组长度减1，从1开始
do
        for ((j=0;j<${#array[*]}-i;j++))  ##比较相邻两个元素，较大的数往后放，比较次数随比较比较轮数而减少
        do
        if [ ${array[$j]} -gt ${array[$[$j+1]]} ]  ##如果第一个元素比第二个元素大就互换
        then
        temp=${array[$j]}  ##把第一个元素值保存在临时变量中
        array[$j]=${array[$[$j+1]]}  ##把第二个元素值保存到第一个元素中
        array[$[$j+1]]=$temp  ##把临时变量（也就是第一个元素原值），保存到第二个元素中
        fi
        done
done
echo ${array[*]}
}
#主体代码
f=$(cat $1)
paixu $f

运行结果如下