一、陣列定義

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}"