anh's blog

260715GO数组

Wed, 15 Jul 2026 00:00:00 GMT

数组（顺序存储）基本原理

一、数组两大分类

静态数组：原始形态，是一块固定长度、连续的内存空间，依靠索引直接访问内存。长度初始化后不可改变。
动态数组：基于静态数组封装而来，内置 push、insert、remove 等常用 API，可自动完成扩容/缩容，简化增删操作。
- 后续栈、队列、哈希表等很多数据结构底层都依赖动态数组实现
- 算法刷题和开发日常一般直接使用动态数组（Go 的 slice），静态数组多用于理解底层原理

Go 静态数组定义

// 定义长度固定为 10 的 int 静态数组
var arr [10]int
// 索引赋值
arr[0] = 1
arr[1] = 2
// 索引取值
a := arr[0]

核心特性：随机访问 — 通过索引可 O(1) 时间直接读取/修改对应元素

二、静态数组：增删原理 & 时间复杂度

1. 新增元素

情况1：末尾追加（有空闲空间）

直接对末尾空位索引赋值，无需移动元素

var arr [10]int
// 前4个位置存入元素
for i := 0; i < 4; i++ {
    arr[i] = i
}
// 末尾追加元素
arr[4] = 4
arr[5] = 5

时间复杂度：O(1)

情况2：中间插入（有空闲空间）

需要把插入位置及之后的原有元素向后整体搬移一位（倒序遍历防止数据覆盖），腾出空位后插入新元素

package main
import "fmt"

func main() {
    var arr [10]int
    for i := 0; i < 4; i++ {
        arr[i] = i
    }
    // 在索引 2 插入元素 666，后移后续元素
    for i := 4; i > 2; i-- {
        arr[i] = arr[i-1]
    }
    arr[2] = 666
    fmt.Println(arr)
}

时间复杂度：O(N)

情况3：数组空间已满

需要手动扩容：新建一块更大的静态数组，复制原有全部数据，再进行新增操作

// 原数组已满
arr := make([]int, 10)
for i := 0; i < 10; i++ {
    arr[i] = i
}
// 创建更大数组并复制原数据
newArr := make([]int, 20)
for i := 0; i < 10; i++ {
    newArr[i] = arr[i]
}
// 在新数组末尾追加元素
newArr[10] = 10

扩容涉及全量拷贝，单次扩容操作复杂度：O(N)

2. 删除元素

情况1：删除末尾元素

直接标记/截断末尾元素，无需搬移数据

var arr [10]int
for i := 0; i < 5; i++ {
    arr[i] = i
}
// 删除末尾元素（示例标记为-1）
arr[4] = -1

时间复杂度：O(1)

情况2：删除中间元素

把被删元素后面的元素整体向前搬移一位（正序遍历），保持数组连续性

var arr [10]int
for i := 0; i < 5; i++ {
    arr[i] = i
}
// 删除索引1的元素，后续元素前移
for i := 1; i < 4; i++ {
    arr[i] = arr[i + 1]
}
arr[4] = -1

时间复杂度：O(N)

3. 查 & 改

按索引查询元素：O(1)
按索引修改元素：O(1)
按元素值遍历查找（非索引查找）：O(N)

4. 静态数组复杂度总览

增
- 末尾追加（有空位）：O(1)
- 中间插入：O(N)
- 满数组扩容新增：O(N)
删
- 删除末尾元素：O(1)
- 删除中间元素：O(N)
查（索引访问）：O(1)
改（索引修改）：O(1)

三、动态数组（Go Slice）用法

底层依旧依托静态数组，自动处理扩容、缩容和数据搬移，对外提供简洁 API

package main
import "fmt"

func main() {
    // 创建初始长度为0的动态数组
    arr := make([]int, 0)

    // 末尾追加元素
    for i := 0; i < 10; i++ {
        arr = append(arr, i)
    }

    // 在索引 2 插入元素 666
    arr = append(arr[:2], append([]int{666}, arr[2:]...)...)

    // 在头部插入元素 -1
    arr = append([]int{-1}, arr...)

    // 删除末尾元素
    arr = arr[:len(arr)-1]

    // 删除索引 2 的元素
    arr = append(arr[:2], arr[3:]...)

    // 索引查询
    a := arr[0]
    fmt.Println(a)

    // 索引修改
    arr[0] = 100

    // 根据值查找索引（遍历查找，复杂度 O(N)）
    index := -1
    for i, v := range arr {
        if v == 666 {
            index = i
            break
        }
    }
    fmt.Println("666的索引：", index)
}

四、核心特点总结

✅ 优点：支持索引随机访问，末尾增删效率极高（O(1)），结构简单
❌ 缺点：中间位置增删效率差（O(N)），会产生大量数据搬移；静态数组长度固定不够灵活
底层本质：连续内存存储，动态数组 = 静态数组 + 自动扩容/缩容 + 封装增删API
适用场景：读多写少、主要在尾部增删、频繁按索引随机访问的场景；不适合频繁在数组中间插入删除的场景

260715GO算法题常用技巧

Wed, 15 Jul 2026 00:00:00 GMT

GO 算法题常用技巧 & ACM模式模板笔记

一、ACM 模式 I/O 模板

很多 OJ 平台使用 ACM 模式，需要自行处理输入输出

1. fmt.Scan 基础模板

fmt.Scan 会自动跳过空白字符（空格、换行、制表符），逐个读取数据，参数必须传指针（加 &）

package main

import "fmt"

func main() {
    var n int
    fmt.Scan(&n)

    for i := 0; i < n; i++ {
        var a, b int
        fmt.Scan(&a, &b)
        fmt.Println(a + b)
    }
    // 示例输出
    // 3
    // 7
    // 11
}

2. bufio.Scanner 快读模板（大数据量防超时必备）

数据量大时 fmt.Scan 容易超时，使用 bufio 加速读取，按空白字符拆分输入：

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
)

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    // 按空白字符分割（空格、换行都算作分隔符）
    scanner.Split(bufio.ScanWords)
    // 扩大缓冲区适配大数据
    scanner.Buffer(make([]byte, 1024*1024), 1024*1024)

    // 读取 int 的辅助函数
    readInt := func() int {
        scanner.Scan()
        num, _ := strconv.Atoi(scanner.Text())
        return num
    }

    n := readInt()
    for i := 0; i < n; i++ {
        a := readInt()
        b := readInt()
        fmt.Println(a + b)
    }
    // 示例输出
    // 3
    // 7
    // 11
}

二、排序技巧

1. 基础切片排序

sort.Ints：int 切片升序快捷排序
sort.Slice + 闭包：自定义排序规则

package main

import (
    "fmt"
    "sort"
    "math"
)

func main() {
    nums := []int{3, 1, 4, 1, 5, 9}

    // 升序（快捷写法）
    sort.Ints(nums)
    fmt.Println(nums) // [1 1 3 4 5 9]

    // 降序（自定义 less 函数）
    sort.Slice(nums, func(i, j int) bool {
        return nums[i] > nums[j]
    })
    fmt.Println(nums) // [9 5 4 3 1 1]

    // 按绝对值降序排序
    nums1 := []int{1, -3, 5, -9, 4, -1}
    sort.Slice(nums1, func(i, j int) bool {
        absI := math.Abs(float64(nums1[i]))
        absJ := math.Abs(float64(nums1[j]))
        return absI > absJ
    })
    fmt.Println(nums1) // [-9 5 4 -3 1 -1]

    // 按绝对值升序排序
    nums2 := []int{1, -3, 5, -9, 4, -1}
    sort.Slice(nums2, func(i, j int) bool {
        absI := math.Abs(float64(nums2[i]))
        absJ := math.Abs(float64(nums2[j]))
        return absI < absJ
    })
    fmt.Println(nums2) // [1 -1 -3 4 5 -9]
}

less 函数规则：返回 true 表示 i 元素排在 j 元素前面

2. 结构体切片排序

package main

import (
    "fmt"
    "sort"
)

type Student struct {
    Name  string
    Score int
}

func main() {
    students := []Student{
        {"Alice", 85},
        {"Bob", 92},
        {"Charlie", 78},
    }

    // 按分数降序排列
    sort.Slice(students, func(i, j int) bool {
        return students[i].Score > students[j].Score
    })

    for _, s := range students {
        fmt.Printf("%s: %d\n", s.Name, s.Score)
    }
    // 输出
    // Bob: 92
    // Alice: 85
    // Charlie: 78
}

3. 多级排序

示例规则：先按分数降序，分数相同则按名字字典序升序

package main

import (
    "fmt"
    "sort"
)

type Student struct {
    Name  string
    Score int
}

func main() {
    students := []Student{
        {"Charlie", 85},
        {"Alice", 92},
        {"Bob", 85},
        {"Alice", 85},
    }

    sort.Slice(students, func(i, j int) bool {
        // 第一关键字：分数降序
        if students[i].Score != students[j].Score {
            return students[i].Score > students[j].Score
        }
        // 第二关键字：名字字典序升序
        return students[i].Name < students[j].Name
    })

    for _, s := range students {
        fmt.Printf("%s: %d\n", s.Name, s.Score)
    }
    // 输出
    // Alice: 92
    // Alice: 85
    // Bob: 85
    // Charlie: 85
}

三、常用数学操作 & 溢出防范

1. math 包常用函数

⚠️ math 包函数基本只接收 float64 类型，int 需要手动类型转换

package main

import (
    "fmt"
    "math"
)

func main() {
    // 绝对值
    fmt.Println(math.Abs(-5.0))
    x := -5
    fmt.Println(int(math.Abs(float64(x)))) // int 类型取绝对值

    // 开方
    fmt.Println(math.Sqrt(9))

    // 幂运算
    fmt.Println(math.Pow(2, 3))

    // 向下取整、向上取整
    fmt.Println(int(math.Floor(3.7))) // 3
    fmt.Println(int(math.Ceil(3.2)))  // 4
}

2. 整数边界常量

package main

import (
    "fmt"
    "math"
)

func main() {
    // int32 边界
    fmt.Println(math.MaxInt32) // 2147483647
    fmt.Println(math.MinInt32) // -2147483648

    // int64 边界
    fmt.Println(math.MaxInt64) // 9223372036854775807

    // int32 溢出演示
    var n int32 = math.MaxInt32
    n = n + 1
    fmt.Println(n) // -2147483648，发生溢出

    // 防溢出计算：先转为 int64 再运算
    var a, b int32 = 100000, 100000
    result := int64(a) * int64(b)
    fmt.Println(result) // 10000000000

    // 无穷大初始化技巧
    minVal := math.MaxInt32
    nums := []int{5, 2, 8, 1, 9}
    for _, v := range nums {
        if v < minVal {
            minVal = v
        }
    }
    fmt.Println(minVal) // 1
}

刷题建议：优先使用原生 int（64位系统等价 int64）降低溢出风险；大数运算显式用 int64
Go1.21+ 可使用内置 min/max 函数，不要混用 math.Max/math.Min

四、优先队列模板（container/heap）

Go 标准库无现成优先队列，需实现 heap.Interface 接口

1. 小顶堆模板

package main

import (
    "container/heap"
    "fmt"
)

// IntHeap 实现 heap.Interface
type IntHeap []int

func (h IntHeap) Len() int           { return len(h) }
func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] } // 小顶堆核心规则
func (h IntHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }

func (h *IntHeap) Push(x interface{}) {
    *h = append(*h, x.(int))
}

func (h *IntHeap) Pop() interface{} {
    old := *h
    n := len(old)
    x := old[n-1]
    *h = old[:n-1]
    return x
}

func main() {
    h := &IntHeap{}
    heap.Init(h)

    // 入堆
    heap.Push(h, 3)
    heap.Push(h, 1)
    heap.Push(h, 4)
    heap.Push(h, 1)
    heap.Push(h, 5)

    // 查看堆顶元素（最小值）
    fmt.Println((*h)[0]) // 1
    // 堆长度
    fmt.Println(h.Len()) // 5

    // 依次弹出元素
    for h.Len() > 0 {
        fmt.Printf("%d ", heap.Pop(h))
    }
    // 输出：1 1 3 4 5
    fmt.Println()
}

2. 大顶堆修改方法

仅修改 Less 函数比较方向即可：

func (h IntHeap) Less(i, j int) bool {
    return h[i] > h[j] // 大顶堆核心规则
}

优先队列使用要点

入堆：heap.Push(h, val)，不要直接调用 h.Push
出堆：heap.Pop(h)，不要直接调用 h.Pop
查看堆顶：(*h)[0]，直接访问底层切片首位
判空：h.Len() > 0

五、整体刷题小结

I/O：小规模输入可用 fmt.Scan；大数据量直接用 bufio 快读避免超时
排序：优先 sort.Slice + 闭包自定义 less 函数，支持单条件/结构体/多级排序
数值计算：注意类型转换和溢出问题，大数运算用 int64
优先队列：套用 heap 模板，通过修改 Less 函数实现大小顶堆
基础工具：善用 math 包函数，注意 float64 类型限制；可用 MaxInt32 表示无穷大

ACM模式

Wed, 15 Jul 2026 00:00:00 GMT

ACM模式：读取至EOF模板笔记

核心关键点

ACM OJ 题目测试用例组数不固定，需要持续读取输入直到 EOF（输入结束标记），不能固定循环次数读取

基础模板：fmt.Scan + EOF 判断

package main

import (
    "fmt"
    "io"
)

func add(a, b int) int {
    return a + b
}

func main() {
    var a, b int
    // 循环读取，直到读到EOF结束
    for {
        _, err := fmt.Scan(&a, &b)
        if err != nil {
            // 判断是否为正常输入结束
            if err == io.EOF {
                break
            }
            // 非EOF错误，抛出异常
            panic(err)
        }
        result := add(a, b)
        fmt.Println(result)
    }
}

重要注意事项

题目结构参考
- 题目示例：查看输入格式、每行数据结构、字段数量和类型
- 自测用例：多行连续输入，无固定行数，模拟真实OJ评测输入
- 完整流程：导包 → 循环读取并解析输入 → 算法计算 → 逐行输出结果
错误判断逻辑
- fmt.Scan 返回 err：读到末尾时错误为 io.EOF → 正常退出循环
- 其他错误（格式错误等）用 panic 抛出，方便调试

大数据版本：bufio快读 + EOF循环

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
)

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    scanner.Split(bufio.ScanWords)
    scanner.Buffer(make([]byte, 1024*1024), 1024*1024)

    readInt := func() int {
        scanner.Scan()
        num, _ := strconv.Atoi(scanner.Text())
        return num
    }

    for scanner.Scan() {
        a := readInt()
        b := readInt()
        fmt.Println(a + b)
    }
    // 检查扫描器是否存在非EOF错误
    if err := scanner.Err(); err != nil {
        panic(err)
    }
}

易错坑
- ❌ 不要直接写固定n次循环（for i:=0;i<n;i++），无法适配未知组数用例
- ✅ 用无限循环 + EOF检测，保证读取全部输入
- ✅ 保证输出格式和题目要求完全一致（换行、空格格式）

EOF含义

EOF = End of File，代表输入流结束，在线评测系统会一次性输入全部测试数据并以EOF结尾；Windows控制台可按 Ctrl+Z，Mac/Linux控制台可按 Ctrl+D 手动触发EOF用于本地自测。

260714GO包与导入

Tue, 14 Jul 2026 00:00:00 GMT

GO包与导入

一、Go 的包（package）

Go 使用包（package）来组织和管理代码

每个 .go 文件第一行必须声明所属包：package 包名
package main 是特殊包：
- 标识该包为可执行程序（编译后生成可运行文件）
- 程序入口：main 包中的 main() 函数，程序启动时自动执行 main()
- 非 main 包：是库包（被其他包引用，不能直接独立运行）
同一个目录下所有 .go 文件 必须声明为同一个包；包名通常和目录名保持一致

二、import 导入

通过 import 引入外部包，调用格式：包名.函数名/类型名

1. 基础写法

import "fmt"
import "sort"
import "strings"

2. 分组导入写法（推荐）

import (
    "fmt"
    "sort"
    "strings"
)

3. 导入规则

Go 强制规则：导入但未使用的包会直接编译报错，不是警告（Go 设计原则：避免冗余死代码）
下划线匿名导入：仅执行包初始化、调用包内 init() 函数，不直接调用包内方法
```
import _ "net/http/pprof"
```
- 适用场景：数据库驱动注册、埋点/监控组件注册等，无需手动调用包内函数，只需完成初始化

4. 导入别名写法（补充）

import (
    s "sort"    // 自定义短别名 s 代替原包名 sort
    "fmt"
)

调用时：s.Slice(...)

三、可见性规则（大小写控制导出/私有）

Go 没有 public / private 关键字，通过标识符首字母大小写控制跨包可见性

✅ 首字母大写 = 导出（public）：可被外部其他包访问

// 可跨包调用
func Factorial(n int) int { ... }
var MaxSize = 100
type Student struct {
    Name string // 大写字段：外部包可访问
    age  int    // 小写字段：仅本包可用
}

✅ 首字母小写 = 包内私有（private）：仅当前包内部可用，外部包无法访问
```
// 仅本包内部调用
func helper() { ... }
var count = 0
type config struct { ... }
```

适用范围：函数、变量、常量、自定义类型、结构体字段等所有标识符
例：标准库 fmt.Println、sort.Ints、strings.ToUpper 均为大写导出，可供外部调用

四、init() 初始化函数

特性

格式：func init() {}，无参数、无返回值，不能手动调用
执行时机：包被导入时自动执行，执行顺序：

被依赖导入包的 init() → 当前包的 init() → main()
用途：初始化包级全局变量、注册组件、加载配置、预处理等
- 刷题场景极少用到；工程开发（数据库驱动、中间件）很常用
- 同一个包内可写多个 init() 函数，会按文件加载顺序依次自动执行

示例代码

package main
import "fmt"

// 包级别全局变量
var config string

// init 自动执行，在 main 之前运行
func init() {
    config = "production"
    fmt.Println("init() 执行了，config =", config)
}

func main() {
    fmt.Println("main() 执行了")
    fmt.Println("当前配置:", config)
}

五、多文件组织

同一目录、同一个 package 的多个 .go 文件：可直接互相调用，无需额外 import
可以拆分代码：如 utils.go（工具函数）、main.go（主逻辑），互相自由调用变量/函数
核心前提：所有文件开头包声明保持一致（如全部写 package main）

六、刷题常用标准库包一览

fmt：格式化输入输出（Printf / Println / Scan）
sort：排序相关函数（sort.Slice、sort.Ints 等）
strings：字符串处理（查找、分割、大小写转换、匹配）
strconv：字符串与数值类型互相转换
math：数学运算（max/min、开方、取整、常数 Pi）
bufio：高效读取输入（读取整行、大数据输入）
container/list：双向链表
time：时间处理
bytes：字节数组处理

260714GO基础语法

Tue, 14 Jul 2026 00:00:00 GMT

GO语言基础语法

一、标准输出

fmt.Println：打印后自动换行，多个参数之间用空格分隔
fmt.Print：打印后不换行
fmt.Printf：格式化输出，和 C 语言的 printf 类似，需手动加 \n 换行

常用格式化占位符

%d：整数
%s：字符串
%f：浮点数
- 示例：fmt.Printf("pi = %.2f\n", pi) 保留2位小数
%c：打印字符
%v：万能占位符，适配任意类型

fmt.Println(10, 20, "hello")   // 自动换行，参数间空格分隔
fmt.Print(10, 20, "hello")    // 不换行，参数间空格分隔
fmt.Printf("a = %d, b = %d\n", 10, 20) // 格式化模板输出

二、读取输入

1. fmt.Scan

以空格/换行作为分隔符读取输入
✅ 变量前必须加 & 传地址

var name string
var age int
fmt.Scan(&name, &age)
fmt.Println("姓名：", name)
fmt.Println("年龄：", age)

返回值：(n int, err error)
- n：成功读取的变量个数
- err：读取错误（正常为 nil）
- _：空白标识符，用于丢弃不需要的返回值

循环读取直到 EOF

package main
import "fmt"

func main() {
    var a, b int
    for {
        n, err := fmt.Scan(&a, &b)
        if n != 2 || err != nil {
            break
        }
        fmt.Println(a + b)
    }
}

2. 读取整行（含空格）bufio.Scanner

package main
import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    scanner.Scan()    // 读取一整行
    line := scanner.Text()
    fmt.Println(line)
}

三、& 和 * 运算符

1. & 取地址运算符

&变量：获取变量内存地址，生成指针
- 例：var a int; p := &a，p 类型为 *int
- 作用：传递原始变量地址，允许函数修改原变量（不是副本）
- 关键：fmt.Scan 需要指针参数才能正确写入值，不能直接传变量本身

2. * 解引用运算符

*指针变量：访问/修改指针指向的原始变量
```
var a int
p := &a
*p = 100 // 通过指针修改原变量 a
fmt.Println(a) // 输出 100
```
- 类型声明写法：var p *int 表示 int 指针类型（和表达式解引用语法不同）

&x：取 x 的地址 → 生成指针

*p：顺着指针地址访问原值

四、变量与数据类型

1. 基础类型

bool：布尔（true / false）
string：UTF-8 字符串
整数：int / int8 / int16 / int32 / int64 / uint / uint8(byte) / uint16 / uint32 / uint64 / uintptr
rune：int32 别名，用于 Unicode 字符
浮点数：float32 / float64
复数：complex64 / complex128

2. 复合类型

数组 [N]T：固定长度，值类型
切片 []T：动态数组，引用类型（需 make）
Map map[KeyType]ValueType：哈希映射，引用类型（需 make）
Struct：结构体，自定义聚合类型
Channel chan T：通道，goroutine 通信（需 make）
Pointer *T：指针类型
Function：函数类型
Interface：接口类型

3. 变量规则

Go 强制要求：声明变量必须使用，否则编译报错
临时忽略值：用空白标识符 _

4. 常量 const

const MaxSize = 100
const Pi = 3.14159

常量定义后不可修改

5. 显式类型转换

Go 无隐式自动类型转换，必须显式转换

a := 42
b := float64(a)
fmt.Println(b)

c := 3.99
d := int(c) // 截断小数，不是四舍五入 → 结果 3
fmt.Println(d)

// 整数除法坑
x, y := 1, 2
fmt.Println(x / y)                  // int除法：0
fmt.Println(float64(x) / float64(y))// 浮点数除法：0.5

var e int = 100
var f int64 = int64(e)
fmt.Println(f)

// 数值转字符串
num := 42
s := fmt.Sprintf("%d", num)
fmt.Printf("%s (string)\n", s)

五、运算符

1. 算术运算符

a, b := 17, 5
fmt.Println(a + b) // 加法
fmt.Println(a - b) // 减法
fmt.Println(a * b) // 乘法
fmt.Println(a / b) // 整数除法，截断小数
fmt.Println(a % b) // 取余

// 自增/自减：只能独立语句，不能嵌入表达式
c := 10
c++
fmt.Println(c)
c--
fmt.Println(c)

// 复合赋值
c += 5
c *= 2

2. 比较 & 逻辑运算符

a, b := 10, 20
// 比较
fmt.Println(a == b)
fmt.Println(a != b)
fmt.Println(a < b)

// 逻辑
fmt.Println(a > 5 && b > 15)  // && 并且
fmt.Println(a > 100 || b > 15) // || 或者
fmt.Println(!(a > 5))         // ! 取反

❗ Go 没有三元运算符 ?:，只能用 if-else

var max int
if a > b {
    max = a
} else {
    max = b
}

3. 位运算

a := 10 // 1010
b := 12 // 1100

fmt.Println(a & b)  // 按位与
fmt.Println(a | b)  // 按位或
fmt.Println(a ^ b)  // 按位异或
fmt.Println(a << 1) // 左移（×2）
fmt.Println(a >> 1) // 右移（÷2）

// 判断奇偶
n := 7
if n&1 == 1 {
    fmt.Printf("%d 是奇数\n", n)
}

六、控制流

1. if / else 条件判断

条件不用括号 ()，左大括号 { 必须和 if 同行
支持前置局部变量声明

score := 85
if score >= 90 {
    fmt.Println("优秀")
} else if score >= 60 {
    fmt.Println("及格")
} else {
    fmt.Println("不及格")
}

// 前置变量写法
if num := 10; num%2 == 0 {
    fmt.Println("偶数")
}

2. for 循环（Go 唯一循环语句）

// 写法1：经典for
for i := 0; i < 5; i++ {
    fmt.Print(i, " ")
}
fmt.Println()

// 写法2：类while
sum := 0
i := 1
for i <= 100 {
    sum += i
    i++
}
fmt.Println(sum)

// 写法3：无限循环
count := 0
for {
    count++
    if count >= 3 {
        break
    }
}
fmt.Println(count)

3. range 遍历

返回：索引 i, 元素值 v

nums := [5]int{10, 20, 30, 40, 50}

// 完整接收索引和值
for i, v := range nums {
    fmt.Printf("索引 %d：值 %d\n", i, v)
}

// 只取值，用 _ 忽略索引
for _, v := range nums {
    fmt.Print(v, " ")
}
fmt.Println()

// 只取索引
for i := range nums {
    fmt.Print(i, " ")
}
fmt.Println()

4. break / continue

break：跳出整个循环
continue：跳过本轮循环，直接进入下一轮

// break 示例
for i := 1; i <= 100; i++ {
    if i%7 == 0 {
        fmt.Println("第一个能被7整除的数：", i)
        break
    }
}

// continue 示例
for i := 1; i <= 10; i++ {
    if i%2 == 0 {
        continue
    }
    fmt.Print(i, " ")
}

5. switch

默认自动 break，不会穿透 case
可多值匹配，也可无表达式作为 if-else 链使用

var day int
fmt.Scan(&day)
switch day {
case 1:
    fmt.Println("星期一")
case 2:
    fmt.Println("星期二")
case 3:
    fmt.Println("星期三")
case 6, 7:
    fmt.Println("周末")
default:
    fmt.Println("其他工作日")
}

// 无表达式 switch
score := 85
switch {
case score >= 90:
    fmt.Println("优秀")
case score >= 60:
    fmt.Println("及格")
default:
    fmt.Println("不及格")
}

260714GO函数和指针

Tue, 14 Jul 2026 00:00:00 GMT

GO 函数与指针

一、函数基础

函数是可重复调用的代码块，用于拆分代码、提高复用性、增强可读性

1. 函数定义与调用

语法：func 函数名(参数列表) 返回类型 { 函数体 }

package main
import "fmt"

// 有返回值函数：计算两数之和
func add(a, b int) int {
    return a + b
}

// 无返回值函数
func greet(name string) {
    fmt.Println("你好，" + name + "！")
}

func main() {
    fmt.Println(add(3, 5)) // 调用函数
    greet("小明")
}

func：函数关键字
参数写法：可简写同类型参数 (a, b int)
无返回值：不写返回类型即可

2. 多返回值

Go 支持函数返回多个值，常用于同时返回结果和错误信息

// 返回商、余数两个 int 值
func divide(a, b int) (int, int) {
    return a / b, a % b
}

func main() {
    q, r := divide(10, 3)
    fmt.Printf("商 = %d, 余数 = %d\n", q, r)

    // 空白标识符 _ 忽略不需要的返回值，避免编译报错
    _, remainder := divide(17, 5)
    fmt.Println("余数 =", remainder)

    quotient, _ := divide(20, 7)
    fmt.Println("商 =", quotient)
}

_：空白标识符，用于丢弃不需要的返回值，解决未使用变量编译报错问题

3. 命名返回值

可直接为返回值命名，函数内可直接赋值，使用空 return 自动返回

func divide(a, b int) (quotient, remainder int) {
    quotient = a / b
    remainder = a % b
    return // 空 return，自动返回命名变量
}

func main() {
    q, r := divide(10, 3)
    fmt.Printf("商 = %d, 余数 = %d\n", q, r)
}

二、指针

1. 指针基础

指针变量：存储另一个变量的内存地址
两个核心运算符：
- &：取地址运算符，获取变量内存地址
- *：解引用运算符，通过地址访问/修改原变量
- 指针类型写法：*int、*string 等，表示指向对应类型的指针
- ✅ Go 指针不支持指针算术运算（p++ 等），保证安全

package main
import "fmt"

func main() {
    a := 42
    var p *int = &a // p 是 *int 指针，保存 a 的内存地址
    fmt.Println("a 的地址：", p)
    fmt.Println("*p =", *p) // 解引用读取原值

    *p = 100 // 解引用修改原变量 a
    fmt.Println("a =", a) // a 变为 100

    // 简写方式
    b := 99
    p2 := &b
    fmt.Println("*p2 =", *p2)
}

2. 值传递 vs 指针传参

Go 默认参数是 值传递：传入变量副本，修改副本不会影响外部原变量

// 值传递：修改的只是副本，外部变量不变
func tryChange(x int) {
    x = 999
    fmt.Println("函数内 x =", x)
}

// 指针传参：直接修改外部原变量
func changeValue(p *int) {
    *p = 999
}

// 交换两个变量（指针版本）
func swap(a, b *int) {
    *a, *b = *b, *a
}

func main() {
    a := 10
    tryChange(a)
    fmt.Println("a =", a) // a 仍然是 10

    changeValue(&a)
    fmt.Println("a =", a) // a 变为 999

    x, y := 1, 2
    swap(&x, &y)
    fmt.Printf("x = %d, y = %d\n", x, y) // x=2 y=1
}

3. slice、map 参数传递特性

slice 和 map 底层结构自带指针，传递时不需要额外加 *，函数内修改元素会直接影响外部原数据

package main
import "fmt"

// 修改切片元素，直接影响原切片
func doubleSlice(nums []int) {
    for i := range nums {
        nums[i] *= 2
    }
}

// 修改 map，直接影响原 map
func addEntry(m map[string]int, key string, value int) {
    m[key] = value
}

func main() {
    nums := []int{1, 2, 3, 4, 5}
    doubleSlice(nums)
    fmt.Println(nums) // [2 4 6 8 10]

    scores := map[string]int{"Alice": 90}
    addEntry(scores, "Bob", 85)
    fmt.Println(scores) // map[Alice:90 Bob:85]
}

map 初始化方式

// 方式1：字面量初始化
scores := map[string]int{"Alice": 90}

// 方式2：make 初始化（推荐动态使用）
scores := make(map[string]int)
scores["Alice"] = 90

❗ nil map 不能直接赋值，必须先用 make / 字面量初始化
map 取值检查：val, ok := scores["Alice"]
- val：对应 value 值
- ok：bool 类型，表示 key 是否存在

三、错误处理（error）

Go 没有 try/catch 异常机制，依靠多返回值 error 做错误处理
调用函数后主动检查 err 是否为 nil

常见多返回值函数

fmt.Scan → (n int, err error)
strconv.Atoi → (int, error)
os.Open → (*os.File, error)
map 取值：val, ok := m["key"]
range 遍历：i, v := range arr

四、匿名函数 & 闭包

1. 匿名函数

没有函数名的函数，可以赋值给变量、直接调用

package main
import "fmt"

func main() {
    // 匿名函数赋值给变量
    add := func(a, b int) int {
        return a + b
    }
    fmt.Println(add(3, 5)) // 8
}

2. 闭包

闭包 = 可以捕获外层变量的匿名函数，会保留引用外部变量，而非复制副本

package main
import "fmt"

func main() {
    x := 10
    addX := func(n int) int {
        return n + x // 捕获外部变量 x
    }
    fmt.Println(addX(5)) // 15

    x = 100 // 修改外部变量，闭包可感知变化
    fmt.Println(addX(5)) // 105
}

3. 闭包 + sort.Slice 自定义排序

sort.Slice(slice, less func(i,j int) bool)

参数1：目标切片
参数2：less 闭包函数：i,j 为索引，返回 bool
- true：i 元素排在 j 前面

package main
import (
    "fmt"
    "sort"
)

func main() {
    nums := []int{3, 1, 4, 1, 5, 9, 2, 6}
    // 升序排序
    sort.Slice(nums, func(i, j int) bool {
        return nums[i] < nums[j]
    })
    fmt.Println(nums) // [1 1 2 3 4 5 6 9]

    // 按绝对值从大到小排序
    nums2 := []int{-3, 1, -4, 1, 5, -9, 2, -6}
    sort.Slice(nums2, func(i, j int) bool {
        a, b := nums2[i], nums2[j]
        if a < 0 { a = -a }
        if b < 0 { b = -b }
        return a > b
    })
    fmt.Println(nums2) // [-9 -6 5 -4 -3 2 1 1]
}

260714GO常用数据结构

Tue, 14 Jul 2026 00:00:00 GMT

GO 常用数据结构

一、数组与切片

1. 数组 Array

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

package main
import "fmt"

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

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

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

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

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

2. 切片 Slice

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

创建方式

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

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

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

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

    // range遍历
    for _, v := range nums {
        fmt.Print(v, " ")
    }
    fmt.Println()
}

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

切片增删 & 截取

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

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

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

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

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

二维切片

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

    // 赋值
    grid[0][0] = 1
    grid[1][2] = 5
    grid[2][3] = 9

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

内存结构

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

二、字符串 string

基础特性

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

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

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

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

    // range遍历 Unicode
    for _, ch := range "Hello" {
        fmt.Printf("%c ", ch)
    }
    fmt.Println()

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

[]byte 与 []rune 转换

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

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

strings 包常用函数

package main
import (
    "fmt"
    "strings"
)
func main() {
    s := "Hello, World!"
    fmt.Println(strings.Contains(s, "World"))    // 是否包含子串 true
    fmt.Println(strings.Index(s, "World"))       // 子串起始索引 7
    fmt.Println(strings.HasPrefix(s, "Hello"))   // 是否前缀 true
    fmt.Println(strings.HasSuffix(s, "World!"))  // 是否后缀 true

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

strconv 包：字符串和数字互转

package main
import (
    "fmt"
    "strconv"
)
func main() {
    // Atoi：字符串转int
    n, err := strconv.Atoi("123")
    if err == nil {
        fmt.Println(n) // 123
    }

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

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

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

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

三、结构体 struct

定义和初始化

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

type Student struct {
    Name  string
    Age   int
    Score float64
}

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

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

    // 访问&修改字段
    fmt.Println(s1.Name)
    s1.Age = 21
    fmt.Println(s1.Age)

    // 零值结构体
    var s3 Student
    fmt.Println(s3)
}

结构体指针

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

type Point struct {
    X int
    Y int
}

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

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

四、哈希表 map

基础用法

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

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

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

    // 字面量初始化
    scores := map[string]int{
        "Alice": 90,
        "Bob":   85,
        "Carol": 92,
    }

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

判断 key 是否存在

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

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

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

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

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

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

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

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

    delete(set, 2) // 删除元素
    for k := range set {
        fmt.Print(k, " ")
    }
    fmt.Println()
}

五、栈（用切片模拟）

后进先出（LIFO）

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

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

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

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

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

六、队列（FIFO 先进先出）

container/list 双向链表实现

package main
import (
    "container/list"
    "fmt"
)
func main() {
    queue := list.New()
    // 入队
    queue.PushBack(10)
    queue.PushBack(20)
    queue.PushBack(30)
    fmt.Println("大小:", queue.Len()) // 3

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

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

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

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

七、make 初始化规则

✅ make 仅用于 3 种引用类型

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

❌ 不能用 make 的类型

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

❗ new 和 make 的区别

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

用于测试的文章

Mon, 13 Jul 2026 00:00:00 GMT

博客的标签分类有：

测试文章图片放置

算法框架

Sat, 11 Jul 2026 00:00:00 GMT

数据结构的存储方式

数据结构的存储方式只有两种：数组（顺序存储）和链表（链式存储）。

数组和链表才是结构基础

哈希表、栈、队列、堆、树、图等等各种数据结构都是在链表或者数组上的特殊操作，API 不同而已。

二者的优缺点如下：

数组紧凑连续存储，可以随机访问，通过索引快速找到对应元素，而且相对节约存储空间。但正因为连续存储，内存空间必须一次性分配够，所以说数组如果要扩容，需要重新分配一块更大的空间，再把数据全部复制过去，时间复杂度 O(N)；而且你如果想在数组中间进行插入和删除，每次必须搬移后面的所有数据以保持连续，时间复杂度 O(N)。

链表因为元素不连续，而是靠指针指向下一个元素的位置，所以不存在数组的扩容问题；如果知道某一元素的前驱和后驱，操作指针即可删除该元素或者插入新元素，时间复杂度 O(1) O (1)。但是正因为存储空间不连续，你无法根据一个索引算出对应元素的地址，所以不能随机访问；而且由于每个元素必须存储指向前后元素位置的指针，会消耗相对更多的储存空间。

比如说队列、栈这两种数据结构既可以使用链表也可以使用数组实现。用数组实现，就要处理扩容缩容的问题；用链表实现，没有这个问题，但需要更多的内存空间存储节点指针。

图结构的两种存储方式，邻接表就是链表，邻接矩阵就是二维数组。邻接矩阵判断连通性迅速，并可以进行矩阵运算解决一些问题，但是如果图比较稀疏的话很耗费空间。邻接表比较节省空间，但是很多操作的效率上肯定比不过邻接矩阵。

哈希表就是通过散列函数把键映射到一个大数组里。而且对于解决散列冲突的方法，拉链法需要链表特性，操作简单，但需要额外的空间存储指针；线性探查法需要数组特性，以便连续寻址，不需要指针的存储空间，但操作稍微复杂些。

树结构，用数组实现就是「堆」，因为「堆」是一个完全二叉树，用数组存储不需要节点指针，操作也比较简单，经典应用有二叉堆；用链表实现就是很常见的那种「树」，因为不一定是完全二叉树，所以不适合用数组存储。为此，在这种链表「树」结构之上，又衍生出各种巧妙的设计，比如二叉搜索树、AVL 树、红黑树、区间树、B 树等等，以应对不同的问题。

数据结构的基本操作

对于任何数据结构，其基本操作无非遍历 + 访问，再具体一点就是：增删查改。

各种数据结构的遍历 + 访问无非两种形式：线性的和非线性的。

线性就是 for/while 迭代为代表，非线性就是递归为代表。再具体一步，无非以下几种框架：