數組排序算法（冒泡/直接/反轉/希爾排序）

1、數組包括的數據類型

• 數值類型

• 字符類型（使用" "或者’ '定義）

2、數組定義方法

(30 20 10 60 50 40)
 0  1  2  3  4  5

方法1:
數組名= (value0 value1 value2 ...)

方法2:
數組名=([0]=value [1]=value [2]=value ...)

方法3:
列表名="value0 value1 value2 ..."
數組名=($列表名)

方法4:
數組名[0]="value"
數組名[1]="value"
數組名[2]="value"

 

3、獲取數組長度

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

 

4、獲取數據列表

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

 

5、讀取某下標賦值

arr_index2=${arr_number [2]}
echo $arr_index2

 

6、數組遍歷

#!/bin/bash

arr=(10 20 30 40 50)
for i in ${arr[@]}
do
  echo $i
done

 

7、數組切片

arr=(1 2 3 4 5)
echo ${arr[@]}       #輸出整個數組
echo ${arr[@]:0:2}   #獲取${ 數組名[@或*] :起始位置:長度}的值
echo ${arr1[*]:1:3}
echo ${arr[@]:2:3}

 

8、數組替換

arr=(1 2 3 4 5)
echo ${arr[@]/4/66}  #${數組名[@或*]/查找字符/替換字符}
echo ${arr[@]}      #並不會替換數組原有內容

arr=(${arr[@]/4/66})  #要實現改變原有數組，可經過從新賦值實現
echo ${arr[@]}

 

9、數組刪除

arr=(1 2 3 4 5)
unset arr   #刪除數組
echo ${arr[*]}

arr=(1 2 3 4 5)
unset arr[2]    #刪除第三個元素
echo ${arr[*]}

 

10、數組追加元素

方法1：
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)
待添加元素必須用「()"包圍起來，而且多個元素用空格分隔

 

11、向函數傳數組參數

若是將數組變量做爲函數參數，函數貝會取數組變量的第一個值

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[*]}

 

12、從函數返回數組

test2() {
newarrary=(`echo $@ `)

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=(`itest3 ${array[*]}`)
echo "新數組的值爲: ${result2[*]}"

 

十3、數組排序算法

一、冒泡排序

相似氣泡上涌的動做，會將數據在數組中從小到大或者從大到小不斷的向前移動

基本思想:

冒泡排序的基本思想是對比相鄰的兩個元素值，若是知足條件就交換元素值，把較小的元素移動到數組前面，把大的元素移動到數組後面(也就是交換兩個元素的位置)，這樣較小的元素就像氣泡同樣從底部.上升到頂部

算法思路：

冒泡算法由雙層循環實現，其中外部循環用於控制排序輪數，一 般爲要排序的數組長度減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[*]}'

 

從小到大排列：

自定義：

從大到小排列：

二、直接選擇排序

與冒泡排序相比，直接選擇排序的交換次數更少，因此速度會快些

基本思想:

將指定排序位置與其它數組元素分別對比，若是知足條件就交換元素值，注意這裏區別冒泡排序，不是交換相鄰元素，而是把知足條件的元素與指定的排序位置交換(如從最後-~個元素開始排序)，這樣排序好的位置逐漸擴大，最後整個數組都成爲已排序好的格式

三、反轉排序

以相反的順序把原有數組的內容從新排序

基本思想:

把數組最後一個元素與第一個元素替換，倒數第二個元素與第二個元素替換，以此類推，直到把全部數組元素反轉替換

#! /bin/bash

array=(1020 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[*]}

 

四、希爾排序

#!/bin/bash


arr=(20 10 30 50 60 40)
echo "原始數組排列爲：${arr[@]}"
length=${#arr[@]}

#把距離爲gap的元素編爲一個組，掃描全部組，每次循環減小增量
for ((gap=$length/2;gap>0;gap/=2))
do
   for ((i=gap;i<$length;i++))
   do
       temp=${arr[$i]}
       #對距離爲gap的元素組進行排序，每一輪比較拿當前輪次最>後一個元素與組內其它元素比較，將數組大的日後放
       for ((a=i-gap;a>=0&temp<${arr[$a]};a-=gap))
       do
         arr[$a+$gap]=${arr[$a]}
       done
       #和最左邊較大的元素調換位置
         arr[$a+$gap]=$temp
   done
done
echo "新的數組排列爲：${arr[*]}"

 

希爾排序詳細說明：

希爾排序，又稱縮小增量法。其基本思想是：

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






1 5 2 3 7 6 9 4

gap=2

i=2 i<7 i++
temp=${array[2]}=2

j=2-2=0 2<1 ...


i=3
temp=${array[3]}=3
j=3-2=1 3<5
array[3]=${array[1]}=5
j=1-2=-1 ...
array[-1+2]=3


1 3 2 5 7 6 9 4
gap=2

i=4
temp=${array[4]}=7
j=4-2=2 7<2...

i=5
temp=${array[5]}=6
j=5-2=3 6<5...

i=6
temp=${array[6]}=9
j=6-2=4 9<7...

1 3 2 5 7 6 9 4
i=7
temp=${array[7]}=4
j=7-2=5 4<6
array[5+2]=${array[5]}=6
1 3 2 5 7 6 9 6
j=5-2=3 4<5
array[3+2]=${array[3]}=5
1 3 2 5 7 5 9 6
j=3-2=1 4<3....
array[1+2]=4
1 3 2 4 7 5 9 6