learnNote

主题

LeetCode 刷题基础语法：Go vs Python ​

1. 变量声明与基本类型 ​

Python ​

python
# 动态类型，无需声明类型
a = 10
b = 3.14
s = "hello"
flag = True

# 多变量赋值
x, y, z = 1, 2, 3

# 交换变量
a, b = b, a

# 类型转换
n = int("123")
s = str(123)
f = float("3.14")

# 最大/最小值
INF = float('inf')
NEG_INF = float('-inf')

Go ​

go
// 短变量声明（函数内部）
a := 10
b := 3.14
s := "hello"
flag := true

// 显式声明
var a int = 10
var s string = "hello"

// 多变量
x, y, z := 1, 2, 3

// 交换变量
a, b = b, a

// 类型转换
n, _ := strconv.Atoi("123")   // string -> int
s := strconv.Itoa(123)         // int -> string
f, _ := strconv.ParseFloat("3.14", 64)

// 最大/最小值
INF := math.MaxInt64
NEG_INF := math.MinInt64

2. 输出与调试 ​

Python ​

python
print(a)
print(a, b, c)
print(f"value = {a}, name = {s}")

Go ​

go
fmt.Println(a)
fmt.Println(a, b, c)
fmt.Printf("value = %d, name = %s\n", a, s)

3. 条件判断 if/else ​

Python ​

python
if x > 0:
    print("positive")
elif x == 0:
    print("zero")
else:
    print("negative")

# 三元表达式
result = "yes" if x > 0 else "no"

# 链式比较
if 1 <= x <= 100:
    pass

Go ​

go
if x > 0 {
    fmt.Println("positive")
} else if x == 0 {
    fmt.Println("zero")
} else {
    fmt.Println("negative")
}

// 没有三元表达式，只能用 if-else

// if 可以带初始化语句
if val, ok := myMap[key]; ok {
    fmt.Println(val)
}

4. for 循环 ​

Python ​

python
# 范围循环
for i in range(10):         # 0 到 9
    pass

for i in range(2, 10):      # 2 到 9
    pass

for i in range(0, 10, 2):   # 0, 2, 4, 6, 8（步长为2）
    pass

for i in range(9, -1, -1):  # 9 到 0（倒序）
    pass

# while 循环
while condition:
    pass

# 遍历列表
for val in nums:
    pass

# 带索引遍历
for i, val in enumerate(nums):
    pass

# 遍历字典
for key, val in d.items():
    pass

# break / continue
for i in range(10):
    if i == 3:
        continue
    if i == 7:
        break

Go ​

go
// 经典 for
for i := 0; i < 10; i++ {
}

for i := 2; i < 10; i++ {
}

for i := 0; i < 10; i += 2 {
}

for i := 9; i >= 0; i-- {
}

// while 风格
for condition {
}

// 无限循环
for {
    if shouldBreak {
        break
    }
}

// 遍历切片
for i, val := range nums {
    _ = i   // 不用索引时用 _
    _ = val
}

// 只要索引
for i := range nums {
}

// 遍历 map
for key, val := range m {
}

// break / continue 同样适用

5. 数组 / 切片 / 列表 ​

Python (list) ​

python
# 创建
nums = []
nums = [0] * 10           # 长度10，初始值0
nums = [1, 2, 3, 4, 5]

# 二维数组
grid = [[0] * n for _ in range(m)]  # m行n列

# 访问
nums[0]       # 第一个
nums[-1]      # 最后一个
nums[1:3]     # 切片 [1, 3)

# 添加
nums.append(6)             # 尾部添加
nums.insert(0, 99)         # 指定位置插入

# 删除
nums.pop()                 # 弹出最后一个
nums.pop(0)                # 弹出第一个
del nums[2]                # 删除指定索引

# 长度
len(nums)

# 排序
nums.sort()                # 原地升序
nums.sort(reverse=True)    # 原地降序
nums.sort(key=lambda x: x[1])  # 自定义排序
sorted_nums = sorted(nums)     # 返回新列表

# 反转
nums.reverse()
nums[::-1]                 # 返回新列表

# 查找
3 in nums                  # O(n) 判断存在
nums.index(3)              # 找索引（不存在会报错）

# 最大/最小/求和
max(nums)
min(nums)
sum(nums)

# 列表推导式
squares = [x * x for x in range(10)]
evens = [x for x in nums if x % 2 == 0]

# 拼接
a + b                      # 合并两个列表

# 解包
first, *rest = nums

Go (slice) ​

go
// 创建
nums := []int{}
nums := make([]int, 10)           // 长度10，初始值0
nums := []int{1, 2, 3, 4, 5}

// 二维切片
grid := make([][]int, m)
for i := range grid {
    grid[i] = make([]int, n)
}

// 访问
nums[0]
nums[len(nums)-1]
nums[1:3]                         // 切片 [1, 3)

// 添加
nums = append(nums, 6)            // 尾部添加
// 指定位置插入较复杂
nums = append(nums[:i+1], nums[i:]...)
nums[i] = val

// 删除
nums = nums[:len(nums)-1]                    // 弹出最后一个
nums = append(nums[:i], nums[i+1:]...)       // 删除索引 i

// 长度
len(nums)

// 排序
sort.Ints(nums)                              // 升序
sort.Sort(sort.Reverse(sort.IntSlice(nums))) // 降序
sort.Slice(nums, func(i, j int) bool {
    return nums[i] < nums[j]                 // 自定义排序
})

// 反转（手动）
for i, j := 0, len(nums)-1; i < j; i, j = i+1, j-1 {
    nums[i], nums[j] = nums[j], nums[i]
}

// 查找（线性）
func contains(nums []int, target int) bool {
    for _, v := range nums {
        if v == target {
            return true
        }
    }
    return false
}

// 最大/最小/求和（手动）
mx := nums[0]
for _, v := range nums[1:] {
    if v > mx {
        mx = v
    }
}

// 拷贝
dst := make([]int, len(src))
copy(dst, src)

// 拼接
result := append(a, b...)

6. 字符串操作 ​

Python ​

python
s = "hello world"

# 长度
len(s)

# 访问字符
s[0]        # 'h'
s[-1]       # 'd'

# 切片
s[1:5]      # "ello"
s[::-1]     # 反转字符串

# 遍历
for ch in s:
    pass

for i, ch in enumerate(s):
    pass

# 查找
s.find("lo")         # 返回索引，找不到返回 -1
"lo" in s            # True/False
s.count("l")         # 出现次数
s.startswith("he")
s.endswith("ld")

# 分割与连接
parts = s.split(" ")         # ["hello", "world"]
joined = " ".join(parts)     # "hello world"
joined = "".join(char_list)  # 字符列表拼成字符串

# 替换
s.replace("world", "python")

# 大小写
s.upper()
s.lower()

# 判断
s.isdigit()
s.isalpha()
s.isalnum()

# 字符串 <-> 字符列表
chars = list(s)
s = "".join(chars)

# ASCII
ord('a')   # 97
chr(97)    # 'a'

Go ​

go
s := "hello world"

// 长度
len(s)                    // 字节数
// 如需字符数（含中文等）
utf8.RuneCountInString(s)

// 访问字符（byte）
s[0]                      // 'h' (byte类型)

// 切片
s[1:5]                    // "ello"

// 反转字符串
runes := []rune(s)
for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
    runes[i], runes[j] = runes[j], runes[i]
}
reversed := string(runes)

// 遍历
for i, ch := range s {   // ch 是 rune 类型
    _ = i
    _ = ch
}

// 查找
strings.Contains(s, "lo")
strings.Index(s, "lo")              // 返回索引，-1 表示未找到
strings.Count(s, "l")
strings.HasPrefix(s, "he")
strings.HasSuffix(s, "ld")

// 分割与连接
parts := strings.Split(s, " ")
joined := strings.Join(parts, " ")

// 替换
strings.ReplaceAll(s, "world", "go")

// 大小写
strings.ToUpper(s)
strings.ToLower(s)

// 字符串 <-> []byte / []rune
bytes := []byte(s)
s = string(bytes)
runes := []rune(s)
s = string(runes)

// ASCII
int('a')          // 97
string(rune(97))  // "a"

// 高效拼接字符串
var builder strings.Builder
builder.WriteString("hello")
builder.WriteByte(' ')
builder.WriteString("world")
result := builder.String()

7. 哈希表 / 字典 (Map) ​

Python (dict) ​

python
# 创建
d = {}
d = {"a": 1, "b": 2}

# 访问
d["a"]               # 不存在会 KeyError
d.get("a", 0)        # 不存在返回默认值 0

# 设置
d["c"] = 3

# 删除
del d["a"]
d.pop("a", None)     # 安全删除

# 判断存在
"a" in d

# 遍历
for key in d:
    pass
for key, val in d.items():
    pass

# 长度
len(d)

# 常用特殊字典
from collections import defaultdict
d = defaultdict(int)         # 默认值 0
d = defaultdict(list)        # 默认值 []
d = defaultdict(set)         # 默认值 set()

from collections import Counter
cnt = Counter(nums)          # 计数器
cnt.most_common(3)           # 前3个高频元素

Go (map) ​

go
// 创建
m := map[string]int{}
m := map[string]int{"a": 1, "b": 2}
m := make(map[string]int)

// 访问
val := m["a"]               // 不存在返回零值
val, ok := m["a"]           // ok 判断是否存在
if val, ok := m["a"]; ok {
    // 存在
}

// 设置
m["c"] = 3

// 删除
delete(m, "a")

// 判断存在
_, ok := m["a"]

// 遍历
for key, val := range m {
}

// 长度
len(m)

// 计数器模式
cnt := make(map[int]int)
for _, v := range nums {
    cnt[v]++
}

8. 集合 (Set) ​

Python (set) ​

python
s = set()
s = {1, 2, 3}

s.add(4)
s.remove(3)       # 不存在会报错
s.discard(3)      # 安全移除

3 in s             # 判断存在
len(s)

# 集合运算
a | b              # 并集
a & b              # 交集
a - b              # 差集

# 从列表去重
unique = list(set(nums))

Go (用 map 模拟) ​

go
s := make(map[int]bool)
// 或 map[int]struct{} 更省内存
s := make(map[int]struct{})

s[4] = struct{}{}
delete(s, 3)

_, ok := s[3]     // 判断存在
len(s)

// 无内置集合运算，需手动实现

9. 栈 (Stack) ​

Python (用 list) ​

python
stack = []

stack.append(1)        # 入栈
top = stack[-1]        # 查看栈顶
val = stack.pop()      # 出栈

len(stack) == 0        # 判空
# 或
not stack

Go (用 slice) ​

go
stack := []int{}

stack = append(stack, 1)             // 入栈
top := stack[len(stack)-1]           // 查看栈顶
stack = stack[:len(stack)-1]         // 出栈

len(stack) == 0                      // 判空

10. 队列 (Queue) ​

Python ​

python
from collections import deque

q = deque()
q.append(1)          # 入队（右端）
val = q.popleft()    # 出队（左端）
q[0]                 # 查看队首

len(q) == 0          # 判空

# 双端队列
q.appendleft(0)      # 左端入队
q.pop()              # 右端出队

Go ​

go
// 简单队列用 slice
q := []int{}
q = append(q, 1)     // 入队
front := q[0]        // 队首
q = q[1:]            // 出队（注意：这种方式有内存泄漏风险，大量数据时需优化）

len(q) == 0          // 判空

// LeetCode 中一般 slice 够用，生产环境建议用 container/list

11. 堆 / 优先队列 (Heap / Priority Queue) ​

Python (heapq — 默认最小堆) ​

python
import heapq

h = []
heapq.heappush(h, 3)
heapq.heappush(h, 1)
heapq.heappush(h, 2)

top = h[0]                   # 查看堆顶（最小值）
val = heapq.heappop(h)       # 弹出堆顶

# 最大堆：取负
heapq.heappush(h, -val)
max_val = -heapq.heappop(h)

# 从列表建堆
nums = [3, 1, 4, 1, 5]
heapq.heapify(nums)          # O(n)

# 自定义排序（元组，按第一个元素）
heapq.heappush(h, (distance, node))

# 前 k 个最小
heapq.nsmallest(k, nums)
# 前 k 个最大
heapq.nlargest(k, nums)

Go (container/heap) ​

go
import "container/heap"

// 需要实现 heap.Interface
type MinHeap []int

func (h MinHeap) Len() int           { return len(h) }
func (h MinHeap) Less(i, j int) bool { return h[i] < h[j] }
func (h MinHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }

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

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

// 使用
h := &MinHeap{}
heap.Init(h)
heap.Push(h, 3)
heap.Push(h, 1)
top := (*h)[0]          // 查看堆顶
val := heap.Pop(h).(int)

// 最大堆：把 Less 反过来
func (h MaxHeap) Less(i, j int) bool { return h[i] > h[j] }

12. 排序 ​

Python ​

python
# 基本排序
nums.sort()                         # 原地排序
sorted_nums = sorted(nums)          # 返回新列表

# 降序
nums.sort(reverse=True)

# 自定义排序
intervals.sort(key=lambda x: x[0])
intervals.sort(key=lambda x: (x[0], -x[1]))  # 多级排序

# 自定义比较函数
from functools import cmp_to_key
nums.sort(key=cmp_to_key(lambda a, b: a - b))

Go ​

go
// 基本排序
sort.Ints(nums)
sort.Strings(strs)
sort.Float64s(floats)

// 自定义排序
sort.Slice(intervals, func(i, j int) bool {
    if intervals[i][0] == intervals[j][0] {
        return intervals[i][1] > intervals[j][1]
    }
    return intervals[i][0] < intervals[j][0]
})

// 判断是否已排序
sort.IntsAreSorted(nums)

// 二分查找（在已排序切片中）
idx := sort.SearchInts(nums, target)

13. 二分查找 ​

Python ​

python
import bisect

# 在有序数组中查找插入位置
idx = bisect.bisect_left(nums, target)    # 第一个 >= target 的位置
idx = bisect.bisect_right(nums, target)   # 第一个 > target 的位置

# 插入并保持有序
bisect.insort_left(nums, val)

# 手写二分
def binary_search(nums, target):
    lo, hi = 0, len(nums) - 1
    while lo <= hi:
        mid = lo + (hi - lo) // 2
        if nums[mid] == target:
            return mid
        elif nums[mid] < target:
            lo = mid + 1
        else:
            hi = mid - 1
    return -1

Go ​

go
// 标准库二分
idx := sort.SearchInts(nums, target)  // 第一个 >= target 的位置

// 通用二分
idx := sort.Search(len(nums), func(i int) bool {
    return nums[i] >= target
})

// 手写二分
func binarySearch(nums []int, target int) int {
    lo, hi := 0, len(nums)-1
    for lo <= hi {
        mid := lo + (hi-lo)/2
        if nums[mid] == target {
            return mid
        } else if nums[mid] < target {
            lo = mid + 1
        } else {
            hi = mid - 1
        }
    }
    return -1
}

14. 链表 (Linked List) ​

Python ​

python
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

# 遍历
cur = head
while cur:
    print(cur.val)
    cur = cur.next

# 虚拟头节点（简化边界处理）
dummy = ListNode(0)
dummy.next = head

Go ​

go
type ListNode struct {
    Val  int
    Next *ListNode
}

// 遍历
cur := head
for cur != nil {
    fmt.Println(cur.Val)
    cur = cur.Next
}

// 虚拟头节点
dummy := &ListNode{Next: head}

15. 树 (Tree) ​

Python ​

python
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

# 递归遍历
def preorder(root):
    if not root:
        return
    print(root.val)       # 前序
    preorder(root.left)
    preorder(root.right)

def inorder(root):
    if not root:
        return
    inorder(root.left)
    print(root.val)       # 中序
    inorder(root.right)

# BFS 层序遍历
from collections import deque
def levelOrder(root):
    if not root:
        return []
    result = []
    q = deque([root])
    while q:
        level = []
        for _ in range(len(q)):
            node = q.popleft()
            level.append(node.val)
            if node.left:
                q.append(node.left)
            if node.right:
                q.append(node.right)
        result.append(level)
    return result

Go ​

go
type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

// 递归遍历
func preorder(root *TreeNode) {
    if root == nil {
        return
    }
    fmt.Println(root.Val)
    preorder(root.Left)
    preorder(root.Right)
}

// BFS 层序遍历
func levelOrder(root *TreeNode) [][]int {
    if root == nil {
        return nil
    }
    var result [][]int
    queue := []*TreeNode{root}
    for len(queue) > 0 {
        size := len(queue)
        level := make([]int, 0, size)
        for i := 0; i < size; i++ {
            node := queue[0]
            queue = queue[1:]
            level = append(level, node.Val)
            if node.Left != nil {
                queue = append(queue, node.Left)
            }
            if node.Right != nil {
                queue = append(queue, node.Right)
            }
        }
        result = append(result, level)
    }
    return result
}

16. 图 (Graph) ​

Python ​

python
# 邻接表表示
from collections import defaultdict
graph = defaultdict(list)
for u, v in edges:
    graph[u].append(v)
    graph[v].append(u)   # 无向图

# DFS
visited = set()
def dfs(node):
    if node in visited:
        return
    visited.add(node)
    for neighbor in graph[node]:
        dfs(neighbor)

# BFS
from collections import deque
def bfs(start):
    visited = {start}
    q = deque([start])
    while q:
        node = q.popleft()
        for neighbor in graph[node]:
            if neighbor not in visited:
                visited.add(neighbor)
                q.append(neighbor)

Go ​

go
// 邻接表
graph := make(map[int][]int)
for _, edge := range edges {
    u, v := edge[0], edge[1]
    graph[u] = append(graph[u], v)
    graph[v] = append(graph[v], u)
}

// DFS
visited := make(map[int]bool)
var dfs func(node int)
dfs = func(node int) {
    if visited[node] {
        return
    }
    visited[node] = true
    for _, neighbor := range graph[node] {
        dfs(neighbor)
    }
}

// BFS
func bfs(start int, graph map[int][]int) {
    visited := map[int]bool{start: true}
    queue := []int{start}
    for len(queue) > 0 {
        node := queue[0]
        queue = queue[1:]
        for _, neighbor := range graph[node] {
            if !visited[neighbor] {
                visited[neighbor] = true
                queue = append(queue, neighbor)
            }
        }
    }
}

17. 数学常用操作 ​

Python ​

python
# 整除与取余
a // b          # 整除（向下取整）
a % b           # 取余

# 幂
a ** b
pow(a, b)
pow(a, b, mod)  # 快速幂取模

# 绝对值
abs(x)

# 上取整除法
-(-a // b)     # 等价于 ceil(a/b)
import math
math.ceil(a / b)

# 最大公约数
import math
math.gcd(a, b)

# 对数
math.log(x)      # ln
math.log2(x)
math.log10(x)

# 平方根
math.sqrt(x)
int(math.sqrt(x))

Go ​

go
import "math"

// 整除与取余
a / b           // 整数除法自动截断
a % b

// 幂
math.Pow(float64(a), float64(b))

// 绝对值
// 整数没有内置 abs，需手动
func abs(x int) int {
    if x < 0 {
        return -x
    }
    return x
}
math.Abs(float64(x))  // 浮点数

// 上取整
(a + b - 1) / b

// 最大/最小（整数需手动）
func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}
func min(a, b int) int {
    if a < b {
        return a
    }
    return b
}
// Go 1.21+ 内置了 min() 和 max()

// GCD
func gcd(a, b int) int {
    for b != 0 {
        a, b = b, a%b
    }
    return a
}

// 平方根
math.Sqrt(float64(x))

18. 位运算 ​

Python ​

python
a & b      # 与
a | b      # 或
a ^ b      # 异或
~a         # 取反
a << n     # 左移
a >> n     # 右移

# 常用技巧
n & 1               # 判断奇偶（1=奇，0=偶）
n & (n - 1)         # 去掉最低位的 1
n & (-n)            # 获取最低位的 1
bin(n).count('1')   # 统计 1 的个数

Go ​

go
a & b
a | b
a ^ b      // 异或
^a         // 取反（Go 用 ^ 做一元取反）
a << n
a >> n

// 常用技巧
n & 1
n & (n - 1)
n & (-n)
bits.OnesCount(uint(n))    // import "math/bits"

19. 函数与闭包 ​

Python ​

python
# 普通函数
def add(a, b):
    return a + b

# lambda
f = lambda x: x * 2

# 闭包 / 嵌套函数（DFS/回溯常用）
def solve():
    result = []
    def backtrack(path):
        if is_valid(path):
            result.append(path[:])
            return
        for choice in choices:
            path.append(choice)
            backtrack(path)
            path.pop()
    backtrack([])
    return result

Go ​

go
// 普通函数
func add(a, b int) int {
    return a + b
}

// 多返回值
func divmod(a, b int) (int, int) {
    return a / b, a % b
}

// 匿名函数 / 闭包（DFS/回溯常用）
func solve() [][]int {
    var result [][]int
    var backtrack func(path []int)
    backtrack = func(path []int) {
        if isValid(path) {
            tmp := make([]int, len(path))
            copy(tmp, path)
            result = append(result, tmp)
            return
        }
        for _, choice := range choices {
            path = append(path, choice)
            backtrack(path)
            path = path[:len(path)-1]
        }
    }
    backtrack([]int{})
    return result
}

20. 常用导入速查 ​

Python ​

python
from collections import defaultdict, Counter, deque, OrderedDict
from heapq import heappush, heappop, heapify
from bisect import bisect_left, bisect_right, insort
from functools import lru_cache, cmp_to_key
from itertools import permutations, combinations, accumulate, product
import math
import sys
sys.setrecursionlimit(10**6)   # 提高递归上限

Go ​

go
import (
    "container/heap"
    "fmt"
    "math"
    "math/bits"
    "sort"
    "strconv"
    "strings"
)

21. LeetCode 实用技巧速查 ​

场景PythonGo
无穷大float('inf')math.MaxInt64
无穷小float('-inf')math.MinInt64
整数最大sys.maxsizemath.MaxInt64
初始化二维[[0]*n for _ in range(m)]make([][]int, m) + 循环
深拷贝列表nums[:] 或 list(nums)copy(dst, src)
字符转数字ord(c) - ord('a')c - 'a'
数字转字符chr(ord('a') + n)string(rune('a' + n))
记忆化搜索@lru_cache(None)手动用 map 做缓存
哨兵节点dummy = ListNode(0)dummy := &ListNode{}
取模防溢出% (10**9 + 7)% 1000000007