Go（Golang） 是一個開源的編程語言，它能讓構造簡單、可靠且高效的軟件變得容易。

Go是從2007年末由Robert Griesemer, Rob Pike, Ken Thompson主持開發，後來還加入了Ian Lance Taylor, Russ Cox等人，並最終於2009年11月開源，在2012年早些時候發佈了Go 1穩定版本。

現在Go的開發已經是完全開放的，並且擁有一個活躍的社區。

在國內外，已經有很多大廠開始大規模使用Golang開發其雲計算相關產品，比如Google、AWS、Cloudflare、阿里巴巴等。

而Go開發人員的全球平均薪資也是相當高。在美國，使用Go語言的開發者平均年薪為$ 136K。

在2019年Stack Overflow開發者調查中，Go是全球收入第三的語言。

因此，還沒有開始學習Go的朋友，不妨來看看我今天推薦的教程《Go 語言實現常見數據結構》。

通過使用 Golang 實現常見的數據結構，加深大家對 Golang 的理解，並且可以強化大家的數據結構基本功。

先讓我們一起來看看《Go 語言實現常見數據結構》節選吧，本節教程主要教大家學習Golang的數組與切片。

教程節選：

實驗1 數組與切片

實驗介紹

從本實現開始我們將進入到 Golang 的學習之旅，Golang 的許多初學者都會對數組 (Array) 與切片 (Slice) 感到困惑。

他們雖然同屬於集合類的類型，但是用起來卻十分不同。在本節實驗中，你將學習到數組與切片到底是哪裡不同，這裡也是 Golang 面試中的一個常考知識點。

知識點

• 數組的數據類型
• 數組的創建
• 數組的遍歷
• Golang 數組與切片的區別
• 切片的擴容規律

Golang 數組基本操作

這一節開始，我們將學習 Golang 數組與切片的常用方法以及他們在具體面試中的常考知識點。

Golang 中一個數組的聲明方式主要有以下幾種。

<code>package main

func main() {
    // 第一種，在初始化時只聲明數組長度，不聲明數組內容
    var arr1 [5]int
    // 第二種，知道數據很多，不想自己寫長度的時候可以用這種方式
    // 聲明之後由編譯器自己推算數組長度
    arr2 :=  [...]int{1,3,5,7,9}
    // 第三種，聲明的時候長度和初值一起聲明
    arr3 := [3]int{2,4,6}
    // 二維數組的聲明，其意義是三行五列 

    var Block [3][5]int
}/<code>

這裡值得一提的是 Golang 中的數組的初始值如果你不做聲明的話默認是全部有初值的。 比如 arr1 這個數組雖然只聲明瞭長度為 5，但是 Go 的編譯器也會把這 5 個元素全都初始化為 0。而對於 bool 值類型的數組，如果不做賦值操作，則初始值全為 false。在接下來的數組遍歷中我們會實際的驗證它。

數組的遍歷

我們先在實驗樓在線實驗環境中新建新建一個名叫 array 的文件夾。如下圖所示，先點擊 File，然後點擊 New Folder 創建名為 array 的文件夾。

然後我們右鍵點擊 array 文件夾，選擇 New File，創建一個叫 main.go 的文件，如下圖所示。

Go 的數組遍歷主要有以下兩種方式。首先鍵入以下代碼：

<code>package main

import "fmt"

func main() {
    // 第一種，在初始化時只聲明數組長度，不聲明數組內容 

    var arr1 [5]int
    // 第二種，知道數據很多，不想自己寫長度的時候可以用這種方式
    // 聲明之後由編譯器自己推算數組長度
    //arr2 :=  [...]int{1,3,5,7,9}
    //// 第三種，聲明的時候長度和初值一起聲明
    //arr3 := [3]int{2,4,6}
    //// 二維數組的聲明，其意義是三行五列
    var Block [3][5]bool
    // 第一種
    for i := 0 ; i        fmt.Printf("%d\\n",arr1[i])
    }
    // 第二種
    for index, value := range arr1 {
        fmt.Printf("索引：%d, 值： %d\\n",index,value)
    }
    // 以第二種方式遍歷二維數組,只取值，也就是取出一個數組
    for _,v := range Block {
        // 再對這個數組取值
        for _,value := range v {
            fmt.Printf("%v ",value)
        }
        fmt.Printf("\\n")
    }

}/<code>

接下來，在終端執行：

<code>cd array
go run main.go/<code>

結果如下：

其中 Go 語言官方更加提倡的是第二種以 range 的方式進行遍歷，這樣寫會讓代碼更加優雅，而且絕對不會越界。

那麼，如果我只想要數組裡的 index 不想要 value 時怎麼 range 呢？

答案其實很簡單，i := range arr 就可以了。如果你只想要 value 不想要索引的時候就可以這樣寫 _, value := range arr, 注意這裡的下劃線不能省略。

封裝一個數組打印函數

現在咱們封裝一個用來打印數組的函數並對其進行測試，代碼如下:

<code>func PrintArr(arr [5]int) {
    // 第二種
    for index, value := range arr {
        fmt.Printf("索引：%d, 值： %d\\n",index,value)
    }
}/<code>

我們分別將 arr1,2,3 傳入打印，先猜測一下會發生什麼結果呢？

<code>package main

import "fmt"

func main() {
    // 第一種，在初始化時只聲明數組長度，不聲明數組內容
    var arr1 [5]int 

    // 第二種，知道數據很多，不想自己寫長度的時候可以用這種方式
    // 聲明之後由編譯器自己推算數組長度
    arr2 :=  [...]int{1,3,5,7,9}
    //// 第三種，聲明的時候長度和初值一起聲明
    arr3 := [3]int{2,4,6}
    PrintArr(arr1)
    PrintArr(arr2)
    PrintArr(arr3)
}

func PrintArr(arr [5]int) {
    // 第二種
    for index, value := range arr {
        fmt.Printf("索引：%d, 值： %d\\n",index,value)
    }
}/<code>

結果是程序在打印 arr3 時拋出瞭如下異常。

這個就要牽扯出一個概念了，Go 語言中數組是值類型。也就是說[3]int，和[5]int 在 go 中會認為是兩個不同的數據類型。

同樣地，你在 PrintArr 中改變數組中的值也不會改變原數組的值。

到了這裡你肯定覺得 go 的數組太難用了，又要數據類型統一又要長度統一才能傳遞。確實是這樣的，在 go 中我們一般不直接使用數組。而是使用我們今天的主角，切片。

Golang 切片的基本操作

一般而言，Go 語言的切片比數組更加靈活，強大而且方便。數組是按值傳遞的（即是傳遞的副本），而切片是引用類型，傳遞切片的成本非常小，而且是不定長的。

而且數組是定長的，而切片可以調整長度。創建切片的語法如下：

• make([ ]Type, length, capacity)
• make([ ]Type, length)
• [ ]Type{}
• [ ]Type{value1, value2, ..., valueN}

內置函數 make() 用於創建切片、映射和通道。當用於創建一個切片時，它會創建一個隱藏的初始化為零值的數組，然後返回一個引用該隱藏數組的切片。

該隱藏的數組與 Go 語言中的所有數組一樣，都是固定長度，如果使用第一種語法創建，那麼其長度為切片的容量 capacity ；如果是第二種語法，那麼其長度記為切片的長度 length 。一個切片的容量即為隱藏數組的長度，而其長度則為不超過該容量的任意值。另外可以通過內置的函數 append() 來增加切片的容量。

我們來執行一下下面的程序：

<code>package main

import "fmt"

func main() {
    slice := make([]int,0)
    for i := 0 ;i < 10; i++ {
        // 動態的對切片進行擴容
        slice = append(slice, i)
    }
    fmt.Println(slice)

    // 調用PrintArr
    PrintArr(slice)
    // 看看是否切片的第一個元素改變了?
    fmt.Println(slice)
}

func PrintArr(arr []int) {
    arr[0] = 100
    for index, value := range arr {
        fmt.Printf("索引：%d, 值： %d\\n",index,value)
    }
}/<code>

執行結果:

執行之後我們會發現 slice[0] 的值確實被改變了。因為切片是引用傳遞，也就是直接把切片在內存中的地址傳遞過去。

這樣我們在其他函數中對其進行修改也會影響原來的切片的數據。這樣做的好處是傳引用因為不用把原數據拷貝一份，所以對系統的開銷比較小。

切片的切割

切片最大的特色就是可以靈活的進行切分，比如下面的例子。

<code>package main

import "fmt"

func main() {
    slice := make([]int,0)
    for i := 0 ;i < 10; i++ {
        slice = append(slice, i)
    }
    fmt.Println(slice)
    s2 := slice[2:4]
    fmt.Println(s2)
}/<code>

執行結果:

這裡的 2 可被稱為起始索引，4 可被稱為結束索引。那麼 s2 的長度就是 4 減去 2，即 2。因此可以說，s2 中的索引從 0 到 1 指向的元素對應的是 slice 及其底層數組中索引從 2 到 3 的那 2 個元素。

到這裡我們就可以推出 [n:m] 的意思是取區間 [n,m) 的數據賦值給新的切片。

關於數組與切片兩道常見面試題

• Golang 切片的擴容規則。

一旦一個切片無法容納更多的元素，Go 語言就會想辦法擴容。但它並不會改變原來的切片，而是會生成一個容量更大的切片，然後將把原有的元素和新元素一併拷貝到新切片中。在一般的情況下，你可以簡單地認為新切片的容量將會是原切片容量的 2 倍。 但是，當原切片的長度大於或等於 1024 時，Go 語言將會以原容量的 1.25 倍作為新容量的基準。因為繼續再乘以 2 的話切片容量增加的太快，很容易產生大量的浪費無意義的空間。 不過，如果我們一次追加的元素過多，以至於使新長度比原容量的 2 倍還要大，那麼新容量就會以新長度為基準。比如你現在的切片長度為 10，現在一下往裡面添加了 30 個元素，那麼 Golang 會直接創建一個新的長度為 40 的底層數組，然後把所有的數據拷貝進去。

• Golang 切片的底層數組在什麼情況下會改變？

其實這裡的典型回答應該是永遠不會改變。因為當切片需要擴容時，新的切片誕生的同時也會創建出新的底層數組，它只是把原數組的數據拷貝了進來，並未對其做任何的修改。

一道思考題

現在我們已經學習瞭如何對數組進行“擴容”，那麼你能否使用“擴容”的方式，把原切片進行縮容呢？請嘗試寫出代碼，或查閱相關資料。

......

篇幅有限，暫時發佈以上內容。

之後還有“棧與棧的應用”“隊列與循環隊列”等內容可以學習，感興趣的朋友可以訪問“實驗樓”官網，搜索“Go 語言實現常見數據結構”，即可學習之後的內容。

閱讀更多 實驗樓 的文章

關鍵字: 數據結構 Overflow 交個朋友吧