shell数组知识与其排序方法

一.数组定义方法

(30 20 10 60 50 40)     #数组
  0  1  2  3  4  5      #索引

方法一：

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

方法二：

数组名= （[0]=value [1]value [2]=value...）

方法三：

列表名="value0 value1 value2..."
数组名=($列表名)

方法四：

数组名=“value”
数组名=“value”
数组名=“value”

二.数组的数据类型

1. 数值类型
2. 字符类型

• 使用" "或’ '定义

三.获取数组长度

arr=(1 2 3 4 5 6)
#获取数组长度
1. echo ${#arr[*]}     

2. echo ${#arr[@]}

读取某索引赋值：

echo ${arr[1]}   
echo ${arr[2]}
echo ${arr[3]}

四.数组遍历

vim 16.sh

#!/bin/bash
arr=(1 2 3 4 5 6)

for i in ${arr[@]}
   do
   echo $i
done

五.数组切片

arry=(10 20 30 40 50 60)
echo ${arry[*]}           

echo ${arry[@]}       #输出整个数组，此处*与@相同

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

echo ${arry[@]:2:2}

echo ${arry[@]:3:4}

六.数组替换

#单个切换
arry=(10 20 30 40 50 60)
echo ${arry[*]}
arry[0]=66
echo ${arry[*]}

#多个替换（临时替换）
echo ${arry[*]/6/88}    #临时替换
echo ${arry[*]}         #原来的值不变

#多个替换（永久替换）
arrp=${arry[*]/6/888}
arry=(${arry[@]/6/888})
echo ${arry[*]}

七.数组删除

 #删除整个数组
echo ${arry[*]}
unset arry             
echo ${arry[*]}

 #删除数组中选择索引对应的元素
arr=(10 20 30 40 50 60 )
echo ${arr[*]}
unset arr[5]          
echo ${arr[*]}

八.数组追加元素

方法一：

#单个添加
arr=（10 20 30 40 50 60）
echo ${arr[*]}
arr[8]=66
arr[9]=88

方法二：

arr[${#arr[*]}]=10
echo ${arr[*]}

方法三：

arry=("${arry[@]}" 7 8 9 ...)

双引号不能省略，否则，当数组array_name中存在包含空格的元素时会按空格将元素拆分成多个
不能将“@”替换为“”，如果替换为“”，不加双引号时与“@”的表现一致，加双引号时，会将数组array_name中的所有元素作为一个元素添加到数组中

方法四：

arry+=(value0 value1 value2)

九.向函数传数组参数

#!/bin/bash
test1() {
 echo "函数接收到的值为：$@"
 newarr=($1 $2 $3 $4 $5)
 echo "新数组的值为：${newarr[@]}"

}

arr=(20 40 60 80 100)
echo "arr数组的值为：${arr[@]}"

test1 ${arr[@]}

十.排序算法

（一）冒泡排序

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

1.基本思想：

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

2.算法思路：

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

#!/bin/bash
read -p "请输入要排序的数组：" nu
arr=($nu)
echo "旧数组为：${arr[@]}"
length=${#arr[@]}
for ((i=1; i<$length; i++))
do
   for ((a=0; a<$length-$i; a++))
   do
   first=${arr[$a]}
   second=${arr[$a+1]}
   if [ $first -gt $second ];then
       funy=$first
       arr[$a]=$second
       arr[$a+1]=$funy

     fi
   done
done

echo "排序后数组的值为：${arr[*]}"

(二)直接选择排序

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

基本思想：

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

#!/bin/bash
arr=(66 88 99 77 55)
echo "原数组的值为：${arr[@]}"
length=${#arr[@]}
for ((a=1; a<$length; a++))
do
   fk=0
   for ((b=1; b<=$length-$a; b++))
   do
     max=${arr[$fk]}
     ys=${arr[$b]}
     if [ $ys -gt $max ];then
     fk=$b 

     fi 
   done
   last=$[$length-$a]  
   temp=${arr[$last]}  
   arr[$last]=${arr[$fk]}
   arr[$fk]=$temp

done

echo "排序后的数组为：${arr[*]}"

（三）反转排序

• 以相反的顺序把原有数组的内容重新排序

基本思想：

• 把数组最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换，以此类推，直到把所有数组元素反转替换