經過前兩天我們學會了,Go基礎的變量,常量, if-else, for, switch 控制語法結構. 那麼今天我們將學會
- 數組 Array
- 切片 Slice
- Map 這應該叫 Key-Value 形式的鍵值對 比如 { "key": "val" }
- 數組和鏈表的區別和特點
- 三種結構的對比優缺點
- 什麼時候使用哪種結構
- 底層實現及優化
- 思考和拓展
數組 Array
_數組_ 是一個固定長度的數列。
<code>package
mainimport
"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
; i2
; i++ {for
j :=0
; j3
; 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
mainimport
"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
; i3
; 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
mainimport
"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 有什麼好處