c++ map中用char数组_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

_数组_ 是一个固定长度的数列。

// 在 Go 中，_数组_ 是一个固定长度的数列。package mainimport "fmt"func main() {    // 这里我们创建了一个数组 `a` 来存放刚好 5 个 `int`。    // 元素的类型和长度都是数组类型的一部分。数组默认是    // 零值的，对于 `int` 数组来说也就是 `0`。    var a [5]int    fmt.Println("emp:", a)    // 我们可以使用 `array[index] = value` 语法来设置数组    // 指定位置的值，或者用 `array[index]` 得到值。    a[4] = 100    fmt.Println("set:", a)    fmt.Println("get:", a[4])    // 使用内置函数 `len` 返回数组的长度    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)}

输出结果

$ go run arrays.goemp: [0 0 0 0 0]set: [0 0 0 0 100]get: 100len: 5dcl: [1 2 3 4 5]2d:  [[0 1 2] [1 2 3]]

理解

var a [5]int 为数组定义. 大家一定要理解. 所谓数组就是连续的相同数据类型的一组数据. 比如这个是定义了一个连续内容5个int型的数组 默认值是0.

那么连续有什么好处呢? 当然学过c语言的或者java的都知道.连续的顺序查询快啊!

相对与数组 还有一种数据结构是链表. 就是node -> node ->node 类型的结构保存了下一个节点的指针.

数组和链表的区别和特点

数组的优点

• 随机访问性强
• 查找速度快

数组的缺点

• 插入和删除效率低
• 可能浪费内存
• 内存空间要求高，必须有足够的连续内存空间。
• 数组大小固定，不能动态拓展

链表的优点

• 插入删除速度快
• 内存利用率高，不会浪费内存
• 大小没有固定，拓展很灵活。

链表的缺点

• 不能随机查找，必须从第一个开始遍历，查找效率低

切片 Slice

增强版本数组 : slice 的类型仅由它所包含的元素决定(不像数组中还需要元素的个数)。要创建一个长度非零的空slice，需要使用内建的方法 make。这里我们创建了一个长度为3的 string 类型 slice(初始化为零值) 建议大家在go中采用

// _Slice_ 是 Go 中一个关键的数据类型，是一个比数组更// 加强大的序列接口package mainimport "fmt"func main() {    // 不像数组，slice 的类型仅由它所包含的元素决定(不像    // 数组中还需要元素的个数)。要创建一个长度非零的空    // slice，需要使用内建的方法 `make`。这里我们创建了一    // 个长度为3的 `string` 类型 slice(初始化为零值)。    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])    // 如你所料，`len` 返回 slice 的长度    fmt.Println("len:", len(s))    // 作为基本操作的补充，slice 支持比数组更多的操作。    // 其中一个是内建的 `append`，它返回一个包含了一个    // 或者多个新值的 slice。注意我们接受返回由 append    // 返回的新的 slice 值。    s = append(s, "d")    s = append(s, "e", "f")    fmt.Println("apd:", s)    // Slice 也可以被 `copy`。这里我们创建一个空的和 `s` 有    // 相同长度的 slice `c`，并且将 `s` 复制给 `c`。    c := make([]string, len(s))    copy(c, s)    fmt.Println("cpy:", c)    // Slice 支持通过 `slice[low:high]` 语法进行“切片”操    // 作。例如，这里得到一个包含元素 `s[2]`, `s[3]`,    // `s[4]` 的 slice。    l := s[2:5]    fmt.Println("sl1:", l)    // 这个 slice 从 `s[0]` 到(但是包含)`s[5]`。    l = s[:5]    fmt.Println("sl2:", l)    // 这个 slice 从(包含)`s[2]` 到 slice 的后一个值。    l = s[2:]    fmt.Println("sl3:", l)    // 我们可以在一行代码中声明并初始化一个 slice 变量。    t := []string{"g", "h", "i"}    fmt.Println("dcl:", t)    // Slice 可以组成多维数据结构。内部的 slice 长度可以不    // 同，这和多位数组不同。    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)}

$ go run slices.goemp: [  ]set: [a b c]get: clen: 3apd: [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]]

Map

key : val 形式的一组 字典或者哈希. 不好翻译,直接采用map 称呼. 非常强大的

// _map_ 是 Go 内置[关联数据类型](http://zh.wikipedia.org/wiki/关联数组)(// 在一些其他的语言中称为_哈希_ 或者_字典_ )。package mainimport "fmt"func main() {    // 要创建一个空 map，需要使用内建的 `make`:    // `make(map[key-type]val-type)`.    m := make(map[string]int)    // 使用典型的 `make[key] = val` 语法来设置键值对。    m["k1"] = 7    m["k2"] = 13    // 使用例如 `Println` 来打印一个 map 将会输出所有的    // 键值对。    fmt.Println("map:", m)    // 使用 `name[key]` 来获取一个键的值    v1 := m["k1"]    fmt.Println("v1: ", v1)    // 当对一个 map 调用内建的 `len` 时，返回的是键值对    // 数目    fmt.Println("len:", len(m))    // 内建的 `delete` 可以从一个 map 中移除键值对    delete(m, "k2")    fmt.Println("map:", m)    // 当从一个 map 中取值时，可选的第二返回值指示这个键    // 是在这个 map 中。这可以用来消除键不存在和键有零值，    // 像 `0` 或者 `""` 而产生的歧义。    _, prs := m["k2"]    fmt.Println("prs:", prs)    // 你也可以通过这个语法在同一行申明和初始化一个新的    // map。    n := map[string]int{"foo": 1, "bar": 2}    fmt.Println("map:", n)}

$ go run maps.go map: map[k1:7 k2:13]v1:  7len: 2map: map[k1:7]prs: falsemap: map[foo:1 bar:2]

三种结构的对比优缺点

当你需要一组序列的时候大多数采用slice, 当需要快速key 定位的时候采用Map O(1)就能找到. 速度极快, 实际工作中需要都采用. 想数组的化缺点是不能快速查询key.全部循环查询的化很费时间.

什么时候使用哪种结构

一般组合采用 向leetcode里面很多题目,可有将Slice转换成Map这样查找很快通过组合来提高程序运行效率

底层实现及优化

底层也是和C基本一样.建议大家看看slice 和map的源码包.官方源码包是开源的.可有理解的更加深刻.

本教程是对初学者.只要会使用,用熟练就可以了.

思考和拓展

数组和链表的区别.map 有什么好处