面试简单的编程题｜高频真题解析与实战指南

在技术面试中，面试简单的编程题往往成为筛选候选人的关键环节。看似基础的题目，实则考察逻辑思维、边界处理、时间复杂度控制等核心能力。本页面系统梳理面试简单的编程题高频考点，提供面试简单的编程题的详细解题思路、多语言实现（Python / JavaScript）、复杂度分析及常见陷阱提醒，助你从容应对校招、社招技术面试。

我们关注的不仅是“做对题”，更是理解出题人意图、掌握通用解题范式。页面内容基于真实面试反馈整理，覆盖面试简单的编程题中字符串、数组、链表、树、排序等五大高频模块，每类题型均配以典型例题、多种解法对比、性能优化路径，确保知识结构完整、实用性强。

无论你是计算机专业应届生、转行程序员，还是准备跳槽的资深工程师，本指南均能帮助你快速定位薄弱环节，强化基础能力，提升面试简单的编程题应对效率与准确率。

典型误区与正确姿势对比

解题思路

使用双指针：左指针从头开始，右指针从尾开始，交换二者所指字符，向中间收缩，直至相遇。

易错点提醒

• 循环条件易写为 i < len(s)，应为 i < j
• Python中字符串不可变，需用list(s)转为列表再操作
• 注意边界：空数组、单字符数组

多语言实现

# Python 实现
def reverseString(s):
    i, j = 0, len(s) - 1
    while i < j:
        s[i], s[j] = s[j], s[i]
        i += 1
        j -= 1
    return s

# JavaScript 实现
function reverseString(s) {
  let i = 0, j = s.length - 1;
  while (i < j) {
    [s[i], s[j]] = [s[j], s[i]];
    i++;
    j--;
  }
  return s;
}

解题思路

两遍扫描：第一遍用哈希表统计各字符频次；第二遍遍历字符串，返回频次为1的字符索引。

优化思路

若用ASCII字符集（256种），可用长度256的数组替代哈希表，提升访问速度。

代码实现

# Python 实现（哈希表）
def firstUniqChar(s):
    count = {}
    for ch in s:
        count[ch] = count.get(ch, 0) + 1
    for i, ch in enumerate(s):
        if count[ch] == 1:
            return i
    return -1

# 优化版（ASCII数组）
def firstUniqChar_ascii(s):
    freq = [0] * 256
    for ch in s:
        freq[ord(ch)] += 1
    for i, ch in enumerate(s):
        if freq[ord(ch)] == 1:
            return i
    return -1

解题思路

使用栈模拟递归过程：遇到数字构建倍数，'['压栈当前结果和倍数，']'弹栈并拼接重复字符串。

关键步骤

1. 初始化 stack = []，curr_str = ''，curr_num = 0
2. 遍历字符：
   • 数字 → curr_num = curr_num * 10 + int(ch)
   • '[' → stack.append((curr_str, curr_num))，重置curr_str/curr_num
   • ']' → str_prev, num = stack.pop()，curr_str = str_prev + num * curr_str
   • 字母 → curr_str += ch

代码实现

# Python 实现
def decodeString(s):
    stack = []
    curr_str, curr_num = '', 0
    for ch in s:
        if ch.isdigit():
            curr_num = curr_num * 10 + int(ch)
        elif ch == '[':
            stack.append((curr_str, curr_num))
            curr_str, curr_num = '', 0
        elif ch == ']':
            prev_str, num = stack.pop()
            curr_str = prev_str + num * curr_str
        else:
            curr_str += ch
    return curr_str

解题思路

快慢双指针：slow指针指向当前可写入位置，fast遍历数组。当fast遇到非零值，写入slow位置并++slow；遍历结束后，slow之后位置全置0。

代码实现

# Python 实现
def moveZeroes(nums):
    slow = 0
    for fast in range(len(nums)):
        if nums[fast] != 0:
            nums[slow] = nums[fast]
            slow += 1
    while slow < len(nums):
        nums[slow] = 0
        slow += 1

进阶要求

“尽量减少操作次数” → 用交换替代覆盖：当nums[fast]≠0时，交换nums[slow]与nums[fast]，再slow++，避免后续多次写0。

解题思路

① 排序数组；② 固定第一个数nums[i]，用双指针在[i+1, end]找nums[l]+nums[r] = -nums[i]；③ 跳过重复值避免重复三元组。

关键技巧

• 排序后，当nums[i] > 0时可提前结束（后续更大）
• 跳过重复：while l < r and nums[l] == nums[l-1]: l += 1

代码实现

# Python 实现
def threeSum(nums):
    nums.sort()
    res = []
    for i in range(len(nums) - 2):
        if nums[i] > 0: break
        if i > 0 and nums[i] == nums[i-1]: continue
        l, r = i + 1, len(nums) - 1
        while l < r:
            s = nums[i] + nums[l] + nums[r]
            if s < 0:
                l += 1
            elif s > 0:
                r -= 1
            else:
                res.append([nums[i], nums[l], nums[r]])
                while l < r and nums[l] == nums[l+1]: l += 1
                while l < r and nums[r] == nums[r-1]: r -= 1
                l += 1
                r -= 1
    return res

解题思路

迭代法：用三个指针prev（前驱）、curr（当前）、next（后继）依次反转链接关系。

代码实现

# Python 实现
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
def reverseList(head):
    prev = None
    curr = head
    while curr:
        next_temp = curr.next  # 暂存后继
        curr.next = prev       # 反转指针
        prev = curr            # 移动prev
        curr = next_temp       # 移动curr
    return prev

递归法对比

递归更简洁但空间复杂度O(n)（调用栈），面试中可补充说明两种写法优劣。

解题思路

① 快慢指针找相遇点；② 相遇后，一指针从头、一从相遇点同步移动，再次相遇即为入环点。

数学原理

设链表头到入环点距离为a，入环点到相遇点为b，相遇点到入环点为c（环长=b+c）。快指针走a+nb+nc，慢指针走a+b → 2(a+b)=a+nb+nc → a = (n-1)(b+c) + c → 从头和相遇点同步走必在入环点相遇。

代码实现

# Python 实现
def detectCycle(head):
    slow = fast = head
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
        if slow == fast:
            # 找入环点
            slow2 = head
            while slow2 != slow:
                slow2 = slow2.next
                slow = slow.next
            return slow
    return None

解题思路

递归比较左右子树：左子树的左孩子 vs 右子树的右孩子，左子树的右孩子 vs 右子树的左孩子。

边界条件

• 两节点均空 → 对称
• 一空一非空 → 不对称
• 值不等 → 不对称

代码实现

# Python 实现
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
def isSymmetric(root):
    def isMirror(t1, t2):
        if not t1 and not t2: return True
        if not t1 or not t2: return False
        return (t1.val == t2.val) and isMirror(t1.left, t2.right) and isMirror(t1.right, t2.left)
    return isMirror(root, root)

迭代法扩展

用队列存储成对节点：每次出队两个节点比较，再将(left,right)、(right,left)入队。

递归解法

最大深度 = 1 + max(左子树深度, 右子树深度)

代码实现

# Python 实现
def maxDepth(root):
    if not root:
        return 0
    return 1 + max(maxDepth(root.left), maxDepth(root.right))

BFS层序遍历

用队列记录每层节点，每遍历一层depth++，队列空时结束。

关键细节

• 循环条件：left ≤ right（闭区间）或 left < right（左闭右开）
• 中点计算：mid = left + (right-left)//2 避免溢出
• 边界收缩：nums[mid] < target → left = mid + 1

代码实现

# Python 实现（闭区间）
def binarySearch(nums, target):
    left, right = 0, len(nums) - 1
    while left <= right:
        mid = left + (right - left) // 2
        if nums[mid] == target:
            return mid
        elif nums[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

扩展：查找第一个≥target的位置

当nums[mid] < target时收缩left，否则收缩right，最终left即为插入位置。

核心思想

分治：选基准→分区（小在左，大在右）→递归排序左右子数组。

分区实现（Lomuto）

# Python 分区函数
def partition(nums, low, high):
    pivot = nums[high]  # 选最后一个为基准
    i = low - 1
    for j in range(low, high):
        if nums[j] <= pivot:
            i += 1
            nums[i], nums[j] = nums[j], nums[i]
    nums[i+1], nums[high] = nums[high], nums[i+1]
    return i + 1

完整快速排序

# Python 实现
def quickSort(nums, low, high):
    if low < high:
        pi = partition(nums, low, high)
        quickSort(nums, low, pi-1)
        quickSort(nums, pi+1, high)

1. 面试流程标准化四步法

2. 高频踩坑点TOP5

• 索引越界：数组/字符串访问前检查长度
• 整数溢出：如求和用long long，JS中注意Number精度
• 空指针：链表/树操作前判空
• 重复计算：用缓存（字典/数组）存储中间结果
• 递归爆栈：大深度时改用迭代

3. 面试后复盘建议

• 记录题目、解法、卡点、改进点
• 整理错题本：标注考察点与最优解
• 每周重做2道旧题，强化肌肉记忆