www.hello‑algo.com 20 图 2‑1 是该求和函数的流程框图。 图 2‑1 求和函数的流程框图 此求和函数的操作数量与输入数据大小 ? 成正比，或者说成“线性关系”。实际上，时间复杂度描述的就是 这个“线性关系”。相关内容将会在下一节中详细介绍。 2. while 循环 与 for 循环类似，while 循环也是一种实现迭代的方法。在 while 循环中，程序每轮都会先检查条件，如果条 hello‑algo.com 29 // 算法 A 的时间复杂度：常数阶 void AlgorithmA(int n) { Console.WriteLine(0); } // 算法 B 的时间复杂度：线性阶 void AlgorithmB(int n) { for (int i = 0; i < n; i++) { Console.WriteLine(0); } } // 算法 C 的时间复杂度：常数阶 A 只有 1 个打印操作，算法运行时间不随着 ? 增大而增长。我们称此算法的时间复杂度为“常数 阶”。 ‧ 算法 B 中的打印操作需要循环 ? 次，算法运行时间随着 ? 增大呈线性增长。此算法的时间复杂度被称 为“线性阶”。 ‧ 算法 C 中的打印操作需要循环 1000000 次，虽然运行时间很长，但它与输入数据大小 ? 无关。因此 C 的时间复杂度和 A 相同，仍为“常数阶”。 图 2‑7

www.hello‑algo.com 20 图 2‑1 是该求和函数的流程框图。 图 2‑1 求和函数的流程框图 此求和函数的操作数量与输入数据大小 ? 成正比，或者说成“线性关系”。实际上，时间复杂度描述的就是 这个“线性关系”。相关内容将会在下一节中详细介绍。 2. while 循环 与 for 循环类似，while 循环也是一种实现迭代的方法。在 while 循环中，程序每轮都会先检查条件，如果条 复杂度分析 www.hello‑algo.com 29 // 算法 A 的时间复杂度：常数阶 void algorithmA(int n) { print(0); } // 算法 B 的时间复杂度：线性阶 void algorithmB(int n) { for (int i = 0; i < n; i++) { print(0); } } // 算法 C 的时间复杂度：常数阶 void A 只有 1 个打印操作，算法运行时间不随着 ? 增大而增长。我们称此算法的时间复杂度为“常数 阶”。 ‧ 算法 B 中的打印操作需要循环 ? 次，算法运行时间随着 ? 增大呈线性增长。此算法的时间复杂度被称 为“线性阶”。 ‧ 算法 C 中的打印操作需要循环 1000000 次，虽然运行时间很长，但它与输入数据大小 ? 无关。因此 C 的时间复杂度和 A 相同，仍为“常数阶”。 图 2‑7

www.hello‑algo.com 20 图 2‑1 是该求和函数的流程框图。 图 2‑1 求和函数的流程框图 此求和函数的操作数量与输入数据大小 ? 成正比，或者说成“线性关系”。实际上，时间复杂度描述的就是 这个“线性关系”。相关内容将会在下一节中详细介绍。 2. while 循环 与 for 循环类似，while 循环也是一种实现迭代的方法。在 while 循环中，程序每轮都会先检查条件，如果条 www.hello‑algo.com 29 // 算法 A 的时间复杂度：常数阶 fun algoritm_A(n: Int) { println(0) } // 算法 B 的时间复杂度：线性阶 fun algorithm_B(n: Int) { for (i in 0..线性增长。此算法的时间复杂度被称 为“线性阶”。 ‧ 算法 C 中的打印操作需要循环 1000000 次，虽然运行时间很长，但它与输入数据大小 ? 无关。因此 C 的时间复杂度和 A 相同，仍为“常数阶”。 图 2‑7

www.hello‑algo.com 20 图 2‑1 是该求和函数的流程框图。 图 2‑1 求和函数的流程框图 此求和函数的操作数量与输入数据大小 ? 成正比，或者说成“线性关系”。实际上，时间复杂度描述的就是 这个“线性关系”。相关内容将会在下一节中详细介绍。 2. while 循环 与 for 循环类似，while 循环也是一种实现迭代的方法。在 while 循环中，程序每轮都会先检查条件，如果条 hello‑algo.com 29 // 算法 A 的时间复杂度：常数阶 function algorithm_A(n) { console.log(0); } // 算法 B 的时间复杂度：线性阶 function algorithm_B(n) { for (let i = 0; i < n; i++) { console.log(0); } } // 算法 C 的时间复杂度：常数阶 A 只有 1 个打印操作，算法运行时间不随着 ? 增大而增长。我们称此算法的时间复杂度为“常数 阶”。 ‧ 算法 B 中的打印操作需要循环 ? 次，算法运行时间随着 ? 增大呈线性增长。此算法的时间复杂度被称 为“线性阶”。 ‧ 算法 C 中的打印操作需要循环 1000000 次，虽然运行时间很长，但它与输入数据大小 ? 无关。因此 C 的时间复杂度和 A 相同，仍为“常数阶”。 图 2‑7

www.hello‑algo.com 20 图 2‑1 是该求和函数的流程框图。 图 2‑1 求和函数的流程框图 此求和函数的操作数量与输入数据大小 ? 成正比，或者说成“线性关系”。实际上，时间复杂度描述的就是 这个“线性关系”。相关内容将会在下一节中详细介绍。 2. while 循环 与 for 循环类似，while 循环也是一种实现迭代的方法。在 while 循环中，程序每轮都会先检查条件，如果条 复杂度分析 www.hello‑algo.com 29 // 算法 A 的时间复杂度：常数阶 func algorithmA(n: Int) { print(0) } // 算法 B 的时间复杂度：线性阶 func algorithmB(n: Int) { for _ in 0 ..< n { print(0) } } // 算法 C 的时间复杂度：常数阶 func algorithmC(n: A 只有 1 个打印操作，算法运行时间不随着 ? 增大而增长。我们称此算法的时间复杂度为“常数 阶”。 ‧ 算法 B 中的打印操作需要循环 ? 次，算法运行时间随着 ? 增大呈线性增长。此算法的时间复杂度被称 为“线性阶”。 ‧ 算法 C 中的打印操作需要循环 1000000 次，虽然运行时间很长，但它与输入数据大小 ? 无关。因此 C 的时间复杂度和 A 相同，仍为“常数阶”。 图 2‑7

hello‑algo.com 20 res end 图 2‑1 是该求和函数的流程框图。 图 2‑1 求和函数的流程框图 此求和函数的操作数量与输入数据大小 ? 成正比，或者说成“线性关系”。实际上，时间复杂度描述的就是 这个“线性关系”。相关内容将会在下一节中详细介绍。 2. while 循环 与 for 循环类似，while 循环也是一种实现迭代的方法。在 while 循环中，程序每轮都会先检查条件，如果条 。假设输入数据大小为 ? ，给定三个算法 A、B 和 C ： # 算法 A 的时间复杂度：常数阶 def algorithm_A(n) puts 0 end # 算法 B 的时间复杂度：线性阶 def algorithm_B(n) (0...n).each { puts 0 } end # 算法 C 的时间复杂度：常数阶 def algorithm_C(n) (0...1_000_000) A 只有 1 个打印操作，算法运行时间不随着 ? 增大而增长。我们称此算法的时间复杂度为“常数 阶”。 ‧ 算法 B 中的打印操作需要循环 ? 次，算法运行时间随着 ? 增大呈线性增长。此算法的时间复杂度被称 为“线性阶”。 ‧ 算法 C 中的打印操作需要循环 1000000 次，虽然运行时间很长，但它与输入数据大小 ? 无关。因此 C 的时间复杂度和 A 相同，仍为“常数阶”。 图 2‑7

www.hello‑algo.com 20 图 2‑1 是该求和函数的流程框图。 图 2‑1 求和函数的流程框图 此求和函数的操作数量与输入数据大小 ? 成正比，或者说成“线性关系”。实际上，时间复杂度描述的就是 这个“线性关系”。相关内容将会在下一节中详细介绍。 2. while 循环 与 for 循环类似，while 循环也是一种实现迭代的方法。在 while 循环中，程序每轮都会先检查条件，如果条 hello‑algo.com 29 // 算法 A 的时间复杂度：常数阶 void algorithm_A(int n) { System.out.println(0); } // 算法 B 的时间复杂度：线性阶 void algorithm_B(int n) { for (int i = 0; i < n; i++) { System.out.println(0); } } // 算法 C 的时间复杂度：常数阶 A 只有 1 个打印操作，算法运行时间不随着 ? 增大而增长。我们称此算法的时间复杂度为“常数 阶”。 ‧ 算法 B 中的打印操作需要循环 ? 次，算法运行时间随着 ? 增大呈线性增长。此算法的时间复杂度被称 为“线性阶”。 ‧ 算法 C 中的打印操作需要循环 1000000 次，虽然运行时间很长，但它与输入数据大小 ? 无关。因此 C 的时间复杂度和 A 相同，仍为“常数阶”。 图 2‑7

www.hello‑algo.com 20 图 2‑1 是该求和函数的流程框图。 图 2‑1 求和函数的流程框图 此求和函数的操作数量与输入数据大小 ? 成正比，或者说成“线性关系”。实际上，时间复杂度描述的就是 这个“线性关系”。相关内容将会在下一节中详细介绍。 2. while 循环 与 for 循环类似，while 循环也是一种实现迭代的方法。在 while 循环中，程序每轮都会先检查条件，如果条 hello‑algo.com 29 // 算法 A 的时间复杂度：常数阶 void algorithm_A(int n) { cout << 0 << endl; } // 算法 B 的时间复杂度：线性阶 void algorithm_B(int n) { for (int i = 0; i < n; i++) { cout << 0 << endl; } } // 算法 C 的时间复杂度：常数阶 A 只有 1 个打印操作，算法运行时间不随着 ? 增大而增长。我们称此算法的时间复杂度为“常数 阶”。 ‧ 算法 B 中的打印操作需要循环 ? 次，算法运行时间随着 ? 增大呈线性增长。此算法的时间复杂度被称 为“线性阶”。 ‧ 算法 C 中的打印操作需要循环 1000000 次，虽然运行时间很长，但它与输入数据大小 ? 无关。因此 C 的时间复杂度和 A 相同，仍为“常数阶”。 图 2‑7

www.hello‑algo.com 20 图 2‑1 是该求和函数的流程框图。 图 2‑1 求和函数的流程框图 此求和函数的操作数量与输入数据大小 ? 成正比，或者说成“线性关系”。实际上，时间复杂度描述的就是 这个“线性关系”。相关内容将会在下一节中详细介绍。 2. while 循环 与 for 循环类似，while 循环也是一种实现迭代的方法。在 while 循环中，程序每轮都会先检查条件，如果条 hello‑algo.com 29 // 算法 A 的时间复杂度：常数阶 func algorithm_A(n int) { fmt.Println(0) } // 算法 B 的时间复杂度：线性阶 func algorithm_B(n int) { for i := 0; i < n; i++ { fmt.Println(0) } } // 算法 C 的时间复杂度：常数阶 func A 只有 1 个打印操作，算法运行时间不随着 ? 增大而增长。我们称此算法的时间复杂度为“常数 阶”。 ‧ 算法 B 中的打印操作需要循环 ? 次，算法运行时间随着 ? 增大呈线性增长。此算法的时间复杂度被称 为“线性阶”。 ‧ 算法 C 中的打印操作需要循环 1000000 次，虽然运行时间很长，但它与输入数据大小 ? 无关。因此 C 的时间复杂度和 A 相同，仍为“常数阶”。 图 2‑7

www.hello‑algo.com 20 图 2‑1 是该求和函数的流程框图。 图 2‑1 求和函数的流程框图 此求和函数的操作数量与输入数据大小 ? 成正比，或者说成“线性关系”。实际上，时间复杂度描述的就是 这个“线性关系”。相关内容将会在下一节中详细介绍。 2. while 循环 与 for 循环类似，while 循环也是一种实现迭代的方法。在 while 循环中，程序每轮都会先检查条件，如果条 hello‑algo.com 29 // 算法 A 的时间复杂度：常数阶 fn algorithm_A(n: i32) { println!("{}", 0); } // 算法 B 的时间复杂度：线性阶 fn algorithm_B(n: i32) { for _ in 0..n { println!("{}", 0); } } // 算法 C 的时间复杂度：常数阶 fn algorithm_C(n: A 只有 1 个打印操作，算法运行时间不随着 ? 增大而增长。我们称此算法的时间复杂度为“常数 阶”。 ‧ 算法 B 中的打印操作需要循环 ? 次，算法运行时间随着 ? 增大呈线性增长。此算法的时间复杂度被称 为“线性阶”。 ‧ 算法 C 中的打印操作需要循环 1000000 次，虽然运行时间很长，但它与输入数据大小 ? 无关。因此 C 的时间复杂度和 A 相同，仍为“常数阶”。 图 2‑7