伪代码编程完全指南
一、伪代码概述
1.1 什么是伪代码
伪代码(Pseudocode)是一种介于自然语言和编程语言之间的算法描述方法,用于表达程序逻辑和算法设计思路。它不依赖于任何特定的编程语言语法,而是使用简洁的、类似代码的结构化语言来描述计算过程。
核心特性:
| 特性 | 说明 |
|---|---|
| 语言无关 | 不依赖特定编程语言,任何程序员都能理解 |
| 可读性强 | 使用自然语言和结构化语法,接近人类思维 |
| 聚焦逻辑 | 忽略语法细节,专注于算法核心逻辑 |
| 不可执行 | 不是可运行代码,是设计/沟通工具 |
| 灵活表达 | 可根据需要调整抽象级别 |
| 易于转换 | 可以方便地转换为任意编程语言 |
1.2 伪代码的用途
| 分类 | 主要用途 | 说明 |
|---|---|---|
| 算法设计 | 快速验证思路 | 在正式编码前验证算法逻辑的正确性 |
| 分析复杂度 | 评估算法的时间/空间复杂度 | |
| 比较不同方案 | 对比多种算法或架构方案的优劣 | |
| 原型设计 | 快速构建逻辑原型,验证整体可行性 | |
| 技术文档 | API设计文档 | 描述接口的输入输出和调用逻辑 |
| 需求规格说明 | 将用户需求转化为结构化的技术描述 | |
| 系统架构文档 | 描述系统整体结构和核心处理流程 | |
| 接口定义 | 清晰定义模块间的调用关系和数据协议 | |
| 团队沟通 | 技术方案评审 | 团队成员讨论和评审技术方案时的统一表达 |
| 跨语言团队 | 不同编程语言背景的成员可以无障碍沟通 | |
| Code Review | 用伪代码描述核心逻辑,避免被语法细节干扰 | |
| 设计讨论 | 在白板或设计评审中快速描述思路 | |
| 教学演示 | 课堂讲解 | 教师讲解算法时使用,便于学生理解核心思想 |
| 教材编写 | 数据结构和算法教材的标准表达形式 | |
| 面试准备 | 求职者描述解题思路的规范方式 | |
| 在线教程 | 博客、视频等教学场景中清晰展示算法 |
原型设计的特殊价值:在正式编码前,用伪代码快速构建逻辑原型,可以提前发现设计缺陷,显著降低返工成本,同时帮助团队更准确地估算开发工作量和技术复杂度。
1.3 伪代码与其他表示方法的对比
| 方法 | 抽象级别 | 可执行性 | 学习成本 | 适用场景 |
|---|---|---|---|---|
| 伪代码 | 中-高 | 不可执行 | 低 | 算法设计、文档、教学 |
| 流程图 | 高 | 不可执行 | 低 | 流程展示、业务逻辑 |
| N-S图 | 高 | 不可执行 | 中 | 结构化程序设计 |
| UML活动图 | 高 | 不可执行 | 中 | 系统设计、需求分析 |
| 实际代码 | 低 | 可执行 | 高 | 生产环境、实现细节 |
| 自然语言 | 很高 | 不可执行 | 极低 | 需求描述、模糊说明 |
1.4 伪代码的抽象级别
PLAINTEXT
// ========== 高抽象级别(接近自然语言)==========
// 适合:需求文档、非技术人员的沟通
FUNCTION 处理用户订单
验证用户身份
检查库存是否充足
计算订单总价
创建订单记录
发送确认邮件
END FUNCTION
// ========== 中抽象级别(最常用)==========
// 适合:算法设计、技术文档、团队沟通
FUNCTION processOrder(userId, items)
user = DATABASE.findUser(userId)
IF user IS NULL THEN
RETURN ERROR "用户不存在"
END IF
FOR EACH item IN items DO
product = DATABASE.getProduct(item.id)
IF product.stock < item.quantity THEN
RETURN ERROR "库存不足"
END IF
NEXT
total = 0
FOR EACH item IN items DO
total = total + product.price * item.quantity
NEXT
order = DATABASE.createOrder(userId, items, total)
EMAIL.send(user.email, "订单确认", order)
RETURN order
END FUNCTION
// ========== 低抽象级别(接近代码)==========
// 适合:详细的实现说明、算法精确描述
FUNCTION processOrder(userId: INTEGER, items: ARRAY<OrderItem>): Order
user = DATABASE.findUser(userId)
IF user == NULL THEN
THROW UserNotFoundException
END IF
FOR i = 0 TO LENGTH(items) - 1 DO
product = DATABASE.getProduct(items[i].productId)
IF product.inventoryCount < items[i].quantity THEN
THROW InsufficientStockException
END IF
NEXT
totalPrice = 0.0
FOR i = 0 TO LENGTH(items) - 1 DO
totalPrice = totalPrice + items[i].unitPrice * items[i].quantity
NEXT
totalPrice = totalPrice * (1 - getDiscountRate(user))
totalPrice = totalPrice + calculateTax(totalPrice)
order = Order.create(user.id, items, totalPrice, "PENDING")
DATABASE.insertOrder(order)
EMAIL.sendOrderConfirmation(user.email, order)
RETURN order
END FUNCTION
二、伪代码基础语法
2.1 变量与数据类型
PLAINTEXT
// ========== 变量声明风格 ==========
// 风格1:使用 SET 关键字
SET name TO "John"
SET age TO 30
SET isActive TO TRUE
// 风格2:使用赋值符号
name = "John"
age = 30
isActive = TRUE
// 风格3:带类型标注
STRING name = "John"
INTEGER age = 30
BOOLEAN isActive = TRUE
// 风格4:声明与赋值分离
DECLARE name AS STRING
name = "John"
// ========== 基本数据类型 ==========
INTEGER count = 42 // 整数
FLOAT price = 19.99 // 浮点数
DOUBLE pi = 3.141592653589793 // 双精度浮点数
STRING message = "Hello, World!" // 字符串
BOOLEAN isValid = TRUE // 布尔值
CHARACTER grade = 'A' // 单个字符
NULL_VALUE = NULL // 空值
// ========== 复合数据类型 ==========
// 数组
ARRAY numbers = [1, 2, 3, 4, 5]
ARRAY fruits = ["apple", "banana", "cherry"]
ARRAY matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
// 关联数组 / 字典 / 映射
MAP person = {
"name": "Alice",
"age": 25,
"email": "alice@example.com",
"isActive": TRUE
}
// 集合
SET uniqueNumbers = {1, 2, 3, 4, 5}
SET tags = {"important", "urgent", "review"}
// 元组
TUPLE coordinate = (x, y)
TUPLE rgb = (255, 128, 0)
// 结构体/记录
RECORD Person
STRING name
INTEGER age
STRING email
END RECORD
// ========== 类型转换 ==========
strNumber = "123"
number = TO_INTEGER(strNumber) // 字符串转整数
strPi = TO_STRING(3.14159) // 数字转字符串
rounded = ROUND(3.7) // 四舍五入 -> 4
floored = FLOOR(3.7) // 向下取整 -> 3
ceiled = CEIL(3.2) // 向上取整 -> 4
// ========== 常量定义 ==========
CONSTANT PI = 3.141592653589793
CONSTANT MAX_RETRY = 3
CONSTANT API_BASE_URL = "https://api.example.com/v1"
CONSTANT DEFAULT_TIMEOUT = 30 // 单位:秒
2.2 运算符与表达式
PLAINTEXT
// ========== 算术运算符 ==========
result = a + b // 加法
result = a - b // 减法
result = a * b // 乘法
result = a / b // 除法(浮点)
result = a DIV b // 整除(整数除法)
result = a MOD b // 取余(模运算)
result = a ^ b // 幂运算(a的b次方)
result = -a // 取负
// ========== 比较运算符 ==========
result = a == b // 等于
result = a != b // 不等于
result = a < b // 小于
result = a <= b // 小于等于
result = a > b // 大于
result = a >= b // 大于等于
// ========== 逻辑运算符 ==========
result = a AND b // 逻辑与(短路求值)
result = a OR b // 逻辑或(短路求值)
result = NOT a // 逻辑非
// ========== 位运算符(低级)==========
result = a & b // 按位与
result = a | b // 按位或
result = a ^ b // 按位异或(注意与幂运算区分)
result = ~a // 按位取反
result = a << n // 左移n位
result = a >> n // 右移n位
// ========== 字符串运算符 ==========
result = str1 + str2 // 字符串拼接
result = CONCAT(str1, str2, str3) // 多字符串拼接
contains = "hello" IN "hello world" // 子串检查
length = LENGTH(str) // 字符串长度
// ========== 运算符优先级(从高到低)==========
// 1. () 括号
// 2. NOT, ~, - (取负) 一元运算符
// 3. ^ (幂运算) 幂运算
// 4. *, /, DIV, MOD 乘除运算
// 5. +, - 加减运算
// 6. <<, >> 位移运算
// 7. <, <=, >, >= 比较运算
// 8. ==, != 等值运算
// 9. AND 逻辑与
// 10. OR 逻辑或
2.3 控制结构
PLAINTEXT
// ========== 条件语句 ==========
// 单分支
IF condition THEN
// 条件为真时执行
END IF
// 双分支
IF condition THEN
// 条件为真时执行
ELSE
// 条件为假时执行
END IF
// 多分支
IF score >= 90 THEN
grade = "A"
ELSE IF score >= 80 THEN
grade = "B"
ELSE IF score >= 70 THEN
grade = "C"
ELSE IF score >= 60 THEN
grade = "D"
ELSE
grade = "F"
END IF
// 三元运算符
status = IF age >= 18 THEN "成年" ELSE "未成年"
// ========== SWITCH 分支 ==========
SWITCH day OF
CASE 1:
dayName = "Monday"
BREAK
CASE 2:
dayName = "Tuesday"
BREAK
CASE 3:
dayName = "Wednesday"
BREAK
CASE 4:
dayName = "Thursday"
BREAK
CASE 5:
dayName = "Friday"
BREAK
CASE 6:
dayName = "Saturday"
BREAK
CASE 7:
dayName = "Sunday"
BREAK
DEFAULT:
dayName = "Invalid"
END SWITCH
// ========== FOR 循环 ==========
// 计数循环
FOR i = 0 TO n - 1 DO
PRINT i
NEXT i
// 指定步长
FOR i = 0 TO 10 STEP 2 DO
PRINT i // 输出: 0, 2, 4, 6, 8, 10
NEXT i
// 倒序循环
FOR i = n - 1 DOWNTO 0 DO
PRINT i
NEXT i
// FOR EACH 遍历
FOR EACH item IN collection DO
PROCESS(item)
NEXT item
// 带索引遍历
FOR EACH (index, item) IN ENUMERATE(collection) DO
PRINT index, ":", item
NEXT
// ========== WHILE 循环 ==========
// 前置条件循环
WHILE condition DO
// 循环体
END WHILE
// 后置条件循环(至少执行一次)
DO
// 循环体
WHILE condition
// 无限循环(需要内部BREAK)
WHILE TRUE DO
// 循环体
IF exitCondition THEN
BREAK
END IF
END WHILE
// ========== 循环控制 ==========
// BREAK:退出循环
FOR i = 0 TO 100 DO
IF foundTarget THEN
BREAK
END IF
NEXT i
// CONTINUE:跳过本次迭代
FOR i = 0 TO 100 DO
IF i MOD 2 == 0 THEN
CONTINUE // 跳过偶数
END IF
PRINT i // 只打印奇数
NEXT i
// ========== 嵌套循环与标签 ==========
OUTER: FOR i = 0 TO rows - 1 DO
INNER: FOR j = 0 TO cols - 1 DO
IF matrix[i][j] == target THEN
BREAK OUTER // 跳出外层循环
END IF
NEXT j
NEXT i
2.4 函数定义与调用
PLAINTEXT
// ========== 函数定义语法 ==========
// 基本函数定义
FUNCTION functionName(param1, param2)
// 函数体
RETURN result
END FUNCTION
// 带类型标注的函数
FUNCTION add(a: INTEGER, b: INTEGER) -> INTEGER
RETURN a + b
END FUNCTION
// 无返回值函数(过程)
PROCEDURE printMessage(message: STRING)
PRINT message
END PROCEDURE
// ========== 参数类型 ==========
// 必需参数
FUNCTION greet(name)
RETURN "Hello, " + name + "!"
END FUNCTION
// 默认参数
FUNCTION createUser(name, role = "user", active = TRUE)
RETURN {name: name, role: role, active: active}
END FUNCTION
// 可变参数
FUNCTION sum(...numbers)
total = 0
FOR EACH num IN numbers DO
total = total + num
NEXT
RETURN total
END FUNCTION
// 命名参数
FUNCTION configure(host, port, timeout = 30, debug = FALSE)
// 调用时可以用命名参数
END FUNCTION
// 调用:configure(host="localhost", port=8080, debug=TRUE)
// ========== 参数传递方式 ==========
// 按值传递(基本类型):函数内修改不影响外部
// 按引用传递(对象/数组):函数内修改影响外部
FUNCTION modifyArray(arr)
arr[0] = 999 // 会影响外部数组
END FUNCTION
FUNCTION modifyValue(val)
val = 999 // 不会影响外部变量
END FUNCTION
// ========== 递归函数 ==========
FUNCTION factorial(n)
IF n <= 1 THEN
RETURN 1
END IF
RETURN n * factorial(n - 1)
END FUNCTION
// 尾递归优化
FUNCTION factorialTail(n, accumulator = 1)
IF n <= 1 THEN
RETURN accumulator
END IF
RETURN factorialTail(n - 1, n * accumulator)
END FUNCTION
// ========== 高阶函数 ==========
// 函数作为参数
FUNCTION applyOperation(arr, operation)
result = []
FOR EACH item IN arr DO
APPEND result, operation(item)
NEXT
RETURN result
END FUNCTION
// 函数作为返回值
FUNCTION makeMultiplier(factor)
RETURN FUNCTION(x)
RETURN x * factor
END FUNCTION
END FUNCTION
// ========== 闭包 ==========
FUNCTION createCounter()
count = 0
RETURN FUNCTION()
count = count + 1
RETURN count
END FUNCTION
END FUNCTION
三、数据结构操作
3.1 数组操作
PLAINTEXT
// ========== 创建数组 ==========
numbers = [1, 2, 3, 4, 5]
empty = []
zeros = ARRAY(10, 0) // 创建长度为10、初始值为0的数组
identity = ARRAY(3, ARRAY(3, 0)) // 3x3二维数组
// ========== 访问元素 ==========
first = numbers[0] // 第一个元素
last = numbers[LENGTH(numbers) - 1] // 最后一个元素
sub = numbers[1:4] // 切片:索引1到3 [2, 3, 4]
// ========== 修改元素 ==========
numbers[2] = 10 // 修改索引2的元素
numbers[0:2] = [99, 100] // 切片赋值
// ========== 添加/删除元素 ==========
APPEND numbers, 6 // 末尾添加 -> [1, 2, 3, 4, 5, 6]
INSERT numbers, 0, 0 // 在索引0处插入0 -> [0, 1, 2, 3, 4, 5, 6]
REMOVE numbers, 2 // 删除索引2的元素
POP numbers // 删除并返回末尾元素
POP_FRONT numbers // 删除并返回开头元素
// ========== 查找/排序 ==========
index = FIND(numbers, 3) // 查找元素3的索引
count = COUNT(numbers, 3) // 统计元素3出现的次数
SORT(numbers) // 升序排序
SORT(numbers, DESCENDING) // 降序排序
REVERSE(numbers) // 反转数组
// ========== 数组函数 ==========
length = LENGTH(numbers) // 数组长度
max = MAX(numbers) // 最大值
min = MIN(numbers) // 最小值
sum = SUM(numbers) // 求和
avg = AVERAGE(numbers) // 平均值
joined = JOIN(numbers, ",") // 用分隔符连接
merged = CONCAT(arr1, arr2) // 合并两个数组
// ========== 数组遍历模式 ==========
// 基本遍历
FOR i = 0 TO LENGTH(arr) - 1 DO
PROCESS(arr[i])
NEXT i
// 遍历并修改
FOR i = 0 TO LENGTH(arr) - 1 DO
arr[i] = arr[i] * 2
NEXT i
// 从后往前遍历(安全删除)
FOR i = LENGTH(arr) - 1 DOWNTO 0 DO
IF SHOULD_REMOVE(arr[i]) THEN
REMOVE arr, i
END IF
NEXT i
// 滑动窗口遍历
FOR i = 0 TO LENGTH(arr) - windowSize DO
window = arr[i : i + windowSize]
PROCESS(window)
NEXT i
3.2 栈与队列
PLAINTEXT
// ========== 栈(Stack):后进先出(LIFO)==========
// 使用数组模拟栈
stack = []
// 入栈(Push)
PUSH(stack, element)
// 或
APPEND stack, element
// 出栈(Pop)
element = POP(stack)
// 或
element = stack[LENGTH(stack) - 1]
REMOVE stack, LENGTH(stack) - 1
// 查看栈顶(Peek)
element = stack[LENGTH(stack) - 1]
// 检查是否为空
isEmpty = LENGTH(stack) == 0
// 栈的大小
size = LENGTH(stack)
// ========== 栈的典型应用:括号匹配 ==========
FUNCTION isValidParentheses(s)
stack = []
FOR EACH ch IN s DO
IF ch == '(' OR ch == '[' OR ch == '{' THEN
PUSH(stack, ch)
ELSE
IF LENGTH(stack) == 0 THEN
RETURN FALSE
END IF
top = POP(stack)
IF NOT MATCH(top, ch) THEN
RETURN FALSE
END IF
END IF
NEXT
RETURN LENGTH(stack) == 0
END FUNCTION
// ========== 队列(Queue):先进先出(FIFO)==========
// 使用数组模拟队列
queue = []
// 入队(Enqueue)
ENQUEUE(queue, element)
// 或
APPEND queue, element
// 出队(Dequeue)
element = DEQUEUE(queue)
// 或
element = queue[0]
REMOVE queue, 0
// 查看队首(Peek)
element = queue[0]
// 检查是否为空
isEmpty = LENGTH(queue) == 0
// ========== 双端队列(Deque)==========
// 两端都可以添加/删除
deque = []
PUSH_FRONT(deque, element) // 前端入队
PUSH_BACK(deque, element) // 后端入队
element = POP_FRONT(deque) // 前端出队
element = POP_BACK(deque) // 后端出队
// ========== 优先队列(Priority Queue)==========
// 使用堆实现
PQ = CREATE_PRIORITY_QUEUE() // 默认最小堆
INSERT(PQ, element, priority)
element = EXTRACT_MIN(PQ) // 取出优先级最高的元素
element = PEEK(PQ) // 查看优先级最高的元素
3.3 链表
PLAINTEXT
// ========== 单向链表节点定义 ==========
RECORD ListNode
value: ANY
next: ListNode OR NULL
END RECORD
// ========== 链表遍历 ==========
FUNCTION traverseList(head)
current = head
WHILE current != NULL DO
PROCESS(current.value)
current = current.next
END WHILE
END FUNCTION
// ========== 链表插入 ==========
FUNCTION insertAfter(node, newNode)
newNode.next = node.next
node.next = newNode
END FUNCTION
// ========== 链表删除 ==========
FUNCTION deleteAfter(node)
IF node.next != NULL THEN
node.next = node.next.next
END IF
END FUNCTION
// ========== 反转链表 ==========
FUNCTION reverseList(head)
prev = NULL
current = head
WHILE current != NULL DO
nextTemp = current.next
current.next = prev
prev = current
current = nextTemp
END WHILE
RETURN prev
END FUNCTION
// ========== 检测环(快慢指针)==========
FUNCTION hasCycle(head)
slow = head
fast = head
WHILE fast != NULL AND fast.next != NULL DO
slow = slow.next
fast = fast.next.next
IF slow == fast THEN
RETURN TRUE
END IF
END WHILE
RETURN FALSE
END FUNCTION
// ========== 双向链表节点定义 ==========
RECORD DoublyListNode
value: ANY
prev: DoublyListNode OR NULL
next: DoublyListNode OR NULL
END RECORD
3.4 树结构
PLAINTEXT
// ========== 二叉树节点定义 ==========
RECORD TreeNode
value: ANY
left: TreeNode OR NULL
right: TreeNode OR NULL
END RECORD
// ========== 二叉树遍历 ==========
// 前序遍历:根 -> 左 -> 右
FUNCTION preorderTraversal(root)
IF root == NULL THEN
RETURN
END IF
VISIT(root.value)
preorderTraversal(root.left)
preorderTraversal(root.right)
END FUNCTION
// 中序遍历:左 -> 根 -> 右
FUNCTION inorderTraversal(root)
IF root == NULL THEN
RETURN
END IF
inorderTraversal(root.left)
VISIT(root.value)
inorderTraversal(root.right)
END FUNCTION
// 后序遍历:左 -> 右 -> 根
FUNCTION postorderTraversal(root)
IF root == NULL THEN
RETURN
END IF
postorderTraversal(root.left)
postorderTraversal(root.right)
VISIT(root.value)
END FUNCTION
// 层序遍历(BFS)
FUNCTION levelOrderTraversal(root)
IF root == NULL THEN
RETURN
END IF
queue = [root]
WHILE LENGTH(queue) > 0 DO
node = DEQUEUE(queue)
VISIT(node.value)
IF node.left != NULL THEN
ENQUEUE(queue, node.left)
END IF
IF node.right != NULL THEN
ENQUEUE(queue, node.right)
END IF
END WHILE
END FUNCTION
// ========== 二叉搜索树(BST)==========
// 查找
FUNCTION bstSearch(root, target)
IF root == NULL OR root.value == target THEN
RETURN root
END IF
IF target < root.value THEN
RETURN bstSearch(root.left, target)
ELSE
RETURN bstSearch(root.right, target)
END IF
END FUNCTION
// 插入
FUNCTION bstInsert(root, value)
IF root == NULL THEN
RETURN NEW TreeNode(value)
END IF
IF value < root.value THEN
root.left = bstInsert(root.left, value)
ELSE IF value > root.value THEN
root.right = bstInsert(root.right, value)
END IF
RETURN root
END FUNCTION
// 查找最小值
FUNCTION bstFindMin(root)
current = root
WHILE current.left != NULL DO
current = current.left
END WHILE
RETURN current.value
END FUNCTION
// 查找最大值
FUNCTION bstFindMax(root)
current = root
WHILE current.right != NULL DO
current = current.right
END WHILE
RETURN current.value
END FUNCTION
// ========== 堆(Heap)==========
// 最大堆:父节点 >= 子节点
// 最小堆:父节点 <= 子节点
// 通常用数组实现,索引关系:
// 父节点索引 i: 左子节点 = 2*i + 1, 右子节点 = 2*i + 2
// 子节点索引 i: 父节点 = (i - 1) / 2
// 上浮操作(插入后调整)
FUNCTION heapifyUp(heap, index)
WHILE index > 0 DO
parent = (index - 1) / 2
IF heap[index] > heap[parent] THEN // 最大堆
SWAP(heap[index], heap[parent])
index = parent
ELSE
BREAK
END IF
END WHILE
END FUNCTION
// 下沉操作(删除堆顶后调整)
FUNCTION heapifyDown(heap, index, size)
WHILE TRUE DO
largest = index
left = 2 * index + 1
right = 2 * index + 2
IF left < size AND heap[left] > heap[largest] THEN
largest = left
END IF
IF right < size AND heap[right] > heap[largest] THEN
largest = right
END IF
IF largest != index THEN
SWAP(heap[index], heap[largest])
index = largest
ELSE
BREAK
END IF
END WHILE
END FUNCTION
3.5 图结构
PLAINTEXT
// ========== 图的表示方法 ==========
// 邻接矩阵
// graph[i][j] = 1 表示从 i 到 j 有边
// 适用于稠密图
// 邻接表
// graph[i] = [j1, j2, ...] 表示从 i 出发可以到达 j1, j2, ...
// 适用于稀疏图
adjacencyList = {
0: [1, 2],
1: [0, 2, 3],
2: [0, 1, 4],
3: [1, 4],
4: [2, 3]
}
// 带权重的邻接表
weightedGraph = {
0: [(1, 5), (2, 3)], // 到节点1权重5,到节点2权重3
1: [(0, 5), (2, 1), (3, 2)],
2: [(0, 3), (1, 1), (4, 4)],
3: [(1, 2), (4, 6)],
4: [(2, 4), (3, 6)]
}
// ========== 深度优先搜索(DFS)==========
FUNCTION dfs(graph, start)
visited = SET()
CALL dfsRecursive(graph, start, visited)
RETURN visited
END FUNCTION
FUNCTION dfsRecursive(graph, node, visited)
ADD visited, node
VISIT(node)
FOR EACH neighbor IN graph[node] DO
IF neighbor NOT IN visited THEN
dfsRecursive(graph, neighbor, visited)
END IF
NEXT
END FUNCTION
// 迭代版DFS(使用栈)
FUNCTION dfsIterative(graph, start)
visited = SET()
stack = [start]
WHILE LENGTH(stack) > 0 DO
node = POP(stack)
IF node NOT IN visited THEN
ADD visited, node
VISIT(node)
FOR EACH neighbor IN graph[node] DO
PUSH(stack, neighbor)
NEXT
END IF
END WHILE
RETURN visited
END FUNCTION
// ========== 广度优先搜索(BFS)==========
FUNCTION bfs(graph, start)
visited = SET()
queue = [start]
ADD visited, start
WHILE LENGTH(queue) > 0 DO
node = DEQUEUE(queue)
VISIT(node)
FOR EACH neighbor IN graph[node] DO
IF neighbor NOT IN visited THEN
ADD visited, neighbor
ENQUEUE(queue, neighbor)
END IF
NEXT
END WHILE
RETURN visited
END FUNCTION
// BFS 最短路径(无权图)
FUNCTION bfsShortestPath(graph, start, target)
visited = SET()
queue = [(start, [start])] // (节点, 路径)
ADD visited, start
WHILE LENGTH(queue) > 0 DO
(node, path) = DEQUEUE(queue)
IF node == target THEN
RETURN path
END IF
FOR EACH neighbor IN graph[node] DO
IF neighbor NOT IN visited THEN
ADD visited, neighbor
newPath = path + [neighbor]
ENQUEUE(queue, (neighbor, newPath))
END IF
NEXT
END WHILE
RETURN NULL // 未找到路径
END FUNCTION
// ========== 拓扑排序(Kahn算法)==========
FUNCTION topologicalSort(graph, n)
// 计算入度
inDegree = ARRAY(n, 0)
FOR EACH node IN graph DO
FOR EACH neighbor IN graph[node] DO
inDegree[neighbor] = inDegree[neighbor] + 1
NEXT
NEXT
// 入度为0的节点入队
queue = []
FOR i = 0 TO n - 1 DO
IF inDegree[i] == 0 THEN
ENQUEUE(queue, i)
END IF
NEXT
result = []
WHILE LENGTH(queue) > 0 DO
node = DEQUEUE(queue)
APPEND result, node
FOR EACH neighbor IN graph[node] DO
inDegree[neighbor] = inDegree[neighbor] - 1
IF inDegree[neighbor] == 0 THEN
ENQUEUE(queue, neighbor)
END IF
NEXT
END WHILE
IF LENGTH(result) != n THEN
RETURN ERROR "图中存在环"
END IF
RETURN result
END FUNCTION
3.6 哈希表
PLAINTEXT
// ========== 哈希表(Hash Table)基本操作 ==========
// 平均 O(1) 的插入、查找、删除
// 创建
hashTable = CREATE_HASH_TABLE()
// 插入/更新
SET hashTable[key] = value
// 或
PUT(hashTable, key, value)
// 查找
value = GET(hashTable, key)
// 或
value = hashTable[key]
// 检查键是否存在
exists = CONTAINS_KEY(hashTable, key)
// 删除
DELETE hashTable[key]
// 或
REMOVE(hashTable, key)
// 获取所有键
keys = KEYS(hashTable)
// 获取所有值
values = VALUES(hashTable)
// 遍历
FOR EACH (key, value) IN hashTable DO
PRINT key, ":", value
NEXT
// ========== 哈希表简单实现原理 ==========
FUNCTION simpleHash(key, tableSize)
hash = 0
FOR EACH ch IN TO_STRING(key) DO
hash = (hash * 31 + CHAR_CODE(ch)) MOD tableSize
NEXT
RETURN hash
END FUNCTION
// 链地址法解决冲突
RECORD HashNode
key: ANY
value: ANY
next: HashNode OR NULL
END RECORD
// ========== 哈希表应用:统计词频 ==========
FUNCTION wordFrequency(text)
wordCount = CREATE_HASH_TABLE()
words = SPLIT(text, " ")
FOR EACH word IN words DO
IF CONTAINS_KEY(wordCount, word) THEN
wordCount[word] = wordCount[word] + 1
ELSE
wordCount[word] = 1
END IF
NEXT
RETURN wordCount
END FUNCTION
// ========== 哈希表应用:两数之和 ==========
FUNCTION twoSum(nums, target)
seen = CREATE_HASH_TABLE()
FOR i = 0 TO LENGTH(nums) - 1 DO
complement = target - nums[i]
IF CONTAINS_KEY(seen, complement) THEN
RETURN [seen[complement], i]
END IF
seen[nums[i]] = i
NEXT
RETURN NULL
END FUNCTION
3.7 字符串操作
PLAINTEXT
// ========== 基本字符串操作 ==========
text = "Hello, World!"
// 长度
length = LENGTH(text) // 13
// 访问字符
firstChar = text[0] // 'H'
lastChar = text[LENGTH(text) - 1] // '!'
// 切片
substring = SUBSTRING(text, 0, 5) // "Hello"
substring = text[0:5] // "Hello"(切片语法)
// 查找
position = FIND(text, "World") // 7
position = FIND(text, "Python") // -1(未找到)
lastPosition = RFIND(text, "o") // 8(最后出现位置)
// 替换
newText = REPLACE(text, "World", "Python") // "Hello, Python!"
newText = REPLACE_ALL(text, "l", "L") // "HeLLo, WorLd!"
// 大小写转换
upper = UPPERCASE(text) // "HELLO, WORLD!"
lower = LOWERCASE(text) // "hello, world!"
// 分割与拼接
parts = SPLIT(text, ", ") // ["Hello", "World!"]
joined = JOIN(parts, " - ") // "Hello - World!"
// 去除空白
trimmed = TRIM(" hello ") // "hello"
leftTrimmed = LTRIM(" hello ") // "hello "
rightTrimmed = RTRIM(" hello ") // " hello"
// 判断
isAlpha = IS_ALPHA("Hello") // TRUE
isDigit = IS_DIGIT("12345") // TRUE
isAlnum = IS_ALNUM("Hello123") // TRUE
startsWith = STARTS_WITH(text, "He") // TRUE
endsWith = ENDS_WITH(text, "!") // TRUE
contains = CONTAINS(text, "World") // TRUE
// ========== 字符串匹配算法 ==========
// 暴力匹配
FUNCTION bruteForceMatch(text, pattern)
n = LENGTH(text)
m = LENGTH(pattern)
FOR i = 0 TO n - m DO
matched = TRUE
FOR j = 0 TO m - 1 DO
IF text[i + j] != pattern[j] THEN
matched = FALSE
BREAK
END IF
NEXT j
IF matched THEN
RETURN i
END IF
NEXT i
RETURN -1
END FUNCTION
// KMP算法(Knuth-Morris-Pratt)
FUNCTION computeLPS(pattern)
m = LENGTH(pattern)
lps = ARRAY(m, 0)
length = 0
i = 1
WHILE i < m DO
IF pattern[i] == pattern[length] THEN
length = length + 1
lps[i] = length
i = i + 1
ELSE
IF length != 0 THEN
length = lps[length - 1]
ELSE
lps[i] = 0
i = i + 1
END IF
END IF
END WHILE
RETURN lps
END FUNCTION
FUNCTION kmpSearch(text, pattern)
n = LENGTH(text)
m = LENGTH(pattern)
IF m == 0 THEN
RETURN 0
END IF
lps = computeLPS(pattern)
i = 0 // text索引
j = 0 // pattern索引
WHILE i < n DO
IF pattern[j] == text[i] THEN
i = i + 1
j = j + 1
END IF
IF j == m THEN
RETURN i - j // 找到匹配
ELSE IF i < n AND pattern[j] != text[i] THEN
IF j != 0 THEN
j = lps[j - 1]
ELSE
i = i + 1
END IF
END IF
END WHILE
RETURN -1
END FUNCTION
四、面向对象伪代码
4.1 类与对象
PLAINTEXT
// ========== 类定义 ==========
CLASS ClassName
// 属性(成员变量)
PUBLIC property1: TYPE
PRIVATE property2: TYPE
PROTECTED property3: TYPE
// 静态属性(类变量)
PUBLIC STATIC counter: INTEGER = 0
// 构造方法
CONSTRUCTOR(param1, param2)
SET self.property1 TO param1
SET self.property2 TO param2
ClassName.counter = ClassName.counter + 1
END CONSTRUCTOR
// 实例方法
PUBLIC METHOD methodName(param)
RETURN self.property1 + param
END METHOD
// 私有方法
PRIVATE METHOD helperMethod()
// 内部辅助逻辑
END METHOD
// 静态方法
PUBLIC STATIC METHOD getCount()
RETURN ClassName.counter
END METHOD
// Getter
PUBLIC METHOD getProperty1()
RETURN self.property1
END METHOD
// Setter
PUBLIC METHOD setProperty1(value)
// 可添加验证逻辑
IF value IS VALID THEN
SET self.property1 TO value
END IF
END METHOD
END CLASS
// ========== 创建和使用对象 ==========
// 创建对象
person = NEW Person("Alice", 25)
// 访问属性
name = person.name
// 调用方法
greeting = person.greet()
// 调用静态方法
count = Person.getCount()
// ========== 完整示例:银行账户类 ==========
CLASS BankAccount
PRIVATE accountNumber: STRING
PRIVATE balance: FLOAT
PRIVATE owner: STRING
PRIVATE isActive: BOOLEAN
STATIC totalAccounts: INTEGER = 0
STATIC MIN_BALANCE: FLOAT = 100.0
CONSTRUCTOR(owner, accountNumber, initialDeposit)
SET self.owner TO owner
SET self.accountNumber TO accountNumber
SET self.balance TO initialDeposit
SET self.isActive TO TRUE
BankAccount.totalAccounts = BankAccount.totalAccounts + 1
END CONSTRUCTOR
PUBLIC METHOD deposit(amount)
IF amount <= 0 THEN
THROW "存款金额必须大于0"
END IF
IF NOT self.isActive THEN
THROW "账户已冻结"
END IF
self.balance = self.balance + amount
LOG("存款: " + amount + ", 余额: " + self.balance)
RETURN self.balance
END METHOD
PUBLIC METHOD withdraw(amount)
IF amount <= 0 THEN
THROW "取款金额必须大于0"
END IF
IF NOT self.isActive THEN
THROW "账户已冻结"
END IF
IF self.balance - amount < BankAccount.MIN_BALANCE THEN
THROW "余额不足,至少保留 " + BankAccount.MIN_BALANCE
END IF
self.balance = self.balance - amount
LOG("取款: " + amount + ", 余额: " + self.balance)
RETURN self.balance
END METHOD
PUBLIC METHOD getBalance()
RETURN self.balance
END METHOD
PUBLIC METHOD freeze()
SET self.isActive TO FALSE
END METHOD
PUBLIC METHOD unfreeze()
SET self.isActive TO TRUE
END METHOD
END CLASS
4.2 继承与多态
PLAINTEXT
// ========== 继承 ==========
CLASS ChildClass EXTENDS ParentClass
CONSTRUCTOR(param1, param2, param3)
CALL SUPER(param1, param2) // 调用父类构造
SET self.param3 TO param3
END CONSTRUCTOR
// 重写父类方法
PUBLIC METHOD parentMethod()
// 可选:调用父类方法
CALL SUPER.parentMethod()
// 新增逻辑
END METHOD
// 新增方法
PUBLIC METHOD childMethod()
// 子类特有逻辑
END METHOD
END CLASS
// ========== 完整示例:形状继承体系 ==========
CLASS Shape
PROTECTED color: STRING
PROTECTED name: STRING
CONSTRUCTOR(name, color)
SET self.name TO name
SET self.color TO color
END CONSTRUCTOR
PUBLIC METHOD getArea()
// 抽象方法:子类必须实现
THROW "未实现"
END METHOD
PUBLIC METHOD getPerimeter()
// 抽象方法:子类必须实现
THROW "未实现"
END METHOD
PUBLIC METHOD describe()
RETURN self.name + " (颜色: " + self.color
+ ", 面积: " + self.getArea()
+ ", 周长: " + self.getPerimeter() + ")"
END METHOD
END CLASS
CLASS Circle EXTENDS Shape
PRIVATE radius: FLOAT
CONSTRUCTOR(color, radius)
CALL SUPER("圆形", color)
SET self.radius TO radius
END CONSTRUCTOR
PUBLIC METHOD getArea()
RETURN PI * self.radius * self.radius
END METHOD
PUBLIC METHOD getPerimeter()
RETURN 2 * PI * self.radius
END METHOD
END CLASS
CLASS Rectangle EXTENDS Shape
PRIVATE width: FLOAT
PRIVATE height: FLOAT
CONSTRUCTOR(color, width, height)
CALL SUPER("矩形", color)
SET self.width TO width
SET self.height TO height
END CONSTRUCTOR
PUBLIC METHOD getArea()
RETURN self.width * self.height
END METHOD
PUBLIC METHOD getPerimeter()
RETURN 2 * (self.width + self.height)
END METHOD
END CLASS
CLASS Triangle EXTENDS Shape
PRIVATE a: FLOAT
PRIVATE b: FLOAT
PRIVATE c: FLOAT
CONSTRUCTOR(color, a, b, c)
CALL SUPER("三角形", color)
SET self.a TO a
SET self.b TO b
SET self.c TO c
END CONSTRUCTOR
PUBLIC METHOD getArea()
// 海伦公式
s = (self.a + self.b + self.c) / 2
RETURN SQRT(s * (s - self.a) * (s - self.b) * (s - self.c))
END METHOD
PUBLIC METHOD getPerimeter()
RETURN self.a + self.b + self.c
END METHOD
END CLASS
// 多态:统一接口处理不同类型
FUNCTION printAllShapes(shapes)
FOR EACH shape IN shapes DO
PRINT shape.describe()
NEXT
END FUNCTION
4.3 接口与抽象类
PLAINTEXT
// ========== 接口定义 ==========
INTERFACE InterfaceName
METHOD method1(param1)
METHOD method2(param1, param2) -> RETURN_TYPE
PROPERTY propertyName: TYPE // 只读属性
END INTERFACE
// ========== 实现接口 ==========
CLASS ConcreteClass IMPLEMENTS InterfaceName
PUBLIC METHOD method1(param1)
// 实现接口方法
END METHOD
PUBLIC METHOD method2(param1, param2)
// 实现接口方法
RETURN result
END METHOD
END CLASS
// ========== 完整示例:支付系统 ==========
INTERFACE PaymentMethod
METHOD pay(amount: FLOAT) -> BOOLEAN
METHOD refund(transactionId: STRING, amount: FLOAT) -> BOOLEAN
METHOD getBalance() -> FLOAT
END INTERFACE
CLASS CreditCard IMPLEMENTS PaymentMethod
PRIVATE cardNumber: STRING
PRIVATE balance: FLOAT
CONSTRUCTOR(cardNumber, initialBalance)
SET self.cardNumber TO cardNumber
SET self.balance TO initialBalance
END CONSTRUCTOR
PUBLIC METHOD pay(amount)
IF amount <= 0 THEN
RETURN FALSE
END IF
IF self.balance < amount THEN
RETURN FALSE
END IF
self.balance = self.balance - amount
LOG("信用卡支付: " + amount)
RETURN TRUE
END METHOD
PUBLIC METHOD refund(transactionId, amount)
self.balance = self.balance + amount
LOG("信用卡退款: " + amount)
RETURN TRUE
END METHOD
PUBLIC METHOD getBalance()
RETURN self.balance
END METHOD
END CLASS
CLASS DigitalWallet IMPLEMENTS PaymentMethod
PRIVATE walletId: STRING
PRIVATE balance: FLOAT
CONSTRUCTOR(walletId, initialBalance)
SET self.walletId TO walletId
SET self.balance TO initialBalance
END CONSTRUCTOR
PUBLIC METHOD pay(amount)
IF amount <= 0 THEN
RETURN FALSE
END IF
IF self.balance < amount THEN
RETURN FALSE
END IF
self.balance = self.balance - amount
LOG("数字钱包支付: " + amount)
RETURN TRUE
END METHOD
PUBLIC METHOD refund(transactionId, amount)
self.balance = self.balance + amount
LOG("数字钱包退款: " + amount)
RETURN TRUE
END METHOD
PUBLIC METHOD getBalance()
RETURN self.balance
END METHOD
END CLASS
// 使用接口的统一处理
FUNCTION processPayment(method: PaymentMethod, amount: FLOAT)
IF method.pay(amount) THEN
PRINT "支付成功,余额: " + method.getBalance()
ELSE
PRINT "支付失败"
END IF
END FUNCTION
4.4 设计模式
PLAINTEXT
// ========== 单例模式(Singleton)==========
CLASS Database
PRIVATE STATIC instance: Database = NULL
PRIVATE CONSTRUCTOR()
// 私有构造,防止外部创建
END CONSTRUCTOR
PUBLIC STATIC METHOD getInstance()
IF Database.instance == NULL THEN
Database.instance = NEW Database()
END IF
RETURN Database.instance
END METHOD
PUBLIC METHOD query(sql)
// 执行查询
END METHOD
END CLASS
// ========== 工厂模式(Factory)==========
FUNCTION createShape(shapeType, ...params)
SWITCH shapeType OF
CASE "circle":
RETURN NEW Circle(params.color, params.radius)
CASE "rectangle":
RETURN NEW Rectangle(params.color, params.width, params.height)
CASE "triangle":
RETURN NEW Triangle(params.color, params.a, params.b, params.c)
DEFAULT:
THROW "未知形状类型: " + shapeType
END SWITCH
END FUNCTION
// ========== 观察者模式(Observer)==========
CLASS EventManager
PRIVATE listeners: MAP
CONSTRUCTOR()
SET self.listeners TO {}
END CONSTRUCTOR
PUBLIC METHOD subscribe(eventType, listener)
IF NOT CONTAINS_KEY(self.listeners, eventType) THEN
self.listeners[eventType] = []
END IF
APPEND self.listeners[eventType], listener
END METHOD
PUBLIC METHOD unsubscribe(eventType, listener)
IF CONTAINS_KEY(self.listeners, eventType) THEN
REMOVE self.listeners[eventType], listener
END IF
END METHOD
PUBLIC METHOD notify(eventType, data)
IF CONTAINS_KEY(self.listeners, eventType) THEN
FOR EACH listener IN self.listeners[eventType] DO
listener.update(data)
NEXT
END IF
END METHOD
END CLASS
// ========== 策略模式(Strategy)==========
INTERFACE SortStrategy
METHOD sort(arr)
END INTERFACE
CLASS BubbleSort IMPLEMENTS SortStrategy
PUBLIC METHOD sort(arr)
// 冒泡排序实现
END METHOD
END CLASS
CLASS QuickSort IMPLEMENTS SortStrategy
PUBLIC METHOD sort(arr)
// 快速排序实现
END METHOD
END CLASS
CLASS MergeSort IMPLEMENTS SortStrategy
PUBLIC METHOD sort(arr)
// 归并排序实现
END METHOD
END CLASS
CLASS Sorter
PRIVATE strategy: SortStrategy
CONSTRUCTOR(strategy)
SET self.strategy TO strategy
END CONSTRUCTOR
PUBLIC METHOD setStrategy(strategy)
SET self.strategy TO strategy
END METHOD
PUBLIC METHOD executeSort(arr)
RETURN self.strategy.sort(arr)
END METHOD
END CLASS
五、算法伪代码详解
5.1 排序算法
PLAINTEXT
// ========== 冒泡排序 O(n²) ==========
PROCEDURE bubbleSort(arr)
n = LENGTH(arr)
FOR i = 0 TO n - 2 DO
swapped = FALSE
FOR j = 0 TO n - 2 - i DO
IF arr[j] > arr[j + 1] THEN
SWAP(arr[j], arr[j + 1])
swapped = TRUE
END IF
NEXT j
IF NOT swapped THEN
BREAK // 已有序,提前退出
END IF
NEXT i
END PROCEDURE
// ========== 选择排序 O(n²) ==========
PROCEDURE selectionSort(arr)
n = LENGTH(arr)
FOR i = 0 TO n - 2 DO
minIndex = i
FOR j = i + 1 TO n - 1 DO
IF arr[j] < arr[minIndex] THEN
minIndex = j
END IF
NEXT j
IF minIndex != i THEN
SWAP(arr[i], arr[minIndex])
END IF
NEXT i
END PROCEDURE
// ========== 插入排序 O(n²) ==========
PROCEDURE insertionSort(arr)
n = LENGTH(arr)
FOR i = 1 TO n - 1 DO
key = arr[i]
j = i - 1
WHILE j >= 0 AND arr[j] > key DO
arr[j + 1] = arr[j]
j = j - 1
END WHILE
arr[j + 1] = key
NEXT i
END PROCEDURE
// ========== 归并排序 O(n log n) ==========
FUNCTION mergeSort(arr)
IF LENGTH(arr) <= 1 THEN
RETURN arr
END IF
mid = LENGTH(arr) / 2
left = mergeSort(arr[0:mid])
right = mergeSort(arr[mid:LENGTH(arr)])
RETURN merge(left, right)
END FUNCTION
FUNCTION merge(left, right)
result = []
i = 0
j = 0
WHILE i < LENGTH(left) AND j < LENGTH(right) DO
IF left[i] <= right[j] THEN
APPEND result, left[i]
i = i + 1
ELSE
APPEND result, right[j]
j = j + 1
END IF
END WHILE
// 添加剩余元素
WHILE i < LENGTH(left) DO
APPEND result, left[i]
i = i + 1
END WHILE
WHILE j < LENGTH(right) DO
APPEND result, right[j]
j = j + 1
END WHILE
RETURN result
END FUNCTION
// ========== 快速排序 O(n log n) ==========
FUNCTION quickSort(arr, low, high)
IF low < high THEN
pivotIndex = partition(arr, low, high)
quickSort(arr, low, pivotIndex - 1)
quickSort(arr, pivotIndex + 1, high)
END IF
RETURN arr
END FUNCTION
FUNCTION partition(arr, low, high)
pivot = arr[high]
i = low - 1
FOR j = low TO high - 1 DO
IF arr[j] <= pivot THEN
i = i + 1
SWAP(arr[i], arr[j])
END IF
NEXT j
SWAP(arr[i + 1], arr[high])
RETURN i + 1
END FUNCTION
// ========== 堆排序 O(n log n) ==========
PROCEDURE heapSort(arr)
n = LENGTH(arr)
// 构建最大堆
FOR i = n / 2 - 1 DOWNTO 0 DO
heapify(arr, n, i)
NEXT i
// 逐个提取堆顶元素
FOR i = n - 1 DOWNTO 1 DO
SWAP(arr[0], arr[i])
heapify(arr, i, 0)
NEXT i
END PROCEDURE
FUNCTION heapify(arr, size, rootIndex)
largest = rootIndex
left = 2 * rootIndex + 1
right = 2 * rootIndex + 2
IF left < size AND arr[left] > arr[largest] THEN
largest = left
END IF
IF right < size AND arr[right] > arr[largest] THEN
largest = right
END IF
IF largest != rootIndex THEN
SWAP(arr[rootIndex], arr[largest])
heapify(arr, size, largest)
END IF
END FUNCTION
// ========== 排序算法对比 ==========
// | 算法 | 最好 | 平均 | 最坏 | 空间 | 稳定 |
// |----------|---------|---------|---------|---------|------|
// | 冒泡排序 | O(n) | O(n²) | O(n²) | O(1) | 是 |
// | 选择排序 | O(n²) | O(n²) | O(n²) | O(1) | 否 |
// | 插入排序 | O(n) | O(n²) | O(n²) | O(1) | 是 |
// | 归并排序 | O(nlogn)| O(nlogn)| O(nlogn)| O(n) | 是 |
// | 快速排序 | O(nlogn)| O(nlogn)| O(n²) | O(logn) | 否 |
// | 堆排序 | O(nlogn)| O(nlogn)| O(nlogn)| O(1) | 否 |
5.2 搜索算法
PLAINTEXT
// ========== 线性搜索 O(n) ==========
FUNCTION linearSearch(arr, target)
FOR i = 0 TO LENGTH(arr) - 1 DO
IF arr[i] == target THEN
RETURN i
END IF
NEXT i
RETURN -1
END FUNCTION
// ========== 二分搜索 O(log n)(需要有序数组)==========
FUNCTION binarySearch(arr, target)
left = 0
right = LENGTH(arr) - 1
WHILE left <= right DO
mid = (left + right) / 2
IF arr[mid] == target THEN
RETURN mid
ELSE IF arr[mid] < target THEN
left = mid + 1
ELSE
right = mid - 1
END IF
END WHILE
RETURN -1
END FUNCTION
// 递归版二分搜索
FUNCTION binarySearchRecursive(arr, target, left, right)
IF left > right THEN
RETURN -1
END IF
mid = (left + right) / 2
IF arr[mid] == target THEN
RETURN mid
ELSE IF arr[mid] < target THEN
RETURN binarySearchRecursive(arr, target, mid + 1, right)
ELSE
RETURN binarySearchRecursive(arr, target, left, mid - 1)
END IF
END FUNCTION
// ========== 插值搜索 O(log log n) ==========
// 适用于均匀分布的有序数组
FUNCTION interpolationSearch(arr, target)
left = 0
right = LENGTH(arr) - 1
WHILE left <= right AND target >= arr[left] AND target <= arr[right] DO
IF left == right THEN
IF arr[left] == target THEN
RETURN left
END IF
RETURN -1
END IF
// 插值公式计算估计位置
pos = left + ((target - arr[left]) * (right - left))
/ (arr[right] - arr[left])
IF arr[pos] == target THEN
RETURN pos
ELSE IF arr[pos] < target THEN
left = pos + 1
ELSE
right = pos - 1
END IF
END WHILE
RETURN -1
END FUNCTION
5.3 动态规划
PLAINTEXT
// ========== 斐波那契数列(带备忘录)==========
FUNCTION fibonacci(n, memo = NULL)
IF memo == NULL THEN
memo = CREATE_HASH_TABLE()
END IF
IF n <= 1 THEN
RETURN n
END IF
IF CONTAINS_KEY(memo, n) THEN
RETURN memo[n]
END IF
memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo)
RETURN memo[n]
END FUNCTION
// 迭代版(自底向上)
FUNCTION fibonacciDP(n)
IF n <= 1 THEN
RETURN n
END IF
dp = ARRAY(n + 1)
dp[0] = 0
dp[1] = 1
FOR i = 2 TO n DO
dp[i] = dp[i - 1] + dp[i - 2]
NEXT i
RETURN dp[n]
END FUNCTION
// 空间优化版
FUNCTION fibonacciOptimized(n)
IF n <= 1 THEN
RETURN n
END IF
prev2 = 0
prev1 = 1
FOR i = 2 TO n DO
current = prev1 + prev2
prev2 = prev1
prev1 = current
NEXT i
RETURN prev1
END FUNCTION
// ========== 背包问题(0/1 Knapsack)==========
FUNCTION knapsack(weights, values, capacity)
n = LENGTH(weights)
// dp[i][w] = 前i个物品,容量为w时的最大价值
dp = ARRAY(n + 1, ARRAY(capacity + 1, 0))
FOR i = 1 TO n DO
FOR w = 0 TO capacity DO
IF weights[i - 1] <= w THEN
// 选或不选当前物品
dp[i][w] = MAX(
values[i - 1] + dp[i - 1][w - weights[i - 1]],
dp[i - 1][w]
)
ELSE
dp[i][w] = dp[i - 1][w]
END IF
NEXT w
NEXT i
RETURN dp[n][capacity]
END FUNCTION
// 空间优化版(一维数组)
FUNCTION knapsackOptimized(weights, values, capacity)
n = LENGTH(weights)
dp = ARRAY(capacity + 1, 0)
FOR i = 0 TO n - 1 DO
FOR w = capacity DOWNTO weights[i] DO
dp[w] = MAX(dp[w], values[i] + dp[w - weights[i]])
NEXT w
NEXT i
RETURN dp[capacity]
END FUNCTION
// ========== 最长公共子序列(LCS)==========
FUNCTION LCS(text1, text2)
m = LENGTH(text1)
n = LENGTH(text2)
dp = ARRAY(m + 1, ARRAY(n + 1, 0))
FOR i = 1 TO m DO
FOR j = 1 TO n DO
IF text1[i - 1] == text2[j - 1] THEN
dp[i][j] = dp[i - 1][j - 1] + 1
ELSE
dp[i][j] = MAX(dp[i - 1][j], dp[i][j - 1])
END IF
NEXT j
NEXT i
// 回溯构造LCS
lcs = []
i = m
j = n
WHILE i > 0 AND j > 0 DO
IF text1[i - 1] == text2[j - 1] THEN
PUSH_FRONT(lcs, text1[i - 1])
i = i - 1
j = j - 1
ELSE IF dp[i - 1][j] > dp[i][j - 1] THEN
i = i - 1
ELSE
j = j - 1
END IF
END WHILE
RETURN (dp[m][n], lcs)
END FUNCTION
// ========== 最长递增子序列(LIS)==========
FUNCTION LIS(nums)
n = LENGTH(nums)
IF n == 0 THEN
RETURN 0
END IF
dp = ARRAY(n, 1) // dp[i] = 以nums[i]结尾的LIS长度
FOR i = 1 TO n - 1 DO
FOR j = 0 TO i - 1 DO
IF nums[i] > nums[j] THEN
dp[i] = MAX(dp[i], dp[j] + 1)
END IF
NEXT j
NEXT i
RETURN MAX(dp)
END FUNCTION
// 二分优化版 O(n log n)
FUNCTION LISOptimized(nums)
tails = [] // tails[i] = 长度为i+1的LIS的最小结尾元素
FOR EACH num IN nums DO
left = 0
right = LENGTH(tails)
WHILE left < right DO
mid = (left + right) / 2
IF tails[mid] < num THEN
left = mid + 1
ELSE
right = mid
END IF
END WHILE
IF left == LENGTH(tails) THEN
APPEND tails, num
ELSE
tails[left] = num
END IF
NEXT
RETURN LENGTH(tails)
END FUNCTION
5.4 图算法
PLAINTEXT
// ========== Dijkstra 最短路径算法 ==========
FUNCTION dijkstra(graph, start)
// graph: 邻接表,graph[node] = [(neighbor, weight), ...]
n = LENGTH(graph)
distances = CREATE_HASH_TABLE()
previous = CREATE_HASH_TABLE()
unvisited = CREATE_PRIORITY_QUEUE()
// 初始化
FOR EACH node IN graph DO
distances[node] = INFINITY
previous[node] = NULL
NEXT
distances[start] = 0
INSERT(unvisited, start, 0)
WHILE NOT IS_EMPTY(unvisited) DO
current = EXTRACT_MIN(unvisited)
FOR EACH (neighbor, weight) IN graph[current] DO
newDistance = distances[current] + weight
IF newDistance < distances[neighbor] THEN
distances[neighbor] = newDistance
previous[neighbor] = current
INSERT(unvisited, neighbor, newDistance)
END IF
NEXT
END WHILE
RETURN (distances, previous)
END FUNCTION
// 重建最短路径
FUNCTION reconstructPath(previous, start, target)
path = []
current = target
WHILE current != NULL DO
PUSH_FRONT(path, current)
current = previous[current]
END WHILE
IF path[0] == start THEN
RETURN path
ELSE
RETURN NULL // 不可达
END IF
END FUNCTION
// ========== Bellman-Ford 算法 ==========
// 可以处理负权边,检测负权环
FUNCTION bellmanFord(graph, start, n)
// graph: 边列表 [(from, to, weight), ...]
distances = ARRAY(n, INFINITY)
distances[start] = 0
// 松弛 n-1 轮
FOR i = 1 TO n - 1 DO
FOR EACH (from, to, weight) IN graph DO
IF distances[from] != INFINITY
AND distances[from] + weight < distances[to] THEN
distances[to] = distances[from] + weight
END IF
NEXT
NEXT i
// 检测负权环
FOR EACH (from, to, weight) IN graph DO
IF distances[from] != INFINITY
AND distances[from] + weight < distances[to] THEN
RETURN ERROR "图中存在负权环"
END IF
NEXT
RETURN distances
END FUNCTION
// ========== Floyd-Warshall 全源最短路径 ==========
FUNCTION floydWarshall(graph, n)
// graph: 邻接矩阵,graph[i][j] = 权重,INFINITY表示无边
dist = COPY(graph)
FOR k = 0 TO n - 1 DO
FOR i = 0 TO n - 1 DO
FOR j = 0 TO n - 1 DO
IF dist[i][k] != INFINITY AND dist[k][j] != INFINITY
AND dist[i][k] + dist[k][j] < dist[i][j] THEN
dist[i][j] = dist[i][k] + dist[k][j]
END IF
NEXT j
NEXT i
NEXT k
RETURN dist
END FUNCTION
// ========== 最小生成树 - Prim 算法 ==========
FUNCTION primMST(graph, start)
n = LENGTH(graph)
visited = SET()
mstEdges = []
totalWeight = 0
pq = CREATE_PRIORITY_QUEUE()
ADD visited, start
FOR EACH (neighbor, weight) IN graph[start] DO
INSERT(pq, (start, neighbor, weight), weight)
NEXT
WHILE LENGTH(visited) < n AND NOT IS_EMPTY(pq) DO
(from, to, weight) = EXTRACT_MIN(pq)
IF to IN visited THEN
CONTINUE
END IF
ADD visited, to
APPEND mstEdges, (from, to, weight)
totalWeight = totalWeight + weight
FOR EACH (neighbor, w) IN graph[to] DO
IF neighbor NOT IN visited THEN
INSERT(pq, (to, neighbor, w), w)
END IF
NEXT
END WHILE
RETURN (mstEdges, totalWeight)
END FUNCTION
// ========== 最小生成树 - Kruskal 算法 ==========
FUNCTION kruskalMST(edges, n)
// edges: [(from, to, weight), ...]
SORT(edges, BY weight) // 按权重升序排序
parent = ARRAY(n)
rank = ARRAY(n, 0)
mstEdges = []
totalWeight = 0
// 初始化并查集
FOR i = 0 TO n - 1 DO
parent[i] = i
NEXT i
FOR EACH (from, to, weight) IN edges DO
IF find(parent, from) != find(parent, to) THEN
union(parent, rank, from, to)
APPEND mstEdges, (from, to, weight)
totalWeight = totalWeight + weight
END IF
IF LENGTH(mstEdges) == n - 1 THEN
BREAK
END IF
NEXT
RETURN (mstEdges, totalWeight)
END FUNCTION
// 并查集 - 查找
FUNCTION find(parent, x)
IF parent[x] != x THEN
parent[x] = find(parent, parent[x]) // 路径压缩
END IF
RETURN parent[x]
END FUNCTION
// 并查集 - 合并
PROCEDURE union(parent, rank, x, y)
rootX = find(parent, x)
rootY = find(parent, y)
IF rootX == rootY THEN
RETURN
END IF
IF rank[rootX] < rank[rootY] THEN
parent[rootX] = rootY
ELSE IF rank[rootX] > rank[rootY] THEN
parent[rootY] = rootX
ELSE
parent[rootY] = rootX
rank[rootX] = rank[rootX] + 1
END IF
END PROCEDURE
六、复杂度分析
6.1 时间复杂度
PLAINTEXT
// ========== 大O表示法 ==========
// O(1) 常数时间 - 数组访问、哈希表查找
// O(log n) 对数时间 - 二分搜索、平衡树操作
// O(n) 线性时间 - 遍历数组、线性搜索
// O(n log n) 线性对数时间 - 归并排序、快速排序(平均)
// O(n²) 平方时间 - 冒泡排序、嵌套循环
// O(n³) 立方时间 - Floyd-Warshall、三重循环
// O(2ⁿ) 指数时间 - 递归斐波那契、子集枚举
// O(n!) 阶乘时间 - 旅行商问题暴力解
// ========== 常见代码的时间复杂度 ==========
// O(1) - 常数时间
FUNCTION constantTime(arr)
RETURN arr[0]
END FUNCTION
// O(n) - 线性时间
FUNCTION linearTime(arr)
FOR i = 0 TO LENGTH(arr) - 1 DO
PROCESS(arr[i])
NEXT i
END FUNCTION
// O(n²) - 平方时间
FUNCTION quadraticTime(arr)
n = LENGTH(arr)
FOR i = 0 TO n - 1 DO
FOR j = 0 TO n - 1 DO
PROCESS(arr[i], arr[j])
NEXT j
NEXT i
END FUNCTION
// O(log n) - 二分搜索
FUNCTION logarithmicTime(arr, target)
left = 0
right = LENGTH(arr) - 1
WHILE left <= right DO
mid = (left + right) / 2
IF arr[mid] == target THEN
RETURN mid
ELSE IF arr[mid] < target THEN
left = mid + 1
ELSE
right = mid - 1
END IF
END WHILE
RETURN -1
END FUNCTION
// O(n log n) - 归并排序
FUNCTION nLogNTime(arr)
// 归并排序、快速排序等
END FUNCTION
// ========== 复杂度分析技巧 ==========
// 1. 顺序执行:复杂度相加,取最大值
// O(n) + O(n²) = O(n²)
//
// 2. 嵌套循环:复杂度相乘
// O(n) * O(n) = O(n²)
//
// 3. 条件分支:取最坏情况
// IF condition THEN O(n) ELSE O(n²) -> O(n²)
//
// 4. 递归:使用递推公式或主定理
// T(n) = 2T(n/2) + O(n) -> O(n log n)
6.2 空间复杂度
PLAINTEXT
// ========== 空间复杂度分析 ==========
// O(1) - 常数空间:只使用固定数量的变量
FUNCTION constantSpace(n)
sum = 0
FOR i = 0 TO n - 1 DO
sum = sum + i
NEXT i
RETURN sum
END FUNCTION
// O(n) - 线性空间:创建与输入大小成正比的数组
FUNCTION linearSpace(arr)
n = LENGTH(arr)
result = ARRAY(n) // O(n) 空间
FOR i = 0 TO n - 1 DO
result[i] = arr[i] * 2
NEXT i
RETURN result
END FUNCTION
// O(n²) - 平方空间:创建二维数组
FUNCTION quadraticSpace(n)
matrix = ARRAY(n, ARRAY(n, 0)) // O(n²) 空间
// ...
RETURN matrix
END FUNCTION
// 递归空间复杂度 = 递归深度 * 每层空间
// 递归斐波那契:O(n) 调用栈深度
// 归并排序:O(n) 辅助数组 + O(log n) 调用栈 = O(n)
// 快速排序:O(log n) 调用栈(平均)
七、实战案例
7.1 用户注册与登录
PLAINTEXT
/**
* 用户注册流程
*
* @param username 用户名(3-20字符,字母数字下划线)
* @param email 邮箱地址
* @param password 密码(最少8字符,需包含大小写字母和数字)
* @return 注册结果
*/
FUNCTION register(username, email, password)
// 1. 参数验证
IF LENGTH(username) < 3 OR LENGTH(username) > 20 THEN
RETURN ERROR "用户名长度需在3-20个字符之间"
END IF
IF NOT MATCH(username, "^[a-zA-Z0-9_]+$") THEN
RETURN ERROR "用户名只能包含字母、数字和下划线"
END IF
IF NOT MATCH(email, "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$") THEN
RETURN ERROR "邮箱格式不正确"
END IF
IF LENGTH(password) < 8 THEN
RETURN ERROR "密码长度不能少于8个字符"
END IF
IF NOT (CONTAINS_UPPERCASE(password)
AND CONTAINS_LOWERCASE(password)
AND CONTAINS_DIGIT(password)) THEN
RETURN ERROR "密码需包含大小写字母和数字"
END IF
// 2. 检查用户名是否已存在
existingUser = DATABASE.findUserByUsername(username)
IF existingUser != NULL THEN
RETURN ERROR "用户名已被注册"
END IF
// 3. 检查邮箱是否已注册
existingEmail = DATABASE.findUserByEmail(email)
IF existingEmail != NULL THEN
RETURN ERROR "邮箱已被注册"
END IF
// 4. 密码哈希
salt = GENERATE_RANDOM_SALT(16)
hashedPassword = HASH(password + salt, "SHA-256")
// 5. 创建用户
user = {
username: username,
email: email,
passwordHash: hashedPassword,
salt: salt,
createdAt: CURRENT_TIMESTAMP(),
isActive: FALSE,
emailVerified: FALSE
}
DATABASE.insertUser(user)
// 6. 发送验证邮件
verificationToken = GENERATE_TOKEN()
CACHE.store("email_verify:" + verificationToken, user.id, EXPIRE=24*3600)
EMAIL.send(email, "请验证您的邮箱",
"点击以下链接验证邮箱: https://example.com/verify?token=" + verificationToken)
RETURN {
success: TRUE,
message: "注册成功,请检查邮箱完成验证",
userId: user.id
}
END FUNCTION
/**
* 用户登录流程
*
* @param username 用户名或邮箱
* @param password 密码
* @return 登录结果(包含JWT Token)
*/
FUNCTION login(username, password)
// 1. 查找用户
user = DATABASE.findUserByUsername(username)
IF user == NULL THEN
user = DATABASE.findUserByEmail(username)
END IF
IF user == NULL THEN
RETURN ERROR "用户名或密码错误"
END IF
// 2. 检查账户状态
IF NOT user.isActive THEN
RETURN ERROR "账户已被禁用"
END IF
// 3. 检查登录尝试次数
attempts = CACHE.get("login_attempts:" + user.id)
IF attempts >= 5 THEN
RETURN ERROR "登录尝试次数过多,请15分钟后再试"
END IF
// 4. 验证密码
hashedInput = HASH(password + user.salt, "SHA-256")
IF hashedInput != user.passwordHash THEN
CACHE.increment("login_attempts:" + user.id, EXPIRE=900)
RETURN ERROR "用户名或密码错误"
END IF
// 5. 清除登录尝试次数
CACHE.delete("login_attempts:" + user.id)
// 6. 生成Token
accessToken = GENERATE_JWT({
userId: user.id,
username: user.username,
role: user.role,
exp: CURRENT_TIMESTAMP() + 3600 // 1小时过期
})
refreshToken = GENERATE_REFRESH_TOKEN()
// 7. 更新最后登录时间
DATABASE.updateLastLogin(user.id, CURRENT_TIMESTAMP())
// 8. 记录登录日志
LOG("用户 " + user.username + " 登录成功")
RETURN {
success: TRUE,
accessToken: accessToken,
refreshToken: refreshToken,
user: {
id: user.id,
username: user.username,
email: user.email,
role: user.role
}
}
END FUNCTION
7.2 分页查询
PLAINTEXT
/**
* 分页查询
*
* @param table 表名
* @param conditions 查询条件
* @param orderBy 排序字段
* @param page 页码(从1开始)
* @param pageSize 每页数量
* @return 分页结果
*/
FUNCTION paginatedQuery(table, conditions, orderBy, page, pageSize)
// 参数校验
IF page < 1 THEN
page = 1
END IF
IF pageSize < 1 THEN
pageSize = 10
END IF
IF pageSize > 100 THEN
pageSize = 100 // 限制最大每页数量
END IF
// 计算总数
totalCount = DATABASE.count(table, conditions)
// 计算总页数
totalPages = CEIL(totalCount / pageSize)
// 计算偏移量
offset = (page - 1) * pageSize
// 查询数据
data = DATABASE.query(
table,
conditions,
orderBy,
LIMIT=pageSize,
OFFSET=offset
)
// 返回结果
RETURN {
data: data,
pagination: {
page: page,
pageSize: pageSize,
totalCount: totalCount,
totalPages: totalPages,
hasNext: page < totalPages,
hasPrev: page > 1
}
}
END FUNCTION
7.3 LRU缓存
PLAINTEXT
/**
* LRU(最近最少使用)缓存
*
* 使用哈希表 + 双向链表实现 O(1) 的 get/put 操作
*/
CLASS LRUCache
PRIVATE capacity: INTEGER
PRIVATE cache: MAP
PRIVATE head: DoublyListNode
PRIVATE tail: DoublyListNode
CONSTRUCTOR(capacity)
SET self.capacity TO capacity
SET self.cache TO {}
// 创建哨兵节点
SET self.head TO NEW DoublyListNode(0, 0)
SET self.tail TO NEW DoublyListNode(0, 0)
self.head.next = self.tail
self.tail.prev = self.head
END CONSTRUCTOR
PUBLIC METHOD get(key)
IF NOT CONTAINS_KEY(self.cache, key) THEN
RETURN -1
END IF
node = self.cache[key]
CALL self.moveToFront(node)
RETURN node.value
END METHOD
PUBLIC METHOD put(key, value)
IF CONTAINS_KEY(self.cache, key) THEN
node = self.cache[key]
node.value = value
CALL self.moveToFront(node)
ELSE
newNode = NEW DoublyListNode(key, value)
self.cache[key] = newNode
CALL self.addToFront(newNode)
IF LENGTH(self.cache) > self.capacity THEN
// 删除最久未使用的节点
lru = self.tail.prev
CALL self.removeNode(lru)
DELETE self.cache[lru.key]
END IF
END IF
END METHOD
PRIVATE METHOD addToFront(node)
node.next = self.head.next
node.prev = self.head
self.head.next.prev = node
self.head.next = node
END METHOD
PRIVATE METHOD removeNode(node)
node.prev.next = node.next
node.next.prev = node.prev
END METHOD
PRIVATE METHOD moveToFront(node)
CALL self.removeNode(node)
CALL self.addToFront(node)
END METHOD
END CLASS
八、伪代码编写规范
8.1 命名规范
PLAINTEXT
// ========== 变量命名 ==========
// 使用有意义的名称,避免单字母(循环变量除外)
// 推荐:驼峰式或下划线式
userName = "Alice" // 驼峰式
user_name = "Alice" // 下划线式
maxRetryCount = 3
isValid = TRUE
// 循环变量可以使用简短名称
FOR i = 0 TO n - 1 DO
FOR j = 0 TO m - 1 DO
// i, j 是约定俗成的循环变量
NEXT j
NEXT i
// ========== 常量命名 ==========
// 全大写,下划线分隔
MAX_SIZE = 100
API_BASE_URL = "https://api.example.com"
DEFAULT_TIMEOUT = 30
// ========== 函数命名 ==========
// 使用动词开头,描述具体操作
FUNCTION getUserById(id) ...
FUNCTION calculateTotalPrice(items) ...
FUNCTION isValidEmail(email) ...
FUNCTION sendNotification(user, message) ...
// 布尔函数使用 is/has/can/should 开头
FUNCTION isLoggedIn() ...
FUNCTION hasPermission(user, resource) ...
FUNCTION canAccess(user, file) ...
// ========== 类命名 ==========
// 使用名词,首字母大写
CLASS User
CLASS OrderService
CLASS DatabaseConnection
CLASS PaymentProcessor
8.2 注释规范
PLAINTEXT
// ========== 单行注释 ==========
// 解释单行逻辑
count = 0 // 初始化计数器
// ========== 多行注释 ==========
/*
* 多行注释
* 用于解释复杂的逻辑块
* 或提供背景信息
*/
// ========== 文档注释 ==========
/**
* 计算两个数的最大公约数(欧几里得算法)
*
* 算法思路:
* 1. 用较大数除以较小数
* 2. 将较小数作为新的较大数,余数作为新的较小数
* 3. 重复直到余数为0
*
* @param a 第一个正整数
* @param b 第二个正整数
* @return a和b的最大公约数
* @example
* gcd(48, 18) -> 6
* gcd(17, 5) -> 1
*/
FUNCTION gcd(a, b)
WHILE b != 0 DO
temp = b
b = a MOD b
a = temp
END WHILE
RETURN a
END FUNCTION
// ========== 分段注释 ==========
// ==================== 初始化阶段 ====================
// 配置日志、加载配置、建立连接
// ==================== 处理阶段 ====================
// 核心业务逻辑
// ==================== 清理阶段 ====================
// 关闭连接、释放资源、保存状态
8.3 格式化规范
PLAINTEXT
// ========== 缩进 ==========
// 使用 2 或 4 个空格缩进,保持一致
// 推荐使用 4 个空格
IF condition THEN
// 缩进一个层级
IF nestedCondition THEN
// 再缩进一个层级
action()
END IF
END IF
// ========== 空行 ==========
// 在逻辑块之间使用空行分隔
FUNCTION processData(data)
// 验证阶段
IF data IS NULL THEN
RETURN ERROR "数据为空"
END IF
// 处理阶段
result = []
FOR EACH item IN data DO
IF IS_VALID(item) THEN
APPEND result, TRANSFORM(item)
END IF
NEXT
// 返回阶段
RETURN result
END FUNCTION
// ========== 对齐 ==========
// 相关变量声明可以对齐
name = "Alice"
age = 25
email = "alice@example.com"
city = "New York"
// ========== 关键字大写 ==========
// 推荐关键字使用大写,以区别于变量名
// IF, ELSE, FOR, WHILE, FUNCTION, RETURN, CLASS, END
// 这是可选的风格选择,关键是一致性
8.4 常见错误与避免
PLAINTEXT
// ========== 错误1:过于详细 ==========
// 不好:包含太多实现细节
FUNCTION badExample(data)
// 创建临时变量
temp = []
i = 0
WHILE i < LENGTH(data) DO
// 创建新对象
obj = {}
obj["id"] = data[i].id
obj["name"] = UPPERCASE(data[i].name)
obj["score"] = ROUND(data[i].score * 1.0, 2)
APPEND temp, obj
i = i + 1
END WHILE
RETURN temp
END FUNCTION
// 好:聚焦逻辑而非细节
FUNCTION goodExample(data)
result = []
FOR EACH item IN data DO
processed = {
id: item.id,
name: TO_UPPERCASE(item.name),
score: ROUND(item.score, 2)
}
APPEND result, processed
NEXT
RETURN result
END FUNCTION
// ========== 错误2:过于模糊 ==========
// 不好:太抽象,无法理解具体逻辑
FUNCTION badExample(input)
处理输入数据
返回结果
END FUNCTION
// 好:提供足够的细节
FUNCTION goodExample(input)
validated = VALIDATE(input)
IF validated.hasError THEN
RETURN ERROR validated.errorMessage
END IF
processed = TRANSFORM(validated.data)
RETURN processed
END FUNCTION
// ========== 错误3:不一致的风格 ==========
// 不好:混用不同的风格
FUNCTION badStyle(x, y)
result = x + y
IF result > 100 then
Return "large"
else
return "small"
END IF
END FUNCTION
// 好:保持一致
FUNCTION goodStyle(x, y)
result = x + y
IF result > 100 THEN
RETURN "large"
ELSE
RETURN "small"
END IF
END FUNCTION
九、伪代码转实际代码
9.1 转Python
PLAINTEXT
// 伪代码
FUNCTION binarySearch(arr, target)
left = 0
right = LENGTH(arr) - 1
WHILE left <= right DO
mid = (left + right) / 2
IF arr[mid] == target THEN
RETURN mid
ELSE IF arr[mid] < target THEN
left = mid + 1
ELSE
right = mid - 1
END IF
END WHILE
RETURN -1
END FUNCTION
PYTHON
def binary_search(arr, target):
left = 0
right = len(arr) - 1
while left <= right:
mid = (left + right) // 2
if arr[mid] == target:
return mid
elif arr[mid] < target:
left = mid + 1
else:
right = mid - 1
return -1
9.2 转Java
PLAINTEXT
// 伪代码
CLASS Calculator
PRIVATE lastResult: FLOAT
CONSTRUCTOR()
SET self.lastResult TO 0
END CONSTRUCTOR
PUBLIC METHOD add(a, b)
self.lastResult = a + b
RETURN self.lastResult
END METHOD
PUBLIC METHOD getLastResult()
RETURN self.lastResult
END METHOD
END CLASS
JAVA
public class Calculator {
private double lastResult;
public Calculator() {
this.lastResult = 0;
}
public double add(double a, double b) {
this.lastResult = a + b;
return this.lastResult;
}
public double getLastResult() {
return this.lastResult;
}
}
9.3 转JavaScript
PLAINTEXT
// 伪代码
FUNCTION debounce(fn, delay)
timerId = NULL
RETURN FUNCTION(...args)
IF timerId != NULL THEN
CLEAR_TIMEOUT(timerId)
END IF
timerId = SET_TIMEOUT(FUNCTION()
fn(...args)
timerId = NULL
END FUNCTION, delay)
END FUNCTION
END FUNCTION
JAVASCRIPT
function debounce(fn, delay) {
let timerId = null;
return function (...args) {
if (timerId !== null) {
clearTimeout(timerId);
}
timerId = setTimeout(() => {
fn(...args);
timerId = null;
}, delay);
};
}
9.4 转Go
PLAINTEXT
// 伪代码
FUNCTION findDuplicates(nums)
seen = SET()
duplicates = []
FOR EACH num IN nums DO
IF num IN seen THEN
APPEND duplicates, num
ELSE
ADD seen, num
END IF
NEXT
RETURN duplicates
END FUNCTION
GO
func findDuplicates(nums []int) []int {
seen := make(map[int]bool)
var duplicates []int
for _, num := range nums {
if seen[num] {
duplicates = append(duplicates, num)
} else {
seen[num] = true
}
}
return duplicates
}
9.5 转C++
PLAINTEXT
// 伪代码
FUNCTION reverseLinkedList(head)
prev = NULL
current = head
WHILE current != NULL DO
nextTemp = current.next
current.next = prev
prev = current
current = nextTemp
END WHILE
RETURN prev
END FUNCTION
CPP
ListNode* reverseLinkedList(ListNode* head) {
ListNode* prev = nullptr;
ListNode* current = head;
while (current != nullptr) {
ListNode* nextTemp = current->next;
current->next = prev;
prev = current;
current = nextTemp;
}
return prev;
}
十、工具与资源
10.1 常用工具
| 工具 | 类型 | 功能 | 推荐度 |
|---|---|---|---|
| VS Code | 编辑器 | 通用编辑,支持Markdown语法高亮 | ★★★★★ |
| Draw.io | 绘图 | 流程图、UML图,免费在线 | ★★★★★ |
| Mermaid | 图表 | 文本转图表,可嵌入Markdown | ★★★★☆ |
| PlantUML | 图表 | 文本转UML图,功能强大 | ★★★★☆ |
| Notion | 笔记 | 支持代码块和数据库,协作方便 | ★★★★☆ |
| Obsidian | 笔记 | 本地Markdown,双向链接 | ★★★★☆ |
| Lucidchart | 绘图 | 在线协作,功能全面 | ★★★☆☆ |
| Excalidraw | 白板 | 手绘风格,轻量协作 | ★★★☆☆ |
10.2 在线资源
- VisuAlgo:https://visualgo.net/ - 算法可视化学习平台
- Algorithm Visualizer:https://algorithm-visualizer.org/ - 交互式算法可视化
- Big-O Cheat Sheet:https://www.bigocheatsheet.com/ - 复杂度速查表
- Pseudocode Standard:https://users.csc.calpoly.edu/ - 学术伪代码标准
- LeetCode:https://leetcode.com/ - 算法练习平台
- GeeksforGeeks:https://www.geeksforgeeks.org/ - 丰富的算法教程
十一、总结
11.1 伪代码编写要点
| 要点 | 说明 |
|---|---|
| 清晰性 | 使用自然语言和结构化语法,让非程序员也能大致理解 |
| 完整性 | 包含所有关键逻辑步骤,不遗漏重要的边界条件和异常处理 |
| 一致性 | 保持统一的命名风格、缩进格式和关键字用法 |
| 适度抽象 | 根据目标受众调整抽象级别,不过于详细也不过于模糊 |
| 独立性 | 不依赖特定编程语言的语法特性,保持语言中立 |
| 可转换性 | 结构清晰,便于转换为任何编程语言的实际代码 |
11.2 学习路径
CODE
伪代码基础语法 → 控制结构 → 数据结构 → 算法设计 → 复杂度分析 → 实战应用
↓ ↓ ↓ ↓ ↓ ↓
变量与类型 条件与循环 数组与链表 排序与搜索 大O表示法 系统设计
运算符 函数定义 栈与队列 动态规划 空间分析 算法优化
表达式 参数传递 树与图 贪心算法 性能对比 代码转换
11.3 推荐资源
- 《算法导论》(CLRS):伪代码的经典教材,所有算法用伪代码描述
- 《算法(第4版)》:Robert Sedgewick著,Java实现配合伪代码讲解
- 《编程珠玑》:Jon Bentley著,通过伪代码讲述编程思想
- 《图解算法》:Aditya Bhargava著,图文并茂,伪代码+图解
- Coursera - Algorithms Specialization:Stanford算法专项课程
- MIT 6.006 Introduction to Algorithms:MIT公开课,使用伪代码教学
祝你通过本书掌握伪代码的精髓,成为算法设计和系统设计的高手!