14天學會Go語言第四天：Array Map Slice 數組 和切片

經過前兩天我們學會了,Go基礎的變量,常量, if-else, for, switch 控制語法結構. 那麼今天我們將學會

1. 數組 Array
2. 切片 Slice
3. Map 這應該叫 Key-Value 形式的鍵值對 比如 { "key": "val" }
4. 數組和鏈表的區別和特點
5. 三種結構的對比優缺點
6. 什麼時候使用哪種結構
7. 底層實現及優化
8. 思考和拓展

數組 Array

_數組_ 是一個固定長度的數列。

<code> 

package
 main

import
 
"fmt"

func
 
main
()
 {

     
     
     
    
var
 a [
5
]
int
    fmt.Println(
"emp:"
, a)

     
     
    a[
4
] = 
100
    fmt.Println(
"set:"
, a)
    fmt.Println(
"get:"
, a[
4
])

     
    fmt.Println(
"len:"
, 
len
(a))

     
    b := [
5
]
int
{
1
, 
2
,  
3
, 
4
, 
5
}
    fmt.Println(
"dcl:"
, b)

     
     
    
var
 twoD [
2
][
3
]
int
    
for
 i := 
0
; i 
2
; i++ {
        
for
 j := 
0
; j 
3
; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println(
"2d: "
, twoD)
}
/<code>

輸出結果

<code>
$
 
go
 
run
 
arrays.go
emp:
 
[0
 
0
 
0
  
0
 
0
]
set:
 
[0
 
0
 
0
 
0
 
100
]
get:
 
100
len:
 
5
dcl:
 
[1
 
2
 
3
 
4
 
5
]
2d:
  
[[0
 
1
 
2
 
]
 
[1
 
2
 
3
]]
/<code>

理解

var a [5]int 為數組定義. 大家一定要理解. 所謂數組就是連續的相同數據類型的一組數據. 比如這個是定義了一個連續內容5個int型的數組 默認值是0.

那麼連續有什麼好處呢? 當然學過c語言的或者java的都知道.連續的順序查詢快啊!

相對與數組 還有一種數據結構是鏈表. 就是node -> node ->node 類型的結構保存了下一個節點的指針.

數組和鏈表的區別和特點

數組的優點

• 隨機訪問性強
• 查找速度快

數組的缺點

• 插入和刪除效率低
• 可能浪費內存
• 內存空間要求高，必須有足夠的連續內存空間。
• 數組大小固定，不能動態拓展

鏈表的優點

• 插入刪除速度快
• 內存利用率高，不會浪費內存
• 大小沒有固定，拓展很靈活。

鏈表的缺點

• 不能隨機查找，必須從第一個開始遍歷，查找效率低

切片 Slice

增強版本數組 : slice 的類型僅由它所包含的元素決定（不像數組中還需要元素的個數）。要創建一個長度非零的空slice，需要使用內建的方法 make。這裡我們創建了一個長度為3的 string 類型 slice（初始化為零值） 建議大家在go中採用

<code> 
 

package
 main

import
 
"fmt"

func
 
main
()
 {

     
     
     
     
    s := 
make
([]
string
, 
3
)
    fmt.Println(
"emp:"
, s)

     
    s[
0
] = 
"a"
    s[
1
] = 
"b"
    s[
2
] = 
"c"
    fmt.Println(
"set:"
, s)
    fmt.Println(
"get:"
, s[
2
])

     
    fmt.Println(
"len:"
, 
len
(s))

     
     
     
     
    s =  
append
(s, 
"d"
)
    s = 
append
(s, 
"e"
, 
"f"
)
    fmt.Println(
"apd:"
, s)

     
     
    c := 
make
([]
string
, 
len
(s))
    
copy
(c, s)
    fmt.Println(
"cpy:"
, c)

     
     
     
    l := s[
2
:
5
]
    fmt.Println(
"sl1:"
, l)

     
    l = s[:
5
]
    fmt.Println(
"sl2:"
, l)

     
    l = s[
2
:]
    fmt.Println(
"sl3:"
, l)

     
    t := []
string
{
"g"
, 
"h"
, 
"i"
}
    fmt.Println(
"dcl:"
, t)

     
     
    twoD := 
make
([][]
int
,  
3
)
    
for
 i := 
0
; i 
3
; i++ {
        innerLen := i + 
1
        twoD[i] = 
make
([]
int
, innerLen)
        
for
 j := 
0
; j < innerLen; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println(
"2d: "
, twoD)
}/<code>

<code>
$
 
go
 
run
 
slices.go
emp:
 
[
  
]
set:
 
[a
 
b
 
c]
get:
 
c
len: 
 
3
apd:
 
[a
 
b
 
c
 
d
 
e
 
f]
cpy:
 
[a
 
b
 
c
 
d
 
e
 
f]
sl1:
 
[c
 
d
 
e]
sl2:
 
[a
 
b
 
c
 
d
 
e] 

sl3:
 
[c
 
d
 
e
 
f]
dcl:
 
[g
 
h
 
i]
2d:
  
[[0]
 
[1
 
2
]
 
[2
 
3
 
4
]]
/<code>

Map

key : val 形式的一組 字典或者哈希. 不好翻譯,直接採用map 稱呼. 非常強大的

<code> 
 

package
 main

 
import
 
"fmt"

func
 
main
()
 {

     
     
    m := 
make
(
map
[
string
]
int
)

     
    m[
"k1"
] = 
7
    m[
"k2"
] = 
13

     
     
    fmt.Println(
"map:"
, m)

     
    v1 := m[
"k1"
]
    fmt.Println(
"v1: "
, v1)

     
     
    fmt.Println(
"len:"
, 
len
(m))

     
    
delete
(m, 
"k2"
)
    fmt.Println(
"map:"
, m)

     
     
     
    _, prs := m[
"k2"
]
    fmt.Println(
"prs:"
, prs)

     
     
    n := 
map
[ 
string
]
int
{
"foo"
: 
1
, 
"bar"
: 
2
}
    fmt.Println(
"map:"
, n)
}/<code>

<code>$ 
go
 run maps.
go
 
map
: 
map
[k1:
7
 k2:
13
]
v1:  
7
len
: 
2
map
: 
map
[k1:
7
]
prs: 
false
map
: 
map
[foo:
1 
 bar:
2
]/<code>

三種結構的對比優缺點

當你需要一組序列的時候大多數採用slice, 當需要快速key 定位的時候採用Map O(1)就能找到. 速度極快, 實際工作中需要都採用. 想數組的化缺點是不能快速查詢key.全部循環查詢的化很費時間.

什麼時候使用哪種結構

一般組合採用 向leetcode裡面很多題目,可有將Slice轉換成Map這樣查找很快通過組合來提高程序運行效率

底層實現及優化

底層也是和C基本一樣.建議大家看看slice 和map的源碼包.官方源碼包是開源的.可有理解的更加深刻.

本教程是對初學者.只要會使用,用熟練就可以了.

思考和拓展

數組和鏈表的區別.map 有什麼好處