Go 语言核心技巧¶

import "container/heap"

// 通用堆模板：只需定义 Less 函数
type Hp struct {
    sort.IntSlice
    LessFunc func(i, j int) bool
}

func (h Hp) Less(i, j int) bool { return h.LessFunc(h.IntSlice[i], h.IntSlice[j]) }
func (h *Hp) Push(v any)        { h.IntSlice = append(h.IntSlice, v.(int)) }
func (h *Hp) Pop() any          { a := h.IntSlice; v := a[len(a)-1]; h.IntSlice = a[:len(a)-1]; return v }

// 使用示例：
func solve() {
    // 建立大顶堆
    pq := &Hp{IntSlice: []int{}, LessFunc: func(i, j int) bool { return i > j }}
    heap.Init(pq)
    heap.Push(pq, 10)
    top := heap.Pop(pq).(int)
}

// 初始化
set := make(map[int]struct{})

// 添加
set[1] = struct{}{}

// 查找
if _, exists := set[1]; exists { ... }

// 删除
delete(set, 1)

keys := make([]int, 0, len(m))
for k := range m {
    keys = append(keys, k)
}
sort.Ints(keys) // 关键步骤
for _, k := range keys {
    val := m[k]
    // ...
}

// 老版本解法：中间变量接引
for _, v := range nums {
    v := v // 影子变量
    result = append(result, &v)
}

// 初始化 dp[m][n]
dp := make([][]int, m)
for i := range dp {
    dp[i] = make([]int, n)
}

func min(a, b int) int { if a < b { return a }; return b }
func max(a, b int) int { if a > b { return a }; return b }
func abs(a int) int    { if a < 0 { return -a }; return a }

//按两个字段排序：先按 Age 升序，Age 相同按 Name 降序
sort.Slice(people, func(i, j int) bool {
    if people[i].Age != people[j].Age {
        return people[i].Age < people[j].Age
    }
    return people[i].Name > people[j].Name
})

// 二分查找第一个 >= target 的位置 (Lower Bound)
// 如果所有元素都 < target，返回 len(nums)
idx := sort.Search(len(nums), func(i int) bool {
    return nums[i] >= target
})

// 二分查找第一个 > target 的位置 (Upper Bound)
idx := sort.Search(len(nums), func(i int) bool {
    return nums[i] > target
})

// 常用场景：状态压缩 DP 统计状态中 1 的个数
cnt := bits.OnesCount(state)

// Go 1.22+ (math/rand/v2) - 推荐
// 自动初始化 Seed，性能更好
idx := rand.IntN(len(nums)) // 生成 [0, n) 的随机数

// Go < 1.22 (math/rand)
// 注意函数名是 Intn (小写 n)
idx := rand.Intn(len(nums))

func test() {
    // 递归闭包必须用 var 声明
    var f func(int) int
    f = func(n int) int {
        if n <= 1 {
            return n
        }
        return f(n-1) + f(n-2) // 如未提前声明 f，此时的 f() 则因不存在而报错
    }

    // 非递归闭包可以用 := 声明
    g := func(n int) int {
        if n <= 1 {
            return n
        }
        return g(n-1) + g(n-2)
    }
}

func test() (result int) {
    defer func() { result++ }()
    return 1 // result = 1 -> defer -> result = 2
}

var p *int = nil
var i interface{} = p
// i != nil，因为 i 的 Type 是 *int，Value 是 nil
if i == nil { exclude() } // ❌ 永远进不去
if v := reflect.ValueOf(i); v.IsNil() { } // ✅ 正确判断

import "unsafe"

// string -> []byte (只读，修改会导致 panic)
func StringToBytes(s string) []byte {
    return unsafe.Slice(unsafe.StringData(s), len(s))
}

// []byte -> string (零拷贝)
func BytesToString(b []byte) string {
    return unsafe.String(unsafe.SliceData(b), len(b))
}

func isValidBST(root *TreeNode) bool {
    var prev *TreeNode  // 一级指针
    return inorder(root, &prev)  // 传递指针的地址（二级指针）
}

func inorder(node *TreeNode, prev **TreeNode) bool {  // 接收二级指针
    if node == nil {
        return true
    }

    if !inorder(node.Left, prev) {
        return false
    }

    // 通过二级指针修改外部变量
    if *prev != nil && node.Val <= (*prev).Val {
        return false
    }
    *prev = node  // 解引用赋值

    return inorder(node.Right, prev)
}

func isValidBST(root *TreeNode) bool {
    var prev *TreeNode  // 闭包自动捕获这个变量

    var inorder func(*TreeNode) bool
    inorder = func(node *TreeNode) bool {
        if node == nil {
            return true
        }

        if !inorder(node.Left) {
            return false
        }

        // 直接访问外部变量，无需解引用
        if prev != nil && node.Val <= prev.Val {
            return false
        }
        prev = node  // 直接赋值

        return inorder(node.Right)
    }

    return inorder(root)
}