Shell数组和排序

---

一、数组

1、数组定义方法

方法一：数组名=（value0 value1 value2 …）

方法二：数组名=( [0]=value [1]=value [2]-value …)

方法三:列表名=“value0 valuel value2 …”
数组名=($列表名)

方法四:数组名[0]=“value”
数组名[1]=“value”
数组名[2]=“value”

2、数组包括的数据类型

数值类型
字符类型
使用“ ”或‘ ’定义

3、获取数组长度

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

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 ${arr1[@]:0:2} #获取 ${数组名[@或 星号）：起始位置：长度 }的值
echo ${arr1[*]:2:2}

7、数组替换

arr=(1 2 3 4 5)
echo ${arr1[@]/4/66} # ${数组名[@或 星号）/查找字符/替换字符}
echo ${arr[@]}
arr1=( ${arr1[*]/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[@]}

9、数组添加元素

数组追加元素
方法一 :
array_ name [index] =value

方法二:
array_ name [ ${#array_ name [@]} ]=value

方法三:
array_ name= (" ${array_ name [@] }" value1 … valueN)
双引号不能省略，否则，当数组array_ name中存在包含空格的元素时会按空格将元素拆分成多个
不能将“@”替换为“ * ”，如果替换为“ * ”，不加双引号时与“@”的表现一致，加双引号时，会将数组array_ name中的所有元素作为一个 元素添加到数组中
方法四:
array_ name+= (value1… valueN)
待添加元素必须用“()”包围起来，并且多个元素用空格分隔

10、向函数传数组参数

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

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

解决这个问题则需要将数组变量的值分解成单个的值，然后将这些值作为函数参数使用。在函数内部，再将所有的参数重新组合成一个新的数组变量。
#!/bin/bash
test2 () {
newarrary=( $ (echo $@))
echo "新数组的值为： ${newarrary[]}”
}
array=(3 2 1 4 5)
echo “原始数组的值为： $ {array[@]}”
test2 ${array[*]}

二、数组排序算法

1、冒泡排序

类似气泡上涌的动作，会将数据在数组中从小到大或者从大到小不断的向前移动。
基本思想:
冒泡排序的基本思想是对比相邻的两个元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把大的元素移动到数组后面(也就是交换两个元素的位置)，这样较小的元素就像气泡一样从底部上升到顶部。
算法思路
冒泡算法由双层循环实现，其中外部循环用于控制排序轮数，一般为要排序的数组长度减1次，因为最后一次循环只剩下一一个数组元素，不需要对比，同时数组已经完成排序了。而内部循环主要用于对比数组中每个相邻元素的大小，以确定是否交换位置，对比和交换次数随排序轮数而减少。
#!/bin/bash
#升序
shengxu(){
#list1=echo $@
#shuzu=( $ list1)
#echo 原数组： $ {shuzu[]}
long= $ {#shuzu[]}
for((i=1;i do
for((j=0;j do
z= $ [ $j+1]
if [ ${shuzu[ $j]} -gt KaTeX parse error: Expected '}', got 'EOF' at end of input: {shuzu[z]} ]
then
temp= $ {shuzu[ $ j]}
shuzu[ $ j]=$ [shuzu[ $ z]]
shuzu[ $ z]= $ temp
fi
done
done
echo 升序排序后的数组：${shuzu[]}
}
#降序
jiangxu(){
#list1=echo $@
#echo $ list1
#shuzu=( $ list1)
#echo 原数组：$ {shuzu[]}
long= $ {#shuzu[]}
for((i=1;i do
for((j=0;j do
z= $ [ $ j+1]
if [ $ {shuzu[ $ j]} -lt $ {shuzu[$ z]} ]
then
temp=$ {shuzu[ $ j]}
shuzu[ j]=$[shuzu[ $ z]]
shuzu[ $ z]= $ temp
fi
done
done
echo 降序排序后的数组：${shuzu[]}
}

read -p “请输入想要排序的数组：” list
shuzu=($(echo $list))
read -p “请选择排序方法：” q
if [ $q = ‘升序’ ];then
shengxu
#fi
elif [ $q = ‘降序’ ];then
jiangxu
fi

2、直接排序

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

#!/bin/bash
abc=(22 41 24 12 53 6)
echo 原数组：$ {abc[]}
long= $ {#abc[]}
for((i=1;i do
y=0
for((j=1;j<=long-i;j++))
do
if [ $ {abc[$ j]} -gt $ {abc[$ [$ y]]} ]
then
y= $ j
fi
done
temp= $ {abc[long-i]}
abc[long-i]=$ {abc[y]}
abc[y]=$tempdoneecho升序排序后的数组：${abc[*]}

for((i=1;i do
y=0
for((j=1;j<=long-i;j++))
do
if [ $ {abc[$ ]} -lt $ {abc[$ [$ y]]} ]
then
y=$
fi
done
temp=$ {abc[long-i]}
abc[long-i]=$ {abc[y]}
abc[y]=$temp
done

echo 降序排序后的数组：${abc[*]}

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[ $ ength- $ i-1]= $temp
done
echo ${array[@] }