go-Go LeetCode-Go：用 Go 语言刷 LeetCode 的终极指南

icy 昨天 12 抢沙发

默认

摘要： Go LeetCode-Go：用 Go 语言刷 LeetCode 的终极指南项目简介 LeetCode-Go 是一个使用 Go 语言实现的 LeetCode 算法题解项目，由 h...

Go LeetCode-Go：用 Go 语言刷 LeetCode 的终极指南

项目简介

LeetCode-Go 是一个使用 Go 语言实现的 LeetCode 算法题解项目，由 halfrost 创建和维护。该项目旨在为学习 Go 语言和算法的人提供一个全面的参考资源，包含了 LeetCode 上大量题目的 Go 语言实现、详细解析和复杂度分析。

项目特点

1. 全面覆盖

包含 LeetCode 上 2000+ 道题目的 Go 语言解决方案
题目按照难度（简单、中等、困难）和类型（数组、字符串、动态规划等）分类
每道题都提供多种解法，展示不同的解题思路

2. 高质量代码

代码风格统一，遵循 Go 语言最佳实践
每段代码都有详细注释，解释算法思路
包含时间和空间复杂度分析

3. 学习友好

从基础到高级，适合各个阶段的学习者
提供算法模板和常用技巧总结
包含测试用例，方便验证代码正确性

项目结构

text

LeetCode-Go/
├── leetcode/           # 题目分类目录
│   ├── 0001-0100/     # 按题号范围分类
│   ├── 0101-0200/
│   └── ...
├── templates/         # 算法模板
├── notes/            # 学习笔记
└── README.md         # 项目说明

实例展示

示例 1：两数之和（第1题）

text

// 题目：给定一个整数数组 nums 和一个目标值 target，
// 请你在该数组中找出和为目标值的那两个整数，并返回它们的数组下标。

func twoSum(nums []int, target int) []int {
    // 使用哈希表存储已遍历元素的值和索引
    hashMap := make(map[int]int)
    
    for i, num := range nums {
        complement := target - num
        // 检查补数是否已在哈希表中
        if index, exists := hashMap[complement]; exists {
            return []int{index, i}
        }
        // 将当前元素存入哈希表
        hashMap[num] = i
    }
    
    return nil
}

复杂度分析： - 时间复杂度：O(n)，只需遍历一次数组 - 空间复杂度：O(n)，最坏情况下需要存储所有元素

示例 2：反转链表（第206题）

text

// 题目：反转一个单链表

type ListNode struct {
    Val  int
    Next *ListNode
}

func reverseList(head *ListNode) *ListNode {
    var prev *ListNode
    current := head
    
    for current != nil {
        // 保存下一个节点
        nextTemp := current.Next
        // 反转当前节点的指针
        current.Next = prev
        // 移动指针
        prev = current
        current = nextTemp
    }
    
    return prev
}

解题思路： 使用三个指针（prev、current、nextTemp）迭代遍历链表，逐个反转节点指向。

示例 3：二叉树的层序遍历（第102题）

text

// 题目：给你一个二叉树，请你返回其按层序遍历得到的节点值

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

func levelOrder(root *TreeNode) [][]int {
    if root == nil {
        return [][]int{}
    }
    
    result := [][]int{}
    queue := []*TreeNode{root}
    
    for len(queue) > 0 {
        levelSize := len(queue)
        currentLevel := []int{}
        
        for i := 0; i < levelSize; i++ {
            node := queue[0]
            queue = queue[1:]
            currentLevel = append(currentLevel, node.Val)
            
            if node.Left != nil {
                queue = append(queue, node.Left)
            }
            if node.Right != nil {
                queue = append(queue, node.Right)
            }
        }
        
        result = append(result, currentLevel)
    }
    
    return result
}

算法要点： - 使用队列实现广度优先搜索（BFS） - 记录每层的节点数，确保正确分层