本文永久链接 – https://tonybai.com/2025/09/07/the-power-of-an-interface-for-performance

我的《Go语言第一课》已上市，赠书活动正在进行中，欢迎点击此链接参与。

大家好，我是Tony Bai。

我们通常如何看待性能优化？答案往往是：更快的算法、更少的内存分配、更底层的并发原语、甚至用SIMD指令压榨CPU的每一个周期。我们痴迷于“引擎盖之下”的实现细节，坚信更好的代码和更强的硬件能带来更高的性能。

然而，TigerBeetle数据库创始人Joran Dirk Greef在Strange Loop上的一场精彩的演讲(https://www.youtube.com/watch?v=yKgfk8lTQuE)，用一场耗资百万美元的数据库比赛，颠覆了这一传统认知。他通过无可辩驳的基准测试数据证明：在分布式系统中，接口（Interface）的设计，而非代码实现或硬件堆砌，才是决定性能上限的真正瓶颈。

在深入探讨之前，我们必须对本文的“接口”一词进行关键澄清。对于Go开发者而言，“接口”通常指代语言层面的interface类型，一种实现行为契约以及多态的工具。但本文中所说的“接口”，则是一个更宏观、更广义的概念，它指的是系统与系统之间、或用户与系统之间进行通信的交互模式、契约与协议。你的REST API设计、gRPC的.proto文件、微服务间的调用时序，都属于这个“广义接口”的范畴。

这场演讲虽然以数据库为载体，但其揭示的“接口即天花板”的原理，对于每一位设计和使用Go API、微服务的工程师来说，都无异于一声惊雷。它迫使我们重新审视，我们日常构建的系统，是否在设计之初，就已为自己埋下了无法逾越的性能枷锁。

赛场设定：一场关于“转账”的终极对决

Greef的实验设计极其巧妙，他回归了OLTP（在线事务处理）的本质，重拾了图灵奖得主Jim Gray定义的最小交易单元：“借贷记”（Debit-Credit），即我们熟知的“转账”操作。

这个工作负载的核心是：在两个账户之间转移价值，并记录一笔历史。它的关键挑战在于竞争（Contention）。在高流量的真实世界系统中，总会有大量的交易集中在少数“热门”账户上，这就是帕累托法则（80/20原则）的体现。

传统接口：交互式事务

大多数通用数据库处理这种事务的标准接口是“交互式”的，即一个业务操作需要多次网络往返才能完成：
1. 第一步（读）：客户端发起一个网络请求，SELECT Alice和Bob的账户余额。
2. 第二步（计算）：数据返回到客户端，应用代码在本地检查余额是否充足。
3. 第三步（写）：客户端发起第二个网络请求，在一个事务中UPDATE两个账户的余额，并INSERT一条转账记录。

这个看似天经地义的流程，隐藏着一个致命的缺陷。

百万美元的“滑铁卢”：当硬件和实现都失灵

Greef设立了三组“选手”来进行一场性能对决：

1. Postgres (单机): 经典的、备受尊重的开源数据库。
2. “迈凯伦” (16节点集群): 一个匿名的、顶级的云原生分布式数据库，年费超过一百万美元。
3. TigerBeetle: Greef自己设计的、专为OLTP优化的新一代数据库。

比赛结果令人瞠目结舌：

• 在零竞争下，“迈凯伦”集群的性能甚至不如单机Postgres。
• 随着竞争率提升，16台机器的“迈凯伦”性能暴跌，甚至出现了节点越少、性能越高的荒谬情况。
• 在整个高竞争测试期间，这百万美元硬件的CPU利用率从未超过12%。

为什么？ 硬件在空转，代码在等待。钱，并没有买来性能。

性能的枷锁：跨网络持有锁

问题的根源，就出在那个“交互式事务”的接口设计上。

当一个事务开始时，数据库为了保证ACID，必须锁定被操作的行。在这个接口模型中，锁的持有时间 = 数据库处理时间 + 两次网络往返（RTT）的时间 + 客户端应用的处理时间。

Greef指出，数据库内部的处理时间可能是微秒级的，但一次跨数据中心的网络往返，轻易就是几十甚至上百毫秒。这意味着，数据库中最宝贵的锁资源，其生命周期被廉价且缓慢的网络I/O牢牢绑架了。

阿姆达尔定律的诅咒

这完美地印证了阿姆达尔定律：系统的总性能，取决于其串行部分的速度。在这个场景中，“跨网络持有锁”就是那个不可并行的、绝对的串行瓶颈。

• 当网络延迟为1ms，竞争率为10%时，即使你的数据库是无限快的，理论性能上限也只有10,000 TPS。
• 当网络延迟上升到10ms，这个上限会骤降到1,000 TPS。

无论你增加多少台机器（水平扩展），都无法打破这个由接口设计决定的物理定律。

对Go API和系统设计的深刻启示

这场数据库之战，对我们Go开发者来说，是一面镜子。我们必须审视自己日常的设计，是否也在不经意间构建了类似的“性能枷锁”。

1. 警惕你的Go API是否“跨网络持有锁”

在微服务架构中，一个常见的反模式是“编排式事务”。想象一个创建订单的流程：

// 反模式：一个跨多个网络调用、持有远端锁的接口
func CreateOrder(ctx context.Context, userID, productID int) error {
    // 步骤1：锁定库存 (通过RPC调用库存服务)
    lock, err := inventoryService.LockStock(ctx, productID, 1)
    if err != nil {
        return err
    }
    // 注意：从此刻起，该商品的库存在inventoryService中被锁定！

    // 步骤2：扣减用户余额 (通过RPC调用账户服务)
    err = accountService.Debit(ctx, userID, product.Price)
    if err != nil {
        inventoryService.UnlockStock(ctx, lock.ID) // 必须记得解锁
        return err
    }

    // 步骤3：创建订单记录
    // ...

    // 成功！最后解锁库存
    return inventoryService.UnlockStock(ctx, lock.ID)
}

这个CreateOrder函数，在其执行期间，跨越了多次网络调用，却一直持有着库存服务的锁。这与Postgres的交互式事务犯了完全相同的错误。这个糟糕的接口设计决定了系统的性能上限。

2. TigerBeetle的解决方案：重新定义接口

TigerBeetle的接口设计哲学截然不同。它不接受交互式的、一次一笔的事务。取而代之的是：
- 批处理 (Batching): 客户端将成千上万个“转账”意图打包成一个大的请求。
- 一次性提交 (One-Shot Commit): 将这个大包一次性发送给数据库。
- 异步处理: 数据库在内部高效地处理这个批次，然后一次性返回所有结果。

在这个模型中，网络延迟只发生一次，且与锁的持有时间完全解耦。

3. 转化为Go的设计模式：

我们可以将TigerBeetle的思想应用到我们的Go服务设计中，重新定义我们的“接口”：

• 使用异步消息传递：CreateOrder服务不应直接调用其他服务并等待。它应该发布一个OrderCreationRequested事件到消息队列（如NATS或Kafka）。后续的服务订阅此事件，并以异步、解耦的方式处理各自的逻辑（通常需要Saga等模式保证最终一致性）。
• 设计“意图驱动”的API：不要创建需要多次交互才能完成一个业务流程的API。取而代之，设计一个能接收完整“业务意图”的API。例如，提供一个/orders/batch_create端点，让客户端一次性提交多个订单创建的请求。
• 将状态检查移至服务端：与其让客户端先读数据再决定如何写，不如提供一个API，让客户端直接声明它的意图，由服务端在一个原子操作内完成“检查并写入”。

小结

Joran Greef的演讲最终以TigerBeetle在高竞争下，性能达到Postgres数千倍的结果震撼全场。这并非因为TigerBeetle的代码实现比Postgres好了几个数量级，而是因为它的接口设计从根本上绕开了阿姆达尔定律的诅咒。

对于Go开发者，这场演讲的启示也是深远的：

• 性能瓶颈往往在白板上就已注定：在你写下第一行代码之前，你的API设计、服务间的交互模型，可能已经为你的系统设定了无法逾越的性能天花板。
• 减少网络往返，尤其是持有锁的往返，是性能优化的第一要务。
• 拥抱批处理和异步化：这是打破“一次交互一件事”思维定势、实现数量级性能提升的关键。

下一次，当你面对性能问题时，与其一头扎进pprof的火焰图，试图优化某个函数的CPU占用，不如先退后一步，审视你的系统和API的接口设计。或许，那个锁住你系统性能的真正枷锁，并非隐藏在代码的细枝末节里，而是明晃晃地写在你的设计文档的第一页。

想系统学习Go，构建扎实的知识体系？

我的新书《Go语言第一课》是你的首选。源自2.4万人好评的极客时间专栏，内容全面升级，同步至Go 1.24。首发期有专属五折优惠，不到40元即可入手，扫码即可拥有这本300页的Go语言入门宝典，即刻开启你的Go语言高效学习之旅！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

本文永久链接 – https://tonybai.com/2025/09/06/gopher-pseudocode-translation-guide

大家好，我是Tony Bai。

你是否曾在阅读顶会论文时，感觉其中的算法描述像一本晦涩难懂的“天书”？那些看不太懂的数学符号、奇特的箭头和看似代码又无法编译的语句(如下图)，是不是常常让你望而却步，感叹理论与实践之间隔着一道鸿沟？

别担心，这不是你的问题。你遇到的正是连接学术象牙塔与工程世界的桥梁——伪代码 (Pseudocode)。它并非一门具体的编程语言，而是算法世界的“通用语” (Lingua Franca)，旨在剥离所有语言特定的语法噪音，只保留逻辑的纯粹核心。

对于我们工程师而言，掌握伪代码的阅读技巧，就像是学会了一门新的“翻译”艺术。这门艺术能让你直接与算法设计者的思想对话，将世界上最聪明的头脑的智慧，转化为你手中坚实、高效的主流编程语言的代码。

本文就是你的学术伪代码“翻译”指南。我们将从最基础的符号“字母表”开始，探索不同风格的伪代码“文体”，通过完整的“翻译”实战，让你最终不仅能读懂，更能欣赏伪代码之美，并自信地将任何算法“天书”都转化为优雅的编程语言实现(本文将以Go语言为例)。

罗塞塔石碑 —— 破译伪代码的核心符号

任何翻译工作都始于对基本词汇的掌握。伪代码的符号系统虽然看似五花八门，但其核心元素却非常稳定。让我们一同来构建我们的“罗塞塔石碑”，将最常见的伪代码符号与 Go 语言进行映射。

1. 赋值操作: ← (The Left Arrow)

这是伪代码最具标志性的符号，代表赋值。

• 伪代码:

  max_val ← A[0]
  i ← 1
  

• 为什么用 ← 而不是 =?
  为了在学术上严格区分赋值 (Assignment) 和 相等判断 (Equality Test)。在算法和数学语境中，= 通常是逻辑断言，表示“等于”。← 则清晰地表达了“将右边的值赋予左边变量”这一动作，杜绝了歧义。

• Go “译文”:

  maxVal := A[0] // 声明并赋值
  i := 1         // 或使用 = 进行二次赋值
  

2. 循环结构: for, while, repeat-until

• 计数循环 (for … to … do)

  • 伪代码:
    for i ← 1 to n do
// 对 A[i] 进行操作

  • Go “译文”:
    注意！这是最常见的陷阱之一！ 伪代码的数组索引习惯于从 1 开始（数学惯例），而 Go 从 0 开始。

    // 伪代码的 1 to n 对应 Go 的 0 to n-1
    for i := 0; i < n; i++ {
        // 操作 A[i]
    }
    
    // 如果逻辑强依赖于 1-based 索引，需手动调整
    for i := 1; i <= n; i++ {
        // 操作 A[i-1]
    }
    

• 遍历循环 (for each … in …)

  • 伪代码:
    for each item in S do
print(item)
  • Go “译文”: 完美对应 for-range。
    go
for _, item := range S {
fmt.Println(item)
}

3. 条件判断: if-then-else

• 伪代码:
  if x > y then
max_val ← x
else
max_val ← y
• Go “译文”: 结构相同，只是去掉了 then。
  go
if x > y {
maxVal = x
} else {
maxVal = y
}

4. 逻辑与数学符号

这是让代码“数学味”变浓的地方，但本质只是运算符的另一种写法。

• 逻辑运算符: ∧ (与, &&), ∨ (或, ||), ¬ (非, !)
• 比较运算符: = (等于, ==), ≠ (不等于, !=)

• 集合运算符: ∈ (属于), ∉ (不属于), ⊂ (是…的子集), ∪ (并集), ∩ (交集)

• 伪代码:

  if (i < n) ∧ (A[i] ≠ target) then
      i ← i + 1
  

• Go “译文”:
  go
if (i < n) && (A[i] != target) {
i++
}

5. 函数与返回值: function, procedure, return

伪代码使用 function 或 procedure 关键字来定义一个可重用的逻辑块。通常，function 暗示着有返回值，而 procedure 可能没有。return 关键字用于明确地从函数中返回一个或多个值。

• 伪代码:
  function FIND-MAX(A, n)
max_val ← A[1]
for i ← 2 to n do
if A[i] > max_val then
max_val ← A[i]
return max_val

• Go “译文”:
  在 Go 中，我们使用 func 关键字。一个重要的“翻译”区别是，Go 的切片自带长度信息，因此通常无需像伪代码那样显式传递长度 n。此外，Go 鼓励通过多返回值来处理错误，这是伪代码中通常不会详述的工程实践。

  // FindMax 在一个整数切片中寻找最大值。
  // 如果切片为空，它会返回 0 和一个错误。
  func FindMax(A []int) (int, error) {
      if len(A) == 0 {
          return 0, fmt.Errorf("cannot find max in an empty slice")
      }
  
      maxVal := A[0]
      // 伪代码从索引 2 开始，对应 Go 的索引 1
      for i := 1; i < len(A); i++ {
          if A[i] > maxVal {
              maxVal = A[i]
          }
      }
      return maxVal, nil
  }
  

6. 注释符号: //, #, 或 ▷

注释是写给人类读者的，用于解释某行或某块逻辑的意图。伪代码中的注释风格非常灵活。

• 为什么有 ▷ 这种奇怪的符号?
  这个空心三角符号 (triangleright) 在使用 LaTeX 排版的学术论文中非常流行，因为它在视觉上比 // 或 # 更优雅，并且能与数学公式和谐共存。

• 伪代码:

  l ← 0   ▷ Initialize the left pointer
  

• Go “译文”:
  Go 语言使用 // 进行单行注释，使用 /* … */ 进行多行注释。

  l := 0 // Initialize the left pointer
  

伪代码的“文体”

正如文章有不同文体，伪代码也并非铁板一块。它存在一个从“酷似代码”到“形如散文”的风格光谱。理解这个光谱，能帮助我们更好地把握作者的意图。

让我们以一个（故意写得晦涩的）SomethingMysterious 算法为例，该算法的功能是统计一个字符串切片中每个唯一字符串出现的次数。

文体一：“伪装者”—— 语言强相关的真实代码

这其实是坏的伪代码。它直接使用某种特定语言（如下例中的MATLAB）的语法，给不熟悉该语言的读者制造了巨大障碍。

• MATLAB 代码示例:
  matlab
function Y = SomethingMysterious(X)
Y = {};
while length(X)
w = X(1);
c_w = 1;
inds = [1];
for i = 2:length(X)
if strcmp(X(i), w)
c_w = c_w + 1;
inds = [inds i];
end
end
Y{end+1} = {w, c_w};
X(inds) = [];
end
end
• “翻译”诊断： 这不是伪代码，这是需要“硬啃”的源码。strcmp, {} cell array, end+1 索引等都是 MATLAB 方言，可读性极差。我们应该避免用这种方式书写和理解算法。

文体二：“直译”—— 细节丰富的类代码风格

这种风格非常接近编程语言，但剥离了最刁钻的语法。它易于转换为代码，但可能因细节过多而显得啰嗦。

• 类代码伪代码:
  PROCEDURE SomethingMysterious_v2(X):
Y = []
while length(X) > 0:
let w be the first element of X
initialize count c_w to 1
initialize inds (indices to delete) to [1]
for i from 2 to length(X): // assume 1-based indexing
if X[i] == w:
c_w = c_w + 1
append i to inds
append {w, c_w} to Y
delete from X all values at indices in inds

• “翻译”诊断： 这是最常见的伪代码风格之一。逻辑清晰，步骤明确。翻译成 Go 时，主要工作是处理 1-based 索引和 delete from X 这个相对低效的操作。

  • 直译版 Go 实现 (保留了低效操作):

    func SomethingMysteriousV2(X []string) map[string]int {
        Y := make(map[string]int)
        // Go 中直接修改正在遍历的切片很危险，我们用一个 map 来标记已处理的元素
        processed := make(map[string]bool)
    
        for _, w := range X {
            if processed[w] {
                continue
            }
            count := 0
            for _, item := range X {
                if item == w {
                    count++
                }
            }
            Y[w] = count
            processed[w] = true
        }
        return Y
    }
    

  • 意译版 Go 实现 (更 Go Idiomatic):
    go
// 这个算法的本质就是词频统计，Go 中用 map 实现最高效
func WordFrequencyCounter(words []string) map[string]int {
counts := make(map[string]int)
for _, word := range words {
counts[word]++
}
return counts
}
    这个例子完美地展示了“翻译”的真谛：我们追求的不是逐字逐句的“直译”，而是理解其核心意图后的“意译”，写出符合目标语言习惯的优雅代码。

文体三：“意译”—— 平衡的半形式化风格

这是理想的伪代码。它使用自然语言来描述高层意图，同时用结构化语句来保留算法骨架。它足够精确，可以用于分析时间复杂度；也足够抽象，不会陷入实现细节。

• 平衡风格伪代码:
  PROCEDURE SomethingMysterious_v3(X):
Y = []
While X is not empty:
Let w be the first element of X
Count the number of occurrences of w in X, call this c_w
Append (w, c_w) to Y
Delete all occurrences of w from X
return Y
• “翻译”诊断： 这种风格最能体现算法思想。Count the number of occurrences 和 Delete all occurrences 是两个抽象指令。读者可以立即明白算法要做什么，并能自由选择最高效的实现方式（比如使用 Go 的 map）。

文体四：“神似”—— 纯自然语言描述

这种风格完全脱离了代码形式，用一两句话描述算法核心思想。适合在高层设计文档中使用，但无法直接用于代码实现或复杂度分析。

• 纯英文描述:

  For each unique word in the input list, count how many times it appears, and add the word and its count to a result list.

• “翻译”诊断： 这是算法的“灵魂”，是“意译”的终极目标。当你在阅读伪代码时，如果能用这样一句话在脑中概括出它的作用，你就真正读懂了它。

实战演练 —— 我们来完整“翻译”一个二分查找

理论讲了这么多，让我们通过一个经典案例——二分查找，来走一遍完整的“翻译”流程。

伪代码版本 (源自经典教材)

function BINARY-SEARCH(A, T)
  1. L ← 1
  2. R ← length(A)
  3. while L ≤ R do
  4.   m ← floor((L + R) / 2)
  5.   if A[m] < T then
  6.     L ← m + 1
  7.   else if A[m] > T then
  8.     R ← m - 1
  9.   else
  10.    return m
  11. return -1  // Indicates not found

Go “翻译”全过程

1. 函数签名翻译 (function BINARY-SEARCH(A, T)):
   伪代码接受一个数组 A 和目标 T。在 Go 中，我们通常使用切片 []int，并返回索引 int 和一个可能的 error。

   func BinarySearch(data []int, target int) (int, bool) { // 返回 (index, found) 更符合 Go 风格
   

2. 变量初始化翻译 (L ← 1, R ← length(A)):
   再次敲响警钟：1-based 索引！ Go 的切片索引从 0 到 len(data) – 1。

   left := 0
   right := len(data) - 1
   

3. 循环与条件翻译 (while L ≤ R do):
   while 循环在 Go 中用 for 实现。

   for left <= right {
   

4. 核心逻辑翻译:
   m ← floor((L + R) / 2) 在 Go 整数除法中自动实现向下取整。但更专业的写法是 left + (right – left) / 2 以防止 left + right 溢出。

       middle := left + (right-left)/2
       if data[middle] < target {
           left = middle + 1
       } else if data[middle] > target {
           right = middle - 1
       } else {
           return middle, true // 找到了
       }
   }
   

5. 返回值翻译 (return -1):
   如果循环结束，说明没找到。按照 Go 的风格，我们返回一个零值和 false。

   return -1, false // 未找到
   

最终的 Go “译文”

// BinarySearch 在一个有序切片中查找目标值。
// 如果找到，返回其索引和 true；否则返回 -1 和 false。
func BinarySearch(data []int, target int) (int, bool) {
    left, right := 0, len(data)-1

    for left <= right {
        // 使用这种方式计算 middle 可以防止 left + right 整数溢出
        middle := left + (right-left)/2

        if data[middle] < target {
            left = middle + 1
        } else if data[middle] > target {
            right = middle - 1
        } else {
            // 找到了目标
            return middle, true
        }
    }

    // 未找到目标
    return -1, false
}

伪代码的“方言”—— 识别不同时代的印记

伪代码没有统一的国际标准，不同年代、不同作者的著作会展现出不同的“方言”。学会识别这些方言，能让你在阅读各种历史文献时游刃有余。

• 早期 Pascal 风格 (e.g., Sedgewick, 1988):

  function binarysearch(v:integer):integer;
  var x, l, r:integer;
  begin
    l:=1; r:=N;
    repeat
      x:=(l+r)div 2;
      if v<a[x].key then r:=x-1 else l:=x+1
    until (v=a[x].key) or (l>r);
  end;
  

  方言特征: 强类型声明 (:integer)、:= 赋值、repeat-until (类似 do-while)、begin-end 块。

• C-Like 风格 (e.g., Baase and Van Gelder, 2000):

  int binarySearch(int[], E, int first, int last, int K)
  if (last < first)
    index = -1;
  else
    int mid = (first + last)/2;
    ...
  return index;
  

  方言特征: C 语言的函数签名、花括号或缩进表示代码块、分号。

• 现代 Pythonic 风格:

  def binary_search(L, item):
    if len(L) <= 1:
      ...
    mid = len(L) // 2
    if L[mid] > item:
      return binary_search(L[:mid], item)
    ...
  

  方言特征: 大量借鉴 Python 语法，如切片 L[:mid]、len() 函数、// 整除。

“翻译”心法： 无论“方言”如何变化，算法的核心思想——循环、判断、赋值——是永恒的。不要被表面的语法差异所迷惑，而要去识别其背后共通的逻辑结构。

伪代码的阅读与写作心法

最后，让我们提炼一些高级的“心法”，它们是伪代码背后的最佳实践。

1. 意图(intent)先于语法

阅读伪代码时，首要任务是理解作者的意图。不要纠结于 := 和 ← 的区别，或者循环是用 while 还是 for。问自己：这一步操作的目的是什么？是在查找、计数还是在交换？

1. 拥抱抽象

当伪代码中出现 Sort(A) 或 FindShortestPath(G, u, v) 这样的语句时，不要立即陷入“我该如何实现一个排序算法”的细节中。作者在此时是把这些操作当作“黑盒”，假设你已经知道或可以查到它们的功能。这能让你聚焦于当前算法的创新之处。

1. 警惕语言特性的“陷阱翻译”

不要把伪代码中的结构生搬硬套到 Go 中。例如，伪代码中的 delete from X 如果直译成 Go，可能会导致在一个循环中反复创建新切片，性能极差。正确的“翻译”是思考：在 Go 中，实现“移除一组元素”这个意图的最佳方式是什么？（可能是原地移动元素后截断，或标记删除等）。

1. 像写文章一样写伪代码

如果你需要写伪代码（例如，在技术设计文档中），请记住你的读者是人类。使用有意义的变量名，适当添加注释，优先保证清晰易懂，而不是代码的紧凑。好的伪代码更像一篇逻辑清晰的说明文。

1. 平衡是艺术

好的伪代码是在精确性和可读性之间取得了绝妙的平衡。它必须包含足够的信息来分析算法的正确性和时间复杂度，但又要隐去足够多的实现细节，以免让核心思想被淹没。这正是“意译”风格（文体三）备受推崇的原因。

小结

伪代码，这门一度看似神秘的“天书”，其面纱已被揭开。通过这篇“翻译指南”，你已经：

• 掌握了伪代码的基础符号“字母表”。
• 理解了其从精确到写意的不同“文体”。
• 亲历了一次完整的“翻译”实战。
• 学会了识别不同时代的“方言”。
• 领悟了阅读与写作的深层“心法”。

现在，你手中的钥匙已经可以打开任何一篇学术论文的算法之门。这片广阔的知识海洋，正等待着你这位优秀的“翻译官”去探索。

参考资料

• https://student.cs.uwaterloo.ca/~cs231/resources/pseudocode.pdf
• https://blogs.ubc.ca/cpsc3202019s2/files/2019/07/pseudocode_guide_sol.pdf
• https://www.researchgate.net/publication/309410533_Introduction_to_Algorithms_and_Pseudocode

想系统学习Go，构建扎实的知识体系？

我的新书《Go语言第一课》是你的首选。源自2.4万人好评的极客时间专栏，内容全面升级，同步至Go 1.24。首发期有专属五折优惠，不到40元即可入手，扫码即可拥有这本300页的Go语言入门宝典，即刻开启你的Go语言高效学习之旅！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。