目录

1. 准备工作
   • 注册 LeetCode 账户
   • 选择 Python 作为默认语言
2. 代码编辑器界面介绍
   • 代码编辑区
   • 输入/输出区
   • 执行结果区
3. Python 代码模板与结构
   • 标准模板
   • 函数签名
   • 类与构造函数
4. Pythonic 编程风格与技巧
   • 列表推导式
   • 哈希集合/字典
   • 模块导入
   • 切片
   • 排序
5. 调试与测试
   • 使用 print() 打印中间结果
   • LeetCode 自带的测试功能
6. 提交代码
   • 提交按钮
   • 查看结果：通过/失败/超时
7. 推荐资源与总结

准备工作

a. 注册 LeetCode 账户

如果您还没有 LeetCode 账户，请访问 leetcode.com 并注册一个，注册后，您可以访问所有题目，但订阅会员可以解锁更多高级题目和公司面试题库。

b. 选择 Python 作为默认语言页面，点击编辑器上方的语言选择标签，选择 Python 或 Python3，LeetCode 主要支持 Python 3。

代码编辑器界面介绍

一个典型的 LeetCode 题目页面包含三个主要区域：

• 代码编辑区：您在这里编写解决问题的代码，默认会提供一个函数框架。
• 输入/输出区：这里会显示题目给出的示例输入和期望输出，以及您自定义的测试用例。
• 执行结果区：点击 "Run Code" 后，这里会显示代码的运行结果，包括执行时间、内存消耗以及是否通过测试用例。

Python 代码模板与结构

a. 标准模板

LeetCode 的 Python 代码通常在一个函数或类中实现，您只需要填充函数体或类的内部逻辑即可。

b. 函数签名要求您实现一个函数。"两数之和" 问题：

# 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那两个整数，并返回它们的数组下标。
# 你可以假设每种输入只会对应一个答案，数组中同一个元素在答案里不能重复出现。
# 你可以按任意顺序返回答案。
# 示例 1:
# 输入: nums = [2,7,11,15], target = 9
# 输出: [0,1]
# 解释: 因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
# 示例 2:
# 输入: nums = [3,2,4], target = 6
# 输出: [1,2]
# 示例 3:
# 输入: nums = [3,3], target = 6
# 输出: [0,1]

您的代码应该像这样：

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        # 在这里编写你的代码
        pass

正确的解法：

from typing import List # 需要导入 List 类型
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        # 使用一个哈希表（字典）来存储已经遍历过的数字及其索引
        num_map = {}
        for i, num in enumerate(nums):
            # 计算差值
            complement = target - num
            # 如果差值已经在哈希表中，说明找到了答案
            if complement in num_map:
                return [num_map[complement], i]
            # 如果没找到，就把当前数字和它的索引存入哈希表
            num_map[num] = i
        # 如果循环结束还没找到，理论上题目保证有解，所以这里可以返回空列表或抛出异常
        return []
# 注意：在实际提交时，只需要上面的 class Solution 部分。
# 下面的 if __name__ == "__main__": 部分是为了本地测试，LeetCode 运行时会忽略。
if __name__ == "__main__":
    # 本地测试代码
    sol = Solution()
    print(sol.twoSum([2, 7, 11, 15], 9))  # 预期输出: [0, 1]
    print(sol.twoSum([3, 2, 4], 6))      # 预期输出: [1, 2]

c. 类与构造函数如数据结构题）需要您实现一个类。

示例：设计一个栈

class MyStack:
    def __init__(self):
        # 初始化数据结构
        self.stack = []
    def push(self, x: int) -> None:
        # 将元素 x 压入栈顶
        self.stack.append(x)
    def pop(self) -> int:
        # 移除并返回栈顶元素
        return self.stack.pop()
    def top(self) -> int:
        # 返回栈顶元素
        return self.stack[-1]
    def empty(self) -> bool:
        # 如果栈为空，返回 true ，否则返回 false
        return not self.stack
# Your MyStack object will be instantiated and called as such:
# obj = MyStack()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.top()
# param_4 = obj.empty()

Pythonic 编程风格与技巧

在 LeetCode 上，简洁高效的代码往往更受欢迎，Python 的许多特性可以帮助您写出更优雅的代码。

a. 列表推导式

用于快速创建列表,比传统的 for 循环更简洁。

传统方式:

squares = []
for i in range(10):
    if i % 2 == 0:
        squares.append(i * i)

Pythonic 方式:

squares = [i * i for i in range(10) if i % 2 == 0]

b. 哈希集合/字典

这是 Python 中解决查找问题的利器，平均时间复杂度为 O(1)。

• set(): 用于存储不重复的元素，适合快速判断 in 关系。

  # 查找数组中是否有重复元素
  if len(nums) != len(set(nums)):
      return True

• dict(): 用于存储键值对，非常适合查找某个元素对应的附加信息（如下标）。

  # 如上面的 twoSum 解法
  num_map = {num: index for index, num in enumerate(nums)}

c. 模块导入

LeetCode 默认导入了 typing 模块，您可以安全使用 List, Dict, Optional 等类型注解。

from typing import List, Optional
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
        # ...
        pass

d. 切片

Python 的切片功能非常强大。

arr = [0, 1, 2, 3, 4, 5]
# 获取前三个元素
print(arr[:3])  # [0, 1, 2]
# 获取从索引 2 到末尾的元素
print(arr[2:])  # [2, 3, 4, 5]
# 获取从索引 1 到 4 的元素（不包括索引 4）
print(arr[1:4]) # [1, 2, 3]
# 反转数组
print(arr[::-1]) # [5, 4, 3, 2, 1, 0]

e. 排序

Python 的 sorted() 函数非常灵活。

nums = [3, 1, 4, 1, 5, 9, 2, 6]
# 默认升序
sorted_nums = sorted(nums)  # [1, 1, 2, 3, 4, 5, 6, 9]
# 按绝对值降序
sorted_nums_abs = sorted(nums, key=abs, reverse=True) # [9, 5, 6, 3, 4, 1, 1, 2]
# 对二维数组按第二列排序
matrix = [[1, 4], [3, 2], [2, 1]]
sorted_matrix = sorted(matrix, key=lambda x: x[1]) # [[2, 1], [3, 2], [1, 4]]

调试与测试

a. 使用 print() 打印中间结果

当您的代码运行失败时,最简单的调试方法就是添加 print() 语句来查看变量在某个时刻的值。

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        num_map = {}
        for i, num in enumerate(nums):
            complement = target - num
            print(f"Current num: {num}, Complement: {complement}, num_map: {num_map}")
            if complement in num_map:
                return [num_map[complement], i]
            num_map[num] = i
        return []

在 "Run Code" 后，您可以在执行结果区看到这些打印信息，帮助您理解代码的执行流程。

b. LeetCode 自带的测试功能

您可以在输入/输出区添加自定义测试用例，来验证您的代码是否能处理边界情况。

提交代码

当您通过 "Run Code" 测试后，如果确认代码逻辑正确，就可以点击右上角的 "Submit" 按钮。

• 通过：恭喜您！系统会显示您的代码在不同测试用例下的执行时间和内存消耗。
• 失败：系统会显示是哪个测试用例没有通过，您可以分析错误原因并修改代码。
• 超时：您的算法时间复杂度太高，需要优化，这是刷题中最常见的问题之一，通常需要思考更高效的算法（将暴力解法的 O(n²) 优化为 O(n) 或 O(n log n)）。

推荐资源与总结

• Python 官方文档: docs.python.org
• LeetCode 官方题解: 很多题目下都有官方或高赞的题解，是学习优秀代码的绝佳途径。
• 1. 先理解题意，明确输入输出和边界条件。
  2. 思考暴力解法，确保至少能通过部分测试用例。
  3. 优化算法，思考如何利用数据结构（哈希表、栈、队列、堆等）来降低时间复杂度。
  4. 用 Pythonic 的方式编写代码，力求简洁、高效、易读。
  5. 多练习，熟能生巧。

祝您刷题愉快,早日拿到心仪的 Offer！