伪代码编程完全指南

← 返回指南列表

伪代码编程完全指南

一、伪代码概述

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 在线资源


十一、总结

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公开课,使用伪代码教学

祝你通过本书掌握伪代码的精髓,成为算法设计和系统设计的高手!