shell数组

最新推荐文章于 2024-08-30 13:45:00 发布

非常的银兴

最新推荐文章于 2024-08-30 13:45:00 发布

阅读量1.3k

点赞数

文章标签：排序算法算法

本文链接：https://blog.csdn.net/qingqui_/article/details/123055433

版权

一，数组

方法一

数组名=（value0 value1 value2 …）

array1=(10 20 30 40 50)

方法二

数组名=（[0]=value [1]=value [2]=value …)

array2=([0]=10 [1]=20 [2]=30 [3]=40 [4]=50)

方法三

列表名=“value0 value1 value2 …”

数组名=（$列表名）

列表名=“value0 value1 value2 …”
数组名=（$列表名）

方法四

数组名[0]=“value”

数组名[1]=“value”

数组名[2]=“value”

array4[0]=10
array4[1]=20
array4[2]=30
array4[3]=40
array4[4]=50

二，数组的数据类型

1、数值类型

字符类型（字符串）：使用" "或’ '定义，防止元素当中有空格，元素按空格分割

2、获取数组长度

echo ${#数组名[*]}

array1=(10 20 30 40 50)
echo ${#array1[*]}

3、读取某索引赋值

echo ${数组名[*]}——读取整个数组数值
echo ${数组名[x]}——读取索引x+1的数值
echo ${array1[*]}
echo ${array1[1]}
echo ${array1[3]}

4、数组遍历

#!/bin/bash
arr=(50 40 30 20 10)

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

5、数组切片

获取 ${数组名[@或*]：起始位置：长度} 的值
输出整个数组，此处*与@相同

arry1=(10 20 30 40 50)          
echo ${arry1[*]}       
echo ${arry1[*]:0:2}   
echo ${arry1[*]:1:4}
echo ${arry1[*]:2:2}

6、数组替换

单个数值替换

array1[2]=88

多个替换（临时替换）

echo ${array1[*]/0/66}

7、数组删除

整个数组删除

unset 数组名

unset arry

删除指定位置

unset 数组名[索引号]

unset array3[2]

8、数组追加元素

方法一

单个添加

数组名[X]=Y

array3[2]=30

方法二（中间数值元素不能有缺漏）

在不进行任何删减时，索引最大值，就是元素长度减一

数组名[$#{数组名[*]}]=X

array3[${#array3[*]}]=88

方法三

直接获取源数组的全部元素再加上新要添加的元素，一并重新赋予该数组，重新刷新定义索引
双引号不能省略，否则数组中存在包含空格的元素时会按空格将元素拆分成多个
不能将“@”替换为“*”，如果替换为星号，不加双引号时与“@”的表现一致，加双引号时，会将数组array_name中的所有元素作为一个元素添加到数组中
数组名=("${数组名[@]}" 数值元素x 数值元素y 数值元素z)

array3=("${array3[@]}" 99 100)

方法四

数组名+=(数值x 数值y 数值z)

array3+=(200 300 400)

三，数组传参

#!/bin/bash

fun () {

 echo "函数收到的值为：$@"
  newarr=$@
  echo "新数组的值为：${newarr[@]}"

}

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

fun ${arr[@]}

四，排序

1.希尔排序

又称缩小增量法。其基本思想是：

1.先选定一个小于N的整数gap作为第一增量，然后将所有距离为gap的元素分在同一组，并对每一组的元素进行直接插入排序。然后再取一个比第一增量小的整数作为第二增量，重复上述操作…

2.当增量的大小减到1时，就相当于整个序列被分到一组，进行一次直接插入排序，排序完成。

问题：为什么要让gap由大到小呢？

answer：gap越大，数据挪动得越快；gap越小，数据挪动得越慢。前期让gap较大，可以让数据更快得移动到自己对应的位置附近，减少挪动次数。

7 6 8 3 1 5 2 4
gap=(8+1)/2=4时比较，大的放后面
7-1 -> 1-7
6-5 -> 5-6
8-2 -> 2-8
3-4 -> 3-4

1 5 2 3 7 6 8 4
gap=4/2=2时比较
1 2 7 8
1 2->1 2
1 2 7-->1 2 7
1 2 7 8--->1 2 7 8

5 3 6 4		每一轮比较拿当前轮次最后一个元素与组内其他元素比较，将数组大的往后放
5 3->3 5
3 5 6-->3 5 6
3 5 6 4--->3 4 5 6

1 3 2 4 7 5 8 6
gap=2/2=1时比较
1 3->1 3
1 3 2-->1 2 3
1 2 3 4--->1 2 3 4
1 2 3 4 7---->1 2 3 4 7
1 2 3 4 7 5----->1 2 3 4 5 7
1 2 3 4 5 7 8------>1 2 3 4 5 7 8
1 2 3 4 5 7 8 6------->1 2 3 4 5 6 7 8

2.插入排序

插入排序，又叫直接插入排序。实际中，我们玩扑克牌的时候，就用了插入排序的思想。

基本思想：在待排序的元素中，假设前n-1个元素已有序，现将第n个元素插入到前面已经排好的序列中，使得前n个元素有序。按照此法对所有元素进行插入，直到整个序列有序。

#!/bin/bash
arr=(63 4 24 1 3 15)
echo ${arr[*]}
length=${#arr[@]}
for ((i=0; i<$length; i++))
{
    for((j=0; j<=$i; j++))
    {
        if [ ${arr[$i]} -lt ${arr[$j]} ]
        then
            tmp=${arr[$i]}
            arr[$i]=${arr[$j]}
            arr[$j]=$tmp
        fi
    }
}
echo ${arr[*]}

3.冒泡排序

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

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

#!/bin/bash
read -p "输入需要排序的数组:" x
array=($x)
echo "旧数组为：${array[@]}"
#获取数组长度
length=${#array[@]}
for ((i=1;i<$length;i++))
do
    #确定数值位置，大的往后放，并且比较次数随着轮数增加而减少
    for ((a=0;a<$length-$i;a++))
    do
       #定义第一个和第二个比较的数值
       first=${array[$a]}
       second=${array[$a+1]}
       if [ $first -gt $second ];then
         #把第一个数值赋予给一个临时变量temp
         temp=${array[$a]}
         #把第二个数值赋予给第一个数值
         array[$a]=${array[$a+1]}
         #再把第一个数值的值（临时变量temp）赋予给第二个数值
         array[$a+1]=$temp
       fi
    done
done
echo "排序后的数组顺序为：${array[@]}"