ARTICLE · 1053757

2026网安习题大全(1)

发布时间：2026-09-21 22:55:48 最近访问：2026-09-21 22:55:48

2026网安习题大全(1)

关注公众号,發“11”获取更多学习资料,动态消息更新!

题目1：验证回文链表

问题描述：给定一个单链表的头节点 head，判断该链表是否为回文链表。要求时间复杂度 O(n)，空间复杂度 O(1)。

解题思路：使用快慢指针找到链表中点，反转后半部分链表，然后与前半部分逐一比较。比较完成后可将链表恢复原状（可选）。

Python 代码示例：

def isPalindrome(head):    if not head or not head.next:        return True    # 找中点    slow = fast = head    while fast and fast.next:        slow = slow.next        fast = fast.next.next    # 反转后半部分    prev = None    while slow:        nxt = slow.next        slow.next = prev        prev = slow        slow = nxt    # 比较前半部分和反转后的后半部分    left, right = head, prev    while right:        if left.val != right.val:            return False        left = left.next        right = right.next    return True

题目2：合并两个有序链表

问题描述：将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

解题思路：使用哑节点和尾指针，依次比较两个链表的当前节点，将较小者接入结果链表，最后接上剩余部分。

Python 代码示例：

def mergeTwoLists(l1, l2):    dummy = ListNode(0)    tail = dummy    while l1 and l2:        if l1.val <= l2.val:            tail.next = l1            l1 = l1.next        else:            tail.next = l2            l2 = l2.next        tail = tail.next    tail.next = l1 if l1 else l2    return dummy.next

题目3：被围绕的区域

问题描述：给定一个二维字符矩阵 board，包含 'X' 和 'O'。将被 'X' 围绕的 'O' 替换为 'X'。边界上的 'O' 以及与边界 'O' 相连的 'O' 不会被替换。

解题思路：先从边界上的 'O' 开始 DFS，将所有与边界相连的 'O' 标记为 '#'。然后遍历整个矩阵，将剩余的 'O' 改为 'X'，将 '#' 恢复为 'O'。

Python 代码示例：

def solve(board):    if not board:        return    rows, cols = len(board), len(board[0])    def dfs(r, c):        if r < 0 or r >= rows or c < 0 or c >= cols or board[r][c] != 'O':            return        board[r][c] = '#'        dfs(r + 1, c)        dfs(r - 1, c)        dfs(r, c + 1)        dfs(r, c - 1)    for r in range(rows):        dfs(r, 0)        dfs(r, cols - 1)    for c in range(cols):        dfs(0, c)        dfs(rows - 1, c)    for r in range(rows):        for c in range(cols):            if board[r][c] == 'O':                board[r][c] = 'X'            elif board[r][c] == '#':                board[r][c] = 'O'

题目4：子集

问题描述：给定一个不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。解集不能包含重复的子集。

解题思路：使用回溯法。从空集开始，每次选择是否将当前元素加入路径，递归处理下一个元素，当处理完所有元素时，将当前路径加入结果集。

Python 代码示例：

def subsets(nums):    result = []    def backtrack(start, path):        result.append(path[:])        for i in range(start, len(nums)):            path.append(nums[i])            backtrack(i + 1, path)            path.pop()    backtrack(0, [])    return result

题目5：用栈实现队列

问题描述：使用两个栈实现一个先入先出（FIFO）的队列。支持 push、pop、peek、empty 操作。

解题思路：使用两个栈：in_stack 负责入队，out_stack 负责出队。当需要出队或查看队首时，如果 out_stack 为空，则将 in_stack 中所有元素依次弹出并压入 out_stack，这样顺序就反转为先进先出。

Python 代码示例：

class MyQueue:    def __init__(self):        self.in_stack = []        self.out_stack = []    def push(self, x):        self.in_stack.append(x)    def pop(self):        self._move()        return self.out_stack.pop()    def peek(self):        self._move()        return self.out_stack[-1]    def empty(self):        return not self.in_stack and not self.out_stack    def _move(self):        if not self.out_stack:            while self.in_stack:                self.out_stack.append(self.in_stack.pop())

题目6：字符串中的第一个唯一字符

问题描述：给定一个字符串 s，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。

解题思路：先用哈希表统计每个字符出现的次数，再从左到右遍历字符串，找到第一个计数为 1 的字符，返回其索引。

Python 代码示例：

1
2
3
4
5
6
7
8
9
10
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

题目7：删除链表的倒数第 N 个节点

问题描述：给定一个链表，删除链表的倒数第 n 个节点，并返回链表的头节点。

解题思路：使用快慢指针。让快指针先走 n + 1 步，然后快慢指针同时移动，直到快指针到达链表末尾。此时慢指针指向待删除节点的前一个节点，修改其 next 指针即可。

Python 代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def removeNthFromEnd(head, n):    dummy = ListNode(0)    dummy.next = head    fast = slow = dummy    for _ in range(n + 1):        fast = fast.next    while fast:        fast = fast.next        slow = slow.next    slow.next = slow.next.next    return dummy.next

题目8：腐烂的橘子

问题描述：给定一个二维网格，每个单元格可以是 0（空）、1（新鲜橘子）或 2（腐烂橘子）。每分钟，腐烂橘子会使其上下左右相邻的新鲜橘子腐烂。返回直到没有新鲜橘子为止所经过的最小分钟数，如果不可能则返回 -1。

解题思路：使用多源 BFS。先将所有腐烂橘子入队，并统计新鲜橘子数量。每一轮 BFS 将当前队列中的所有腐烂橘子向外扩散，将新腐烂的橘子入队，分钟数加一。最后若仍有新鲜橘子则返回 -1。

Python 代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
from collections import dequedef orangesRotting(grid):    if not grid:        return 0    rows, cols = len(grid), len(grid[0])    queue = deque()    fresh = 0    for r in range(rows):        for c in range(cols):            if grid[r][c] == 2:                queue.append((r, c))            elif grid[r][c] == 1:                fresh += 1    minutes = 0    directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]    while queue and fresh > 0:        for _ in range(len(queue)):            r, c = queue.popleft()            for dr, dc in directions:                nr, nc = r + dr, c + dc                if 0 <= nr < rows and 0 <= nc < cols and grid[nr][nc] == 1:                    grid[nr][nc] = 2                    fresh -= 1                    queue.append((nr, nc))        minutes += 1    return minutes if fresh == 0 else -1

题目9：组合总和

问题描述：给定一个无重复元素的整数数组 candidates 和一个目标整数 target，找出 candidates 中所有可以使数字和为 target 的组合。candidates 中的数字可以无限制重复被选取。

解题思路：使用回溯法。递归时传入当前起始索引 start，每次可以选择当前元素并继续递归（允许重复选取），也可以跳过当前元素。当剩余目标为 0 时，将当前路径加入结果集；当剩余目标小于 0 时剪枝。

Python 代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def combinationSum(candidates, target):    result = []    def backtrack(start, path, remain):        if remain == 0:            result.append(path[:])            return        if remain < 0:            return        for i in range(start, len(candidates)):            path.append(candidates[i])            backtrack(i, path, remain - candidates[i])            path.pop()    backtrack(0, [], target)    return result

题目10：有效的括号

问题描述：给定一个只包括 '('、')'、'{'、'}'、'['、']' 的字符串 s，判断字符串是否有效。有效字符串需满足：左括号必须用相同类型的右括号闭合，且必须以正确的顺序闭合。

解题思路：使用栈。遍历字符串，遇到左括号时入栈；遇到右括号时，检查栈顶是否为对应的左括号。若是则弹出栈顶，否则返回 False。遍历结束后栈为空则有效。

Python 代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
def isValid(s):    stack = []    mapping = {')': '(', '}': '{', ']': '['}    for ch in s:        if ch in mapping:            if not stack or stack[-1] != mapping[ch]:                return False            stack.pop()        else:            stack.append(ch)    return not stack

关注公众号,获取更多学习资料,动态消息更新!

读者福利：知道你对网络安全感兴趣，便准备了这套黑客学习资料

关于网络安全技术储备

学好网络安全、渗透测试与黑客技术，不论是入行就业、接单副业、护网挖洞，还是提升个人网络攻防能力，都极具价值。但想要系统掌握专业的网安攻防技术，绝非盲目摸索就能学会，必须拥有一套科学完整的学习规划。最后给大家分享一套全套的网络安全攻防学习资料，助力每一位想入门网安、深耕黑客技术的小伙伴快速进阶、少走弯路！

一、网络安全所有方向的学习路线

刚开始接触网络安全与黑客技术，如果你没有梳理清楚完整的学习步骤、攻防进阶体系，盲目刷题、乱学工具，基本很难真正入门、掌握实战能力。这套资料整合了网络安全全领域学习路线，梳理出渗透测试、漏洞挖掘、内网渗透、红蓝对抗、代码审计、应急响应等各大核心领域的完整知识点汇总，从零搭建系统化的网安攻防知识体系。