GO 常用数据结构#

一、数组与切片#

1. 数组 Array#

特点：长度固定、声明时必须指定大小，属于值类型，不能动态扩容

1
package main
2
import "fmt"
3

4
func main() {
5
    // 声明长度为5的int数组，默认零值全为0
6
    var arr [5]int
7
    fmt.Println(arr) // [0 0 0 0 0]
8

9
    // 下标赋值
10
    arr[0] = 10
11
    arr[1] = 20
12
    fmt.Println(arr) // [10 20 0 0 0]
13

14
    // 初始化数组
15
    nums := [5]int{1, 2, 3, 4, 5}
16
    fmt.Println(nums) // [1 2 3 4 5]
17

18
    // 获取数组长度
19
    fmt.Println(len(nums)) // 5
20
}

缺点：长度固定，灵活性差，实际开发很少直接使用，优先用切片 slice

2. 切片 Slice#

特点：动态可变数组，类型写法 []int（无固定长度数字），引用类型，底层依托数组

创建方式#

1
func main() {
2
    // 方式1：字面量创建
3
    nums := []int{1, 2, 3, 4, 5}
4
    fmt.Println(nums) // [1 2 3 4 5]
5

6
    // 方式2：make 指定长度
7
    a := make([]int, 5)
8
    fmt.Println(a) // [0 0 0 0 0]
9

10
    // 方式3：make 指定长度 + 容量
11
    b := make([]int, 3, 10)
12
    fmt.Println(b) // [0 0 0]
13
    fmt.Printf("长度=%d, 容量=%d\n", len(b), cap(b)) // len=3, cap=10
14

15
    // 下标访问修改
16
    nums[0] = 100
17
    fmt.Println(nums[0]) // 100
18

19
    // range遍历
20
    for _, v := range nums {
21
        fmt.Print(v, " ")
22
    }
23
    fmt.Println()
24
}

len()：当前实际元素数量
cap()：底层数组总容量；超出容量时 Go 自动扩容，重新分配底层数组
...：切片展开语法，把切片拆成独立参数传给 append

切片增删 & 截取#

1
func main() {
2
    nums := []int{1, 2, 3}
3

4
    // 末尾追加元素
5
    nums = append(nums, 4)
6
    nums = append(nums, 5, 6)
7
    fmt.Println(nums) // [1 2 3 4 5 6]
8

9
    // 切片截取 nums[start:end]：含start，不含end
10
    fmt.Println(nums[1:4]) // [2 3 4]
11
    fmt.Println(nums[:3])  // [1 2 3] 省略start：从头开始
12
    fmt.Println(nums[3:])  // [4 5 6] 省略end：到末尾
13

14
    // 删除索引 i 的元素
15
    i := 2
16
    nums = append(nums[:i], nums[i+1:]...)
17
    fmt.Println(nums) // [1 2 4 5 6]
18

19
    // 在索引 i 插入元素
20
    i = 1
21
    nums = append(nums[:i], append([]int{99}, nums[i:]...)...)
22
    fmt.Println(nums) // [1 99 2 4 5 6]
23
}

二维切片#

1
func main() {
2
    rows, cols := 3, 4
3
    // 创建外层切片
4
    grid := make([][]int, rows)
5
    // 逐行创建内层一维切片
6
    for i := 0; i < rows; i++ {
7
        grid[i] = make([]int, cols)
8
    }
9

10
    // 赋值
11
    grid[0][0] = 1
12
    grid[1][2] = 5
13
    grid[2][3] = 9
14

15
    fmt.Printf("%d 行 %d 列\n", len(grid), len(grid[0]))
16
}

内存结构

1
grid (外层切片)
2
 ├─ grid[0] → [0, 0, 0, 0]
3
 ├─ grid[1] → [0, 0, 0, 0]
4
 └─ grid[2] → [0, 0, 0, 0]

二、字符串 string#

基础特性#

字符串不可直接修改单个字符（底层是只读字节数组）
len(s)：获取字节长度；下标访问得到 byte 字节
range 遍历可正确读取 Unicode 字符（rune）

1
func main() {
2
    s := "Hello, Go!"
3
    fmt.Println(len(s))         // 10 字节
4
    fmt.Println(s[0])           // 72 (H的ASCII码)
5
    fmt.Printf("%c\n", s[0])    // H
6
    fmt.Println(s[0:5])         // Hello 截取
7

8
    // 字符串拼接
9
    greeting := "你好" + "，世界"
10
    fmt.Println(greeting)
11

12
    // 字符串比较
13
    fmt.Println("hello" == "hello") // true
14

15
    // range遍历 Unicode
16
    for _, ch := range "Hello" {
17
        fmt.Printf("%c ", ch)
18
    }
19
    fmt.Println()
20

21
    // s[0] = 'h' // ❌ 编译报错：字符串不可变
22
}

[]byte 与 []rune 转换#

[]byte：按字节处理，适合纯 ASCII 英文/数字
[]rune：按 Unicode 字符处理，适合中文、emoji 等多字节字符

1
s := "abc中文"
2
b := []byte(s)    // 转为字节数组
3
r := []rune(s)    // 转为 Unicode 字符数组
4
newS := string(b) // 转回字符串

strings 包常用函数#

1
package main
2
import (
3
    "fmt"
4
    "strings"
5
)
6
func main() {
7
    s := "Hello, World!"
8
    fmt.Println(strings.Contains(s, "World"))    // 是否包含子串 true
9
    fmt.Println(strings.Index(s, "World"))       // 子串起始索引 7
10
    fmt.Println(strings.HasPrefix(s, "Hello"))   // 是否前缀 true
11
    fmt.Println(strings.HasSuffix(s, "World!"))  // 是否后缀 true
12

13
    csv := "apple,banana,cherry"
14
    parts := strings.Split(csv, ",")             // 分割字符串
15
    fmt.Println(strings.Join(parts, " - "))      // 拼接切片
16
    fmt.Println(strings.Replace("aabbaabb", "aa", "cc", -1)) // 全部替换
17
    fmt.Println(strings.Repeat("Go", 3))         // 重复字符串 GoGoGo
18
    fmt.Println(strings.ToUpper("hello"))         // 转大写
19
    fmt.Println(strings.ToLower("HELLO"))         // 转小写
20
}

strconv 包：字符串和数字互转#

1
package main
2
import (
3
    "fmt"
4
    "strconv"
5
)
6
func main() {
7
    // Atoi：字符串转int
8
    n, err := strconv.Atoi("123")
9
    if err == nil {
10
        fmt.Println(n) // 123
11
    }
12

13
    // Itoa：int转字符串
14
    s := strconv.Itoa(42)
15
    fmt.Println(s) // 42
16

17
    // ParseInt：指定进制转整数
18
    num, _ := strconv.ParseInt("ff", 16, 64)
19
    fmt.Println(num) // 255
20

21
    // FormatInt：整数转指定进制字符串
22
    binStr := strconv.FormatInt(255, 2)
23
    fmt.Println(binStr) // 11111111
24
}

刷题高频：strconv.Atoi / strconv.Itoa

三、结构体 struct#

定义和初始化#

Go 没有 class，用 struct 聚合多个字段，可用于节点、实体建模

1
type Student struct {
2
    Name  string
3
    Age   int
4
    Score float64
5
}
6

7
func main() {
8
    // 按字段名初始化（推荐）
9
    s1 := Student{Name: "Alice", Age: 20, Score: 95.5}
10
    fmt.Println(s1)
11

12
    // 按顺序初始化（不推荐）
13
    s2 := Student{"Bob", 21, 88.0}
14
    fmt.Println(s2)
15

16
    // 访问&修改字段
17
    fmt.Println(s1.Name)
18
    s1.Age = 21
19
    fmt.Println(s1.Age)
20

21
    // 零值结构体
22
    var s3 Student
23
    fmt.Println(s3)
24
}

结构体指针#

Go 自动解引用指针字段，无需手动写 (*p).X

1
type Point struct {
2
    X int
3
    Y int
4
}
5

6
func moveRight(p *Point, distance int) {
7
    p.X += distance // 直接使用 p.X
8
}
9

10
func main() {
11
    p := &Point{X: 3, Y: 4}
12
    fmt.Println(p.X) // 3
13
    moveRight(p, 10)
14
    fmt.Println(*p) // {13 4}
15
}

四、哈希表 map#

基础用法#

键值对存储，查找/增删效率高；必须用 make/字面量初始化，nil map 不能直接赋值

1
func main() {
2
    // make 创建空 map
3
    m := make(map[string]int)
4
    m["apple"] = 3
5
    m["banana"] = 5
6
    m["cherry"] = 2
7
    fmt.Println(m["apple"]) // 3
8

9
    m["apple"] = 10       // 修改值
10
    delete(m, "cherry")   // 删除键
11
    fmt.Println(len(m))   // 长度 2
12

13
    // 字面量初始化
14
    scores := map[string]int{
15
        "Alice": 90,
16
        "Bob":   85,
17
        "Carol": 92,
18
    }
19

20
    // 遍历map（无序）
21
    for k, v := range scores {
22
        fmt.Printf("%s: %d\n", k, v)
23
    }
24
}

判断 key 是否存在#

1
func main() {
2
    m := map[string]int{"apple": 3, "banana": 5}
3
    val, ok := m["apple"]
4
    fmt.Println(val, ok) // 3 true
5

6
    val, ok = m["grape"]
7
    fmt.Println(val, ok) // 0 false
8

9
    if val, ok := m["banana"]; ok {
10
        fmt.Printf("banana 存在，值为 %d\n", val)
11
    }
12
}

哈希集合（用 map[T]struct{} 模拟）#

struct{} 空结构体不占用内存，适合实现集合去重

1
func main() {
2
    set := make(map[int]struct{})
3
    set[1] = struct{}{}
4
    set[2] = struct{}{}
5
    set[3] = struct{}{}
6
    set[2] = struct{}{} // 重复添加无效
7

8
    fmt.Println(len(set)) // 3
9

10
    // 判断存在
11
    if _, ok := set[2]; ok {
12
        fmt.Println("2 存在")
13
    }
14

15
    delete(set, 2) // 删除元素
16
    for k := range set {
17
        fmt.Print(k, " ")
18
    }
19
    fmt.Println()
20
}

五、栈（用切片模拟）#

后进先出（LIFO）

1
func main() {
2
    stack := []int{}
3
    // 入栈
4
    stack = append(stack, 1)
5
    stack = append(stack, 2)
6
    stack = append(stack, 3)
7
    fmt.Println(stack) // [1 2 3]
8

9
    // 栈顶元素
10
    top := stack[len(stack)-1]
11
    fmt.Println("栈顶:", top) // 3
12

13
    // 出栈
14
    stack = stack[:len(stack)-1]
15
    fmt.Println(stack) // [1 2]
16

17
    // 判空
18
    fmt.Println(len(stack) == 0)
19
}

入栈：stack = append(stack, x)
栈顶：stack[len(stack)-1]
出栈：stack = stack[:len(stack)-1]
判空：len(stack) == 0

六、队列（FIFO 先进先出）#

container/list 双向链表实现#

1
package main
2
import (
3
    "container/list"
4
    "fmt"
5
)
6
func main() {
7
    queue := list.New()
8
    // 入队
9
    queue.PushBack(10)
10
    queue.PushBack(20)
11
    queue.PushBack(30)
12
    fmt.Println("大小:", queue.Len()) // 3
13

14
    // 队头元素（类型断言）
15
    front := queue.Front().Value.(int)
16
    fmt.Println("队头:", front) // 10
17

18
    // 出队
19
    queue.Remove(queue.Front())
20
    fmt.Println("新队头:", queue.Front().Value.(int)) // 20
21

22
    // 遍历
23
    for e := queue.Front(); e != nil; e = e.Next() {
24
        fmt.Print(e.Value.(int), " ")
25
    }
26
    fmt.Println()
27
}

入队：queue.PushBack(x)
队头：queue.Front().Value.(类型断言)
出队：queue.Remove(queue.Front())
判空：queue.Len() == 0

七、make 初始化规则#

✅ make 仅用于 3 种引用类型#

slice 切片
```
1
s := make([]int, 3, 10) // 长度3，容量10
```
- 分配底层数组内存，减少反复扩容开销
- var s []int → nil 切片，无底层数组
map 字典
```
1
m := make(map[string]int, 10)
```
- 初始化哈希表，避免 nil map 直接赋值 panic
chan 通道
```
1
ch := make(chan int, 5)
```
- 初始化缓冲区，用于 goroutine 通信

❌ 不能用 make 的类型#

普通变量、定长数组 [N]int、string、bool、int、struct 等，直接声明即可

❗ new 和 make 的区别#

new(T)：返回 *T 指针，只分配基础结构内存，不初始化底层数据结构
```
1
s := new([]int) // 仅切片结构体，无底层数组，不能直接索引赋值
```
make(T, ...)：返回原始引用类型，初始化底层数组/哈希表/缓冲区