关于数组，应该不用我说了，懂得都懂。？？什么？？ 不懂？？不懂你害不进来康康

一、数组定义

1、定义数组的方法

10 20 30 40 50             #元素（不一定是按顺序来的，也可一数打乱的数）
0   1   2   3   4          #索引（从0开始，0对应元素上的第一位数，然后1对应元素第二位数，剩下的以此类推）

方法一、 数组名=(value0 value1 value2 ...)

方法二、  数组名=([0]=value [1]=value [2]=value ...)

方法三、  列表名="value0 value1value2 ...."
         数组名=($列表名)

方法四、   数组名[0]="value"
          数组名[1]="value" 
          数组名[2]="value"

2、数组包括的数据类型

1、数值类型

2、字符类型：使用" " 或 ’ ’ 定义

3、获取数组长度

abc=(1 2 3 4 5 6 7 8)                #定义数组
echo ${#abc[*]}或者echo ${#abc[@]}   #获取数组长度

4、读取某索引赋值

abc=(1 2 3 4 5 6 7 8)
echo ${abc[0]}

echo ${abc[2]}

echo ${abc[4]

4、数组遍历

#vim bianli.sh
#!/bin/bash
abccc=(1 2 3 4 5)

for i in ${abccc[@]}  #此处中括号里使用“*”、“@” 都可
do

     echo $i

done

5、数组切片

abccc=(1 2 3 4 5)

echo ${abccc[@]}          输出整个数组

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

echo ${abccc[@]：2：3}

这里因为元素长度只有5位数，所以董索引号 2 开始，长度 4 只能显示到长度 3 所在的位置

6、数组替换

永久替换

临时替换

abc=(1 2 3 4 5 6 7)
echo ${abc[@]}
abc[1]=12
echo ${abc[@]}

单个临时替换

多个临时替换

7、数组删除

echo ${abc[@]}

unset abc             #删除整个数组

echo ${abc[*]}

7、追加元素

方法一：单个添加
abc[4]=6
数组名+[索引]=元素

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

abc[${abc[*]}]=7

方法三：直接获取源数组的全部元素再加上新要添加的元素，一并重新赋予该数组，重新刷新定义索引

abc=(1 2 3 4 5 6 7)
echo ${abc[*]}

unset abc[2]
unset abc[4]

echo ${abc[*]}
echo ${abc[6]}
echo ${abc[5]}
echo ${abc[4]}
echo ${abc[2]}

abc=("${abc[@]}" 8 9 10)
echo ${abc[*]}
echo ${abc[4]}
echo ${abc[2]}

双引号不能省略，否则，当数组array_name中存在包含空格的元素时会按空格将元素拆分成多个

不能将"@"替换为"*"，如果替换为"*"，不加双引号时与"@"的表现一致，加双引号时，会将数组array_name中的所有元素作为一个元素添加到数组中

方法四：待添加元素必须用“()”包围起来，并且多个元素用空格分隔
abc+=(10 11 12 ...)

8、向函数传数组参数

#!/bin/bash
test() {
        newabc=($(echo $@))
echo $1 $2 $3 $4 $5
        echo "新数组的值为：${newabc[*]}"

        }

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

9、从函数返回数组

test1 () {
   newabc=(`echo $@`)  # 将数组传入函数，$@表示将每个元素分开输出“1、2、 3、 4、 5 ”

   sum=0
   for i in ${newabc[*]}  # for循环来求新数组newabc 的和，in 可以以空格分隔数组中的元素进行提取
   do
        sum=$[$sum+$i]    # 求元素之和
   done
        echo $sum         # 输出元素之和
}

test2 () {
   newabc=(`echo $@`)           # 将数组传入函数，$@表示将每个元素分开输出“1、2、3、4、5”
   for ((d=0; d<=$[$# - 1]; d++))  #  $#表示新数组元素的总个数（5），因为这边的i 同时也表示数组的所引号，所以要减一，即[0][1][2][3][4]
   do
        newabc[$d]=$[${newabc[$d]} * 2]   #表示将新数组的每个元素*2形成新的元素值，即将数组中的每个元素都扩大两倍
   done
        echo ${newabc[*]}     # 输出扩大后的两倍数组
}

abc=(1 2 3 4 5)
echo "原始数值为：${abc[*]}"  
result1=`test1 ${abc[*]}`      # 调用test1函数
echo "新数组的和为：$result1"
result2=(`test2 ${abc[*]}`)    # 调用test2 函数
echo "新数组的值为：${result2[*]}"

二、冒泡排序法

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

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

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

#!/bin/bash
abcd=(63 4 24 1 3 15)
echo "原数组元素顺序为：${abcd[*]}"

for ((i=1;i<${#abcd[*]};i++))
do
        for ((a=0;a<${#abcd[*]}-i;a++))
        do
                if [ ${abcd[$a]} -gt ${abcd[$a+1]} ]
                then
                temp=${abcd[$a]}
                abcd[$a]=${abcd[$a+1]}
                abcd[$a+1]=$temp
                fi

        done

done

        echo "经过冒泡排序后，数组顺序为：${abcd[*]}"

三、直接选择排序

直接选择排序：

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

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

#!/bin/bash
abc=(10 20 14 12 50 22 30)     #  定义数组并赋值
echo "原数组元素顺序为:${abc[*]}"  #  输出现在数组所有元素顺序为：${abc[*]}

length=${#abc[*]}     #  定义一个变量  将数组长度赋值给他，原数组长度为 6
for ((i=1;i<$long;i++))  #  使用for循环来定义排序轮数，比较5次
do
  index=0       #  表示从索引0开始比较
   for ((a=1;a<=$long-$i;a++))    #  设定每轮对比的次数
   do

    if [ ${abc[$a]} -gt ${abc[$index]} ]  #   比较第一个和第二个参数的大小
    then
    index=$a   #  如果第二个数比第一个数大，就将第二个数的索引值赋予变量 index
    fi
   last=$[$long-$i]  #  可以将每轮的最后一个索引值定义成一个变量

   temp=${array[$last]}  #  定义一个新的变量，将每轮的最后一个参数赋予这个变量
   abc[$last]=${abc[$index]}  #  将if循环出来的最大的数赋予最后一个位置
   abc[$index]=$temp   #  将变量temp 里的值赋予 if 循环出的索引位置

   done
done

    echo "经过直接排序后数组元素顺序为：${abc[*]}"   #  输出排序后的数组

四、反转排序

反转排序

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

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

#!/bin/bash
abc(60 20 30 50 10 40)
echo "反转前顺序：${abc]}"  
length=${#abc]}
for ((i=0;i<$length/2;i++))
do
  temp=${abc[$i]}
  abc[$bc]=${abc[$length-1-$i]}
  abc[$length-1-$i]=$temp
done
echo "反转排序后：${abc}"