{ // 常數、變數、物件佔用 O(1) 空間 const int a = 0; int b = 0; int nums[1000]; ListNode *node = newListNode(0); free(node); // 迴圈中的變數佔用 O(1) 空間 第 2 章 複雜度分析 www.hello‑algo.com 45 for (int i = 0; i < n; i++) 從當前節點訪問到下一個節點。 鏈結串列的設計使得各個節點可以分散儲存在記憶體各處，它們的記憶體位址無須連續。 圖 4‑5 鏈結串列定義與儲存方式 觀察圖 4‑5 ，鏈結串列的組成單位是節點（node）物件。每個節點都包含兩項資料：節點的“值”和指向下 一節點的“引用”。 ‧ 鏈結串列的首個節點被稱為“頭節點”，最後一個節點被稱為“尾節點”。 ‧ 尾節點指向的是“空”，它在 Java、C++ */ ListNode *newListNode(int val) { ListNode *node; node = (ListNode *) malloc(sizeof(ListNode)); node->val = val; node->next = NULL; return node; } 第 4 章 陣列與鏈結串列 www.hello‑algo.com 75 4.2.1 鏈結串列常用操作

在分析一段程式的空間複雜度時，我們通常統計暫存資料、堆疊幀空間和輸出資料三部分，如圖 2‑15 所示。 圖 2‑15 演算法使用的相關空間 相關程式碼如下： /* 類別 */ class Node { var val: Int var next: Node? init(x: Int) { val = x } } /* 函式 */ func function() -> Int { // 執行某些操作... } func algorithm(n: Int) -> Int { // 輸入資料 let a = 0 // 暫存資料（常數） var b = 0 // 暫存資料（變數） let node = Node(x: 0) // 暫存資料（物件） let c = function() // 堆疊幀空間（呼叫函式） 第 2 章 複雜度分析 www.hello‑algo.com 43 return { // 常數、變數、物件佔用 O(1) 空間 let a = 0 var b = 0 let nums = Array(repeating: 0, count: 10000) let node = ListNode(x: 0) // 迴圈中的變數佔用 O(1) 空間 for _ in 0 ..< n { let c = 0 } // 迴圈中的函式佔用 O(1) 空間 for

在分析一段程式的空間複雜度時，我們通常統計暫存資料、堆疊幀空間和輸出資料三部分，如圖 2‑15 所示。 圖 2‑15 演算法使用的相關空間 相關程式碼如下： /* 類別 */ class Node { int val; Node next; Node(this.val, [this.next]); } /* 函式 */ int function() { // 執行某些操作... return 0; } } int algorithm(int n) { // 輸入資料 const int a = 0; // 暫存資料（常數） int b = 0; // 暫存資料（變數） Node node = Node(0); // 暫存資料（物件） int c = function(); // 堆疊幀空間（呼叫函式） return a + b + c; // 輸出資料 } 第 2 章 複雜度分析 www 常數、變數、物件佔用 O(1) 空間 final int a = 0; int b = 0; List nums = List.filled(10000, 0); ListNode node = ListNode(0); // 迴圈中的變數佔用 O(1) 空間 for (var i = 0; i < n; i++) { 第 2 章 複雜度分析 www.hello‑algo.com

在分析一段程式的空間複雜度時，我們通常統計暫存資料、堆疊幀空間和輸出資料三部分，如圖 2‑15 所示。 圖 2‑15 演算法使用的相關空間 相關程式碼如下： /* 結構體 */ struct Node { int val; Node *next; Node(int x) : val(x), next(nullptr) {} }; /* 函式 */ int func() { // 執行某些操作... return } int algorithm(int n) { // 輸入資料 const int a = 0; // 暫存資料（常數） int b = 0; // 暫存資料（變數） Node* node = new Node(0); // 暫存資料（物件） int c = func(); // 堆疊幀空間（呼叫函式） 第 2 章 複雜度分析 www.hello‑algo.com 43 return constant(int n) { // 常數、變數、物件佔用 O(1) 空間 const int a = 0; int b = 0; vector nums(10000); ListNode node(0); // 迴圈中的變數佔用 O(1) 空間 for (int i = 0; i < n; i++) { 第 2 章 複雜度分析 www.hello‑algo.com 45 int c

在分析一段程式的空間複雜度時，我們通常統計暫存資料、堆疊幀空間和輸出資料三部分，如圖 2‑15 所示。 圖 2‑15 演算法使用的相關空間 相關程式碼如下： /* 類別 */ class Node { int val; Node next; Node(int x) { val = x; } } /* 函式 */ int function() { // 執行某些操作... return 0; } 第 2 43 int algorithm(int n) { // 輸入資料 final int a = 0; // 暫存資料（常數） int b = 0; // 暫存資料（變數） Node node = new Node(0); // 暫存資料（物件） int c = function(); // 堆疊幀空間（呼叫函式） return a + b + c; // 輸出資料 } 2.4.2 推算方法 com 45 // 常數、變數、物件佔用 O(1) 空間 final int a = 0; int b = 0; int[] nums = new int[10000]; ListNode node = new ListNode(0); // 迴圈中的變數佔用 O(1) 空間 for (int i = 0; i < n; i++) { int c = 0; } // 迴圈中的函式佔用

在分析一段程式的空間複雜度時，我們通常統計暫存資料、堆疊幀空間和輸出資料三部分，如圖 2‑15 所示。 圖 2‑15 演算法使用的相關空間 相關程式碼如下： /* 類別 */ class Node { val: number; next: Node | null; constructor(val?: number) { this.val = val === undefined ? 0 : val; // 節點值 algorithm(n: number): number { // 輸入資料 const a = 0; // 暫存資料（常數） let b = 0; // 暫存資料（變數） const node = new Node(0); // 暫存資料（物件） const c = constFunc(); // 堆疊幀空間（呼叫函式） return a + b + c; // 輸出資料 } 2.4.2 推算方法 number): void { // 常數、變數、物件佔用 O(1) 空間 const a = 0; const b = 0; const nums = new Array(10000); const node = new ListNode(0); // 迴圈中的變數佔用 O(1) 空間 for (let i = 0; i < n; i++) { const c = 0; } // 迴圈中的函式佔用

在分析一段程式的空間複雜度時，我們通常統計暫存資料、堆疊幀空間和輸出資料三部分，如圖 2‑15 所示。 圖 2‑15 演算法使用的相關空間 相關程式碼如下： /* 類別 */ class Node { val; next; constructor(val) { this.val = val === undefined ? 0 : val; // 節點值 this.next = null; } function algorithm(n) { // 輸入資料 const a = 0; // 暫存資料（常數） let b = 0; // 暫存資料（變數） const node = new Node(0); // 暫存資料（物件） const c = constFunc(); // 堆疊幀空間（呼叫函式） return a + b + c; // 輸出資料 } 2.4.2 推算方法 constant(n) { // 常數、變數、物件佔用 O(1) 空間 const a = 0; const b = 0; const nums = new Array(10000); const node = new ListNode(0); // 迴圈中的變數佔用 O(1) 空間 for (let i = 0; i < n; i++) { const c = 0; } // 迴圈中的函式佔用

在分析一段程式的空間複雜度時，我們通常統計暫存資料、堆疊幀空間和輸出資料三部分，如圖 2‑15 所示。 圖 2‑15 演算法使用的相關空間 相關程式碼如下： ### 類別 ### class Node attr_accessor :val # 節點值 attr_accessor :next # 指向下一節點的引用 def initialize(x) @val = x end end # 執行某些操作... 0 end ### 演算法 ### def algorithm(n) # 輸入資料 a = 0 # 暫存資料（常數） b = 0 # 暫存資料（變數） node = Node.new(0) # 暫存資料（物件） c = function # 堆疊幀空間（呼叫函式） a + b + c # 輸出資料 end 第 2 章 複雜度分析 www.hello‑algo # 執行某些操作 0 end ### 常數階 ### def constant(n) # 常數、變數、物件佔用 O(1) 空間 a = 0 nums = [0] * 10000 node = ListNode.new # 迴圈中的變數佔用 O(1) 空間 (0...n).each { c = 0 } # 迴圈中的函式佔用 O(1) 空間 (0...n).each { function

class Node(int x) { int val = x; Node next; } /* 函式 */ int Function() { // 執行某些操作... return 0; } int Algorithm(int n) { // 輸入資料 const int a = 0; // 暫存資料（常數） int b = 0; // 暫存資料（變數） Node node int a = 0; 第 2 章 複雜度分析 www.hello‑algo.com 45 int b = 0; int[] nums = new int[10000]; ListNode node = new(0); // 迴圈中的變數佔用 O(1) 空間 for (int i = 0; i < n; i++) { int c = 0; } // 迴圈中的函式佔用 O(1) 空間 hello‑algo.com 73 鏈結串列的設計使得各個節點可以分散儲存在記憶體各處，它們的記憶體位址無須連續。 圖 4‑5 鏈結串列定義與儲存方式 觀察圖 4‑5 ，鏈結串列的組成單位是節點（node）物件。每個節點都包含兩項資料：節點的“值”和指向下 一節點的“引用”。 ‧ 鏈結串列的首個節點被稱為“頭節點”，最後一個節點被稱為“尾節點”。 ‧ 尾節點指向的是“空”，它在 Java、C++

所示。 圖 2‑15 演算法使用的相關空間 相關程式碼如下： /* 結構體 */ type node struct { val int next *node } /* 建立 node 結構體 */ func newNode(val int) *node { return &node{val: val} } /* 函式 */ func function() int { // 10000) node := newNode(0) // 迴圈中的變數佔用 O(1) 空間 var c int for i := 0; i < n; i++ { c = 0 } // 迴圈中的函式佔用 O(1) 空間 for i := 0; i < n; i++ { function() } b += 0 c += 0 nums[0] = 0 node.val = 0 spaceLinear(n int) { // 長度為 n 的陣列佔用 O(n) 空間 _ = make([]int, n) // 長度為 n 的串列佔用 O(n) 空間 var nodes []*node for i := 0; i < n; i++ { nodes = append(nodes, newNode(i)) } // 長度為 n 的雜湊表佔用 O(n) 空間 第 2 章 複雜度分析