数组及算法的运算

一.数组定义方法

方法一

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

方法二

数组名=([0] =value [1]=value [2]=value ... )

方法三

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

方法四

数组名[0]="value"
数组名[1]="value"
数组名[2]="value"

☝ 注意事项：

Ⅰ.数组包括的数据类型

• 数值类型
• 字符类型
  ——使用" "或’ '定义，防止元素中有空格被分割
  

Ⅱ.获取数组长度

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

Ⅲ.数组遍历

Ⅳ.数组切片

将数组进行分割，截取自己想要的元素

arr=(1 2 3 4 5)
#赋值arr数组元素
echo ${arr[@]}
#输出整个数组

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

echo $ {arr[*]:1:3}

echo $ {arr[@]:2:3}

Ⅴ.数组替换

arr=(1 2 3 4 5)

echo $ {arr[@]/4/66}      #${数组名[@或*]/查找字符/替换字符}
echo $ {arr[@]}           #并不会替换数组原有内容

arr=(${arr[@]/4/66})      #要实现改变原有数组,可通过重新赋值实现
echo ${arr[@]}

Ⅵ.数组删除

arr=(1 2 3 4 5)
unset arr                  #删除数组
echo ${arr[*]}
arr=(1 2 3 4 5)
unset arr[2]               
#删除第三个元素，删除后剩下元素对应的下标依旧不变
echo ${arr[*]}

Ⅶ.数组追加元素

① 方法一：

array _name [index]=value     #数组名 [序列号]=元素

② 方法二：

array _name [${#array_name[@]}]=value     #数组名[数组长度]=元素

☞当下标正常排序，且下标有对应元素时可以使用:

☛当下标元素出现空档时，也就是没有时，谨慎使用

③ 方法三：

array_name=("${array_name[@]} " value1 ... valueN)
#双引号不能省略，否则，当数组array_name中存在包含空格的元素时会按空格将元素拆分成多个不能将""@"替换为"*"，如果替换为"*"，不加双引号时与"e"的表现一致，加双引号时，会将数组array _name中的所有元素作为一个元素添加到数组中

for i in "$ {array_name [@]} "; do echo $i; done

④ 方法四:

array name+=(value1 ... valueN)

• 待添加元素必须用"()"包围起来，并且多个元素用空格分隔
  

二.函数与数组间的传参

2.1向函数传数组参数

• 如果将数组变量作为函数参数，函数只会取数组变量的第一个值。

#!/bin/bash
test1(){
  echo "函数接收到的参数列表为：$@"
  newarr=($1)
  echo "函数中新的数组的值为：${newarr[@]}" 
}

arr=(30 40 20 10 50)
echo "原始的数组列表为：${arr[@]}"
test1 $arr

[root@centos7-1 shell]# bash shuzu1.sh 
原始的数组列表为：30 40 20 10 50
函数接收到的参数列表为：30
函数中新的数组的值为：30

2.2 数组向函数传参步骤：

1. 现将数组拆分成列表 ${arr[*]}
2. 函数通过$@获取之前将数组拆分成的列表 $@
3. 在函数中重新把列表定义成数组 newarr=($@0)
4. 对新的数组进行进一步的处理，在echo 输出

解决这个问题则需要将数组变量的值分解成单个的值，然后将这些值作为函数参数使用。在函数内部，再将所有的参数重新组合成一个新的数组变量。

#!/bin/bash

test2(){
  newarr1={$@}
  length=${#newarr1[@]}
  for ((j=0;j<=$lenth-1;j++))
  do
      newarr1[$j]=$[${newarr1[$j]}*2]
  done

  echo ${newarr1[*]}
}

#######main############
array=(10 20 30 40 50)
echo "原数组的列表为：${array[@]}"

res1=`test1 ${array[@]}`
echo "test1中的新数组的累加和为：$res1"

res2=($(test2 ${array[@]}))
echo "test2中的新数组的值为：${res2[@]}"

三.数组排序算法

3.1 冒泡排序

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

3.1.1 基本思想

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

3.1.2 算法思路

——冒泡算法由双层循环实现

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

#!/bin/bash
read -p "请输入一个数组列表：" list
#定义一个初始数组
arr=($list)  #获取第一个元素的值
echo "原数组的顺序为：${arr[@]}"
#获取数组的长度
length=${#arr[@]}

#冒泡排序：
#定义比较轮数，为数组长度减一，并且要从一开始
for ((i=1;i<=$length;i++))
do
  #确定没比较的元素下标，比较相邻两个元素，大的往后放，小的往前放，并且每轮比较的次数要随着轮数递减
  for ((j=0;j<$length-$i;j++))
  do
  #获取第一个元素的值
  first=${arr[$j]}
  #获取第二个元素的值
  k=$[$j + 1]
  second=${arr[$k]}
  #比较第一个元素和第二个元素的值，如果第一个元素大于第二个元素值则
  if [ $first -gt $second ];then
     #先把第一个元素的值保存在临时变量temp中
     temp=${arr[$j]}
     #把第二个元素的值赋给第一个元素
     arr[$j]=$second
     #把原来第一个元素的值赋给第二个元素
     arr[$k]=$temp
  fi
  done
done

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


[root@centos7-1 shell]# bash shuzu2.sh 
请输入一个数组列表：2 4 7 3 9 1
原数组的顺序为：2 4 7 3 9 1
排序后新的数组的顺序为：1 2 3 4 7 9

3.2 直接选择排序

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

3.2.1 基本思想

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

3.2.2 实验

#!/bin/bash

arr=(30 10 40 20 50)
length=${#arr[@]}
echo "原始数组的顺序为${arr[@]}"
for ((i=1;i<=$length;i++))
do
   #先假设最大的元素下标为0
   index=0
   #用于确定实际最大元素的下标，从第二个元素开始比较，最后一个元素下标随着比较轮数递减
   for ((j=1;j<=$length-$i;j++))
   do
       if [ ${arr[$j]} -gt ${arr[index]} ];then
          index=$j
       fi
   done
   #在确定好当前轮次的最大元素下标后，开始最大元素的值和当前轮次最后一个元素进行交换
   last=$[$length - $i]
   temp=${arr[$last]}
   arr[$last]=${arr[$index]}
   arr[$index]=$temp
done

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


[root@centos7-1 shell]# bash shuzu3.sh 
原始数组的顺序为30 10 40 20 50
排序后的新数组的顺序为：10 20 30 40 50

3.3 反转排序

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

3.3.1基本思想

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

3.3.2 实验

#!/bin/bash

arr=(10 20 30 40 50 60 70)
length=${#arr[@]}
echo "原始的数组顺序为：${arr[@]}"
for ((i=0;i<=$length/2;i++))
do
    temp=${arr[$i]}
    arr[$i]=${arr[$length-1-$i]}
    arr[$length-1-$i]=$temp

done

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

[root@centos7-1 shell]# bash shuzu4.sh 
原始的数组顺序为：10 20 30 40 50 60 70
排序后的数组的顺序为：70 60 50 40 30 20 10