目录

一、数组的概念

二、数组定义方法

三、数组

1.获取数组长度

2.获取数组数据列表

3.获取数组下标列表

4.读取某下标赋值

5.数组遍历

6.数组切片

7.数组替换

8.数组删除

四、数组追加元素

五、向函数传数组参数

​编辑六、数组排序算法

1.冒泡排序

2.直接选择排序

3.反转排序

---

一、数组的概念

数组（Array）是有序的元素序列

若将有限个类型相同的变量的集合命名，那么这个名称为数组名。
组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。
用于区分数组的各个元素的数字编号称为下标
数组是在编程中，为了处理方便， 把具有相同类型的若干元素按有序的形式组织起来的一种形式
这些有序排列的同类数据元素的集合称为数组

二、数组定义方法

(30 20 10 60 50 40)
  0  1  2  3  4  5
  
方法一：
数组名=(value0 value1 value2 ...)

#以空格间隔，如果值为字符类型，需要加单引号或双引号

数组名=（value0 value1 value2 ...）
 

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

#以空格间隔，“ [ ] ”里表示元素的下标，第一个元素从0开始

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

方法三：
列表名="value0 value1 value2 ..."
数组名=($列表名)

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

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

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

数组包括的数据类型
●数值类型
●字符类型
使用" "或' '定义

三、数组

1.获取数组长度

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

2.获取数组数据列表

echo ${arr_number[*]}
echo ${arr_number[@]}

3.获取数组下标列表

echo ${!arr_number[*]}

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

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

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

7.数组替换

arr=(1 2 3 4 5)

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

arr=(${arr[@]/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[*]}

四、数组追加元素

方法一：

array_name[index]=value

方法二：

array_name[${#array_name[@]}]=value

方法三：

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

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

方法四：

array_name+=(value1 ... valueN)
待添加元素必须用“()”包围起来，并且多个元素用空格分隔

[root@localhost ~]# array1=(10 20 30 40 50)
[root@localhost ~]# echo ${array1[*]}
10 20 30 40 50
[root@localhost ~]# echo ${!array1[@]}
0 1 2 3 4
[root@localhost ~]# array1[5]=60
[root@localhost ~]# echo ${!array1[@]}
0 1 2 3 4 5
[root@localhost ~]# echo ${array1[*]}
10 20 30 40 50 60

五、向函数传数组参数

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

test1() {
  echo "接收到的参数列表：$@"
  newarrary=($1)
  echo "新数组的值为：${newarrary[*]}"
}

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

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

test2() {
  newarrary=($(echo $@))
  echo "新数组的值为：${newarrary[*]}"

}

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

从函数返回数组

test2() {
  newarrary=($@)

  sum=0
  for value in ${newarrary[*]}
  do
    sum=$[$sum + $value]
  done
  echo $sum
}

test3() {
  newarrary=(`echo $@`)
  for ((i=0; i<=$[$# - 1]; i++))
  {
    newarrary[$i]=$[${newarrary[$i]} * 2]
  }
  echo ${newarrary[*]}
}

array=(3 2 1 4 5)
echo "原始数组的值为：${array[*]}"
result1=`test2 ${array[*]}`
echo "新数组的和为：$result1"

result2=(`test3 ${array[*]}`)
echo "新数组的值为：${result2[*]}"

[root@localhost ~]# vim 14.sh

#!/bin/bash

test1() {
  echo "函数接收到的参数列表：$@"
}


arr1=(50 40 30 20 10)

test1 $arr1

[root@localhost ~]# bash 14.sh
函数接收到的参数列表：50




[root@localhost ~]# vim 14.sh

#!/bin/bash

test1() {
  echo "函数接收到的参数列表：$@"
}

arr1=(50 40 30 20 10)

test1 ${arr1[@]}

六、数组排序算法

1.冒泡排序

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

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

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

#!/bin/bash
array=(63 4 24 1 3 15)
echo "old_array：${array[*]}"
length=${#array[*]}
#定义比较轮数，比较轮数为数组长度减1，从1开始
for ((i=1; i<$length; i++))
do
  #确定比较元素的位置，比较相邻两个元素，较大的数往后放，比较次数随比较轮数而减少
  for ((j=0; j<$length-i; j++))
  do
    #定义第一个元素的值
    first=${array[$j]}
    #定义第二个元素的值
    k=$[$j+1]
    second=${array[$k]}
    #如果第一个元素比第二个元素大就互换
    if [ $first -gt $second ]
    then
      #把第一个元素值保存到临时变量中
      temp=$first
      #把第二个元素值赋给第一个元素
      array[$j]=$second
      #把临时变量（也就是第一个元素原值）赋给第二个元素
      array[$k]=$temp
    fi
  done
done
#输出排序后的数组
echo "new_array：${array[*]}"

2.直接选择排序

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

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

#!/bin/bash
array=(63 4 24 1 3 15)
length=${#array[*]}
#定义排序轮数
for ((i=1; i<$length; i++))
do
  index=0
  #确定用于比较的第一个元素的索引范围
  for ((j=1; j<=$length-i; j++))
  do
    #通过比较获取最大值元素的索引位置
    if [ ${array[$j]} -gt ${array[$index]} ];then
       index=$j
    fi
  done
  #获取每轮最后一个元素的索引 
  last=$[$length-$i]
  #把当前轮次的最后一个元素的值保存在临时变量中
  temp=${array[$last]}
  #把最大的元素的值赋给最后一个元素
  array[$last]=${array[$index]}
  #把原最后一个元素的值赋给原最大值的位置的元素
  array[$index]=$temp
done

echo ${array[*]}

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[$length-$i-1]=$temp
done

echo ${array[*]}