從0開始學Golang之數(shù)組使用

數(shù)組的含義

數(shù)組是「相同類型」的變量的集合。也可以理解為「內存地址連續(xù)」的一組變量的集合。

數(shù)據(jù)結構

數(shù)組的定義

基本格式

//?指定初始值
數(shù)組名稱?:=?[數(shù)組長度]數(shù)組類型?{初始值1,初始值2,......,初始值n}
//?初始化一個數(shù)組
var?數(shù)組名?[數(shù)組長度]數(shù)組類型

情況分析

1. 數(shù)組定義時長度和類型不能省略。如果長度是"..."，此時數(shù)組的長度會根據(jù)初始值的元素個數(shù)而定。

2. 數(shù)組的長度可以是一個「常量表達式」，但是編譯階段的數(shù)組長度值必須是一個整數(shù)類型的值，不能是其他的類型。比如編譯后的值是一個字符串的0("0"),這種是錯誤的。

3. 數(shù)組的小標是從0開始的。數(shù)組可以創(chuàng)建一個空數(shù)組，也可以創(chuàng)建一個分配好的值的數(shù)據(jù)。

4. 數(shù)組的類型和數(shù)組的長度是數(shù)組中的一部分，因此如果類型相同并且數(shù)組元素也相同的數(shù)組，但是長度不一樣，是不同的數(shù)組類型。

//?這兩個數(shù)組不是不是同一類型的數(shù)組
var?arrray1?=?[10]int?{1,?2}
var?arrray2?=?[11]int?{1,?2}
//?這兩組數(shù)組是同一類型的數(shù)組
var?arrray1?=?[10]int?{1,?2}
var?arrray2?=?[...]int?{1,?2}

5. 當未設置初始值時，根據(jù)數(shù)組的長度和數(shù)組的類型，編譯時自動設置默認值。如果設置的是"..."，編譯時則默認根據(jù)類型自動設置一個初始值。

默認值

1. 當數(shù)組類型是數(shù)字類型時，初始值是0，

2. 當數(shù)組類型是string，初始值為空，

3. 當數(shù)組的類型是bool類型時，初始值為false

代碼演示

func?IndexArray()?{
?//?長度和初始值都不設置，打印一個空數(shù)組,[]
?array1?:=?[...]int{}
?fmt.Println(array1)
?//?長度設置，初始值不設置，打印一個長度為1，初始值為0的數(shù)組,[0]
?array2?:=?[1]int{}
?fmt.Println(array2)
?//?長度不設置，設置初始值，打印出初始值[1?2]
?array3?:=?[...]int{1,2}
?fmt.Println(array3)
?//?長度和初始值都設置，打印出初始值[1?2?3?4]
?array4?:=?[4]int{1,2,3,4}
?fmt.Println(array4)
?//?長度設置，初始值設置的個數(shù)小于長度,未設置的初始值根據(jù)數(shù)組類型編譯時自動設置默認值，打印出[1?2?0?0]
?array5?:=?[4]int{1,2}
?fmt.Println(array5)
?//?長度設置，指定索引設置初始值，其他未設置初始值的編譯時自動設置默認值，打印出[0?0?0?0?0?1]
?array6?:=?[6]int{5:?1}
?fmt.Println(array6)
?//?長度和初始值設置，指定索引,打印出[2?2?2]
?array7?:=?[3]int{0:2,1:2,2:2}
?fmt.Println(array7)
}

多維數(shù)組

多維數(shù)組定義

var?數(shù)組名稱?[數(shù)組長度][二維的長度]....[n維的長度]?數(shù)組類型

1. 不管是多少維度的數(shù)組，數(shù)據(jù)類型必須和定義時保持一致。

代碼演示

//?多維數(shù)組的定義
func?MoreArray()?{
?var?array1?[1][2]int
?var?array2?=?[1][2]int{
??{1,?2},
?}
?//?正確定義
?var?array3?=?[3][2][3]int{
??{{1,?2,?3},?{3,?2,?1}},
?}
?//?正確定義
?var?array3?=?[3][2][3]int{
??{
???{1,?2,?3},?
???{3,?2,?1}},
?}
?//?錯誤定義
?var?array3?=?[3][2][3]int{
??{
????{1,?2,?3},?
????{3,?2,?1},
??},
?}
}

//?output
[[[1?2?3]?[3?2?1]]?[[0?0?0]?[0?0?0]]?[[0?0?0]?[0?0?0]]]

?

多維數(shù)組的常見集中情況和上面一維數(shù)組的常見集中情況一樣，但是有如下不同的一個地方。多維數(shù)組的頂層必須設置長度

?

//?多維數(shù)組需要注意的地方
//?錯誤的定義方式
var?array3?=?[...][2][3]int{
????{{1,?2,?3},?{3,?2,?1}},
}
//?正確的定義方式(注意第二行結尾的","不能省略)
var?array3?=?[][2][3]int{
????{{1,?2,?3},?
????{3,?2,?1}},
}

//output
[
???[[1?2?3]?[3?2?1]]
???[[0?0?0]?[0?0?0]]?
???[[0?0?0]?[0?0?0]]
]

數(shù)組的常用操作

循環(huán)

1. for方式

func?LoopArray()?{
?array?:=?[4]int{1,2,3,4}
?len?:=?len(array)
?for?i?:=?0;?i?len;?i++?{
??fmt.Printf("數(shù)組array的索引%d對應的值是%d",?i,?array[i])
??fmt.Println()
?}
}

2. range方式

arr?:=?[...]int{1,?2,?3,?4}
?for?index,?value?:=?range?arr?{
??fmt.Println(index,?value)
?}

計算長度

len?:=?len(數(shù)組名)

?

當數(shù)組是一個多維數(shù)組時，直接使用len(數(shù)組名)，計算的是頂層的長度

?

賦值

數(shù)組名[下標]?=?值
array?:=?[4]int{1,2,3}
array[3]?=?100

比較

如果兩個數(shù)組類型相同（包括數(shù)組的長度，數(shù)組中元素的類型）的情況下，我們可以直接通過較運算符（==和!=）來判斷兩個數(shù)組是否相等，只有當兩個數(shù)組的所有元素都是相等的時候數(shù)組才是相等的，不能比較兩個類型不同的數(shù)組，否則程序將無法完成編譯。

a?:=?[2]int{1,?2}
b?:=?[...]int{1,?2}
c?:=?[2]int{1,?3}
fmt.Println(a?==?b,?a?==?c,?b?==?c)?//?"true?false?false"
d?:=?[3]int{1,?2}
fmt.Println(a?==?d)?//?編譯錯誤：無法比較?[2]int ==?[3]int

數(shù)組與函數(shù)的使用

func?函數(shù)名(形參名稱?[數(shù)組長度]數(shù)組類型)?函數(shù)返回值?{
????//?函數(shù)體
}

?

形參中，函數(shù)的長度為可寫

?

//?數(shù)組與函數(shù)的使用
func?Function(arr?[]?int)?int?{
????return?len(arr)
}

Function([5]int{})

排序

冒泡排序

//?從大到小進行排序
func?BubbleSort()?{

?array?:=?[...]int{2,9,3,5,1,2}
?len?:=?len(array)
?fmt.Println(array)

?for?i?:=?1;?i?len;?i++?{//?控制外層循環(huán)次數(shù)
??for?j?:=?0;?j?len-i;?j++?{?//?控制內部每次循環(huán)個數(shù)
???if?array[j]?1]?{
????tmp?:=?array[j]
????array[j]?=?array[j+1]
????array[j+1]?=?tmp
???}
??}
?}
?fmt.Println(array)
}

插入排序

//?插入排序
func?InsertSort()?{
?array?:=?[...]int{2,9,3,5,1,2}
?len?:=?len(array)
?fmt.Println(array)
?//?var?j?int?=?0
?//?for?i?:=?1;?i?
?//??tmp?:=?array[i]
?//??for?j?=?i;?j?>?0?&&?tmp?
?//???array[j]?=?array[j?-?1]
?//??}
?//??array[j]?=?tmp
?//?}
?for?i?:=?1;?i?len;?i++?{//?控制外層循環(huán)個數(shù)
??tmp?:=?array[i]
??for?j?:=?i-1;?j?>=?0;?j--?{//?針對已經排序好的數(shù)組再次排序
???if?tmp?>?array[j]?{
????array[j+1]?=?array[j]
????array[j]?=?tmp
???}
??}
?}
?fmt.Println(array)
}