Data structure on Jenny blog

資料結構：線段樹 Segment Tree

Fri, 30 Jun 2023 18:43:13 +0800

介紹

線段樹（Segment Tree）是一種常見的資料結構，用於解決區間查詢（range query）的問題。

它主要用於處理數列或數組的區間操作，如區間求和、區間最大值、區間最小值等。

線段樹的基本思想是將原始的數據按照一定的方式分割成若干個區間，並在每個區間上存儲相應的信息，如區間的總和、最大值、最小值等。這樣，在需要查詢某個區間的統計信息時，可以通過合併相應區間的信息快速計算得到。

一般而言，線段樹是一種二叉樹結構，每個節點表示一個區間，而樹的根節點表示整個數列或數組的區間。
每個節點包含了該區間的統計信息，以及指向左右子節點的指標。

基礎操作

建構線段樹的過程可以使用遞迴或迭代的方式進行。具體而言，建構過程中，將原始數據切分為兩半，然後遞迴構建左子樹和右子樹，最終將左子樹和右子樹的統計信息合併到當前節點。

線段樹的查詢操作也可以使用遞迴或迭代的方式進行。當查詢的區間與節點表示的區間有交集時，需要遞迴查詢左子節點和右子節點。如果查詢的區間完全包含在節點表示的區間中，則可以直接返回該節點的統計信息。

線段樹的修改操作通常也使用遞迴或迭代的方式進行。當需要修改某個位置的值時，需要遞迴更新涉及該位置的所有節點，以維護其統計信息的準確性。

時間複雜度，推薦必看👍

資料來自菜鳥工程師肉豬的部落格，推薦超好懂 👍：
【為什麼Binary Search 二元搜索法的時間複雜度是O(log(n))】

優點

線段樹的優點在於可以在O(logN)的時間複雜度下完成區間操作，其中N表示數列或數組的長度。
它在許多需要頻繁進行區間操作的應用場景中具有重要的應用價值，如區間求和、區間最值查詢、區間更新等。

問題與限制

然而，線段樹也有一些限制和注意事項。首先，它需要較多的內存空間來存儲統計信息，因此在處理大型數據集時可能會面臨內存限制的問題。此外，線段樹的建構過程較為複雜，並且對於動態更新的情況，可能需要進行結構調整，增加了一定的複雜度。

結論

總體而言，線段樹是一種強大的數據結構，可以高效地處理區間操作的問題。在算法競賽和一些需要快速解決區間查詢的應用中，線段樹是一個重要的工具。

以下是使用 JavaScript 實現線段樹的基本範例碼：

class SegmentTree {
    constructor(nums) {
        this.nums = nums;
        this.tree = new Array(nums.length * 4); // 建立線段樹陣列
        this.buildTree(0, 0, nums.length - 1);
    }

    // 建立線段樹
    buildTree(node, start, end) {
        if (start === end) {
            this.tree[node] = this.nums[start];
        } else {
            const mid = Math.floor((start + end) / 2);
            const leftChild = 2 * node + 1;
            const rightChild = 2 * node + 2;

            this.buildTree(leftChild, start, mid);
            this.buildTree(rightChild, mid + 1, end);

            this.tree[node] = this.tree[leftChild] + this.tree[rightChild]; // 修改這裡可以實現不同的區間操作
        }
    }

    // 區間查詢
    query(node, start, end, left, right) {
        if (left > end || right < start) {
            return 0; // 區間不相交，返回初始值（這裡假設初始值為 0）
        } else if (left <= start && right >= end) {
            return this.tree[node]; // 區間完全包含在節點表示的區間中，返回該節點的值
        } else {
            const mid = Math.floor((start + end) / 2);
            const leftChild = 2 * node + 1;
            const rightChild = 2 * node + 2;
            const sumLeft = this.query(leftChild, start, mid, left, right);
            const sumRight = this.query(rightChild, mid + 1, end, left, right);
            return sumLeft + sumRight; // 修改這裡可以實現不同的區間操作
        }
    }

    // 修改數組中某個位置的值
    update(node, start, end, index, value) {
        if (start === end) {
            this.tree[node] = value;
        } else {
            const mid = Math.floor((start + end) / 2);
            const leftChild = 2 * node + 1;
            const rightChild = 2 * node + 2;
            if (index >= start && index <= mid) {
                this.update(leftChild, start, mid, index, value);
            } else {
                this.update(rightChild, mid + 1, end, index, value);
            }
            this.tree[node] = this.tree[leftChild] + this.tree[rightChild]; // 修改這裡可以實現不同的區間操作
        }
    }
}

// 測試
const nums = [1, 3, 5, 7, 9, 11];
const segmentTree = new SegmentTree(nums);

console.log(segmentTree.query(0, 0, nums.length - 1, 1, 4)); // 計算索引 1 到 4 的區間和，應為 24
segmentTree.update(0, 0, nums.length - 1, 2, 6); // 修改索引 2 的值為 6
console.log(segmentTree.query(0, 0, nums.length - 1, 1, 4)); // 再次計算索引 1 到 4 的區間和，應為 25

/**
 *               【以數字來分類】
 *             [1, 3, 5, 7, 9, 11]
 *              /              \
 *         [1, 3, 5]       [7, 9, 11] 
 *            /  \             /     \
 *         [1, 3] [5]       [7, 9]   [11]
 *          / \               /   \
 *        [1] [3]           [7]   [9] 
 * 
 * 
 * 
 *               【以 index 來分類】
 *                   (0){0-5}
 *               /             \
 *          (1){0-2}           (2){3-5}
 *          /     \            /       \
 *      (3){0-1} (4){2-2}  (5){3-4} (6){5-5}
 *       /    \              /    \ 
 *  (7){0-0} (8){1-1}   (11){3-3} (12){4-4}
 * 
 * 
 * 計算索引 1 到 4 的區間和：
 * 先找到 {0-2}
 *  往下再找 {0-1}
 *   往下再找 {1-1} 得到 {1} 的值 3
 *  找 {2-2} 得到 {2} 的值 5
 * 
 * 找 {3-5}
 *  往下再找 {3-4} 得 {3, 4} 的值 16
 *  
 * 結束尋找
 * 將找到的值加總，總和為 24
 * 
 */

上述範例中，我們首先創建了一個 SegmentTree 類，並在建構函數中初始化數組 nums 和線段樹 tree。

然後，我們實現了線段樹的三個基本操作：buildTree 用於建立線段樹、query 用於執行區間查詢、update 用於修改數組中某個位置的值。

最後，我們使用測試數組 [1, 3, 5, 7, 9, 11] 創建了一個線段樹 segmentTree，並通過 query 方法計算了索引 1 到 4 的區間和。接著，我們使用 update 方法將索引 2 的值修改為 6，並再次使用 query 方法計算了索引 1 到 4 的區間和，驗證了修改操作的正確性。

這只是線段樹的一個基本實現示例，你可以根據需要進一步擴展和修改線段樹的功能，以滿足不同的區間操作需求。

解釋

              【以數字來分類】
            [1, 3, 5, 7, 9, 11]
             /              \
        [1, 3, 5]       [7, 9, 11] 
           /  \             /     \
        [1, 3] [5]       [7, 9]   [11]
         / \               /   \
       [1] [3]           [7]   [9] 



              【以 index 來分類】
        表達格式：(node 編號){index-index}

                  (0){0-5}
              /             \
         (1){0-2}           (2){3-5}
         /     \            /       \
     (3){0-1} (4){2-2}  (5){3-4} (6){5-5}
      /    \              /    \ 
 (7){0-0} (8){1-1}   (11){3-3} (12){4-4}


計算索引 1 到 4 的區間和：
先找到 {0-2}
 往下再找 {0-1}
  往下再找 {1-1} 得到 {1} 的值 3
 往回找 {2-2} 得到 {2} 的值 5

再來找 {3-5}
 往下再找 {3-4} 得 {3, 4} 的值 16 

結束尋找，將找到的值加總，總和為 24

參考資料

最後，如果你覺得我的分享對你有幫助，請給予我一個愛心，並且分享這篇文章，這將是對我最大的鼓勵！

資料結構：樹的分類

Tue, 27 Jun 2023 15:46:47 +0800

樹的分類

樹（Tree）作為一種常見的資料結構，隨著時間的推移，出現了多種不同的樹型結構，每一種都具有特定的優點和應用場景。以下是樹的演進史中一些重要的樹型結構：

二叉樹（Binary Tree）

二叉樹是最簡單且最基本的樹型結構。
每個節點最多有兩個子節點，分別稱為左子節點和右子節點。
二叉樹具有簡單的結構和易於實現的特點，但在某些情況下可能出現不平衡的情況，影響查找效率。

二叉搜索樹（Binary Search Tree）

二叉搜索樹在二叉樹的基礎上進一步定義了鍵的有序性。
對於任意節點，其左子樹中的所有鍵都小於節點的鍵，而右子樹中的所有鍵都大於節點的鍵。
這使得二叉搜索樹能夠快速進行查找、插入和刪除操作。然而，如果插入或刪除操作不當，可能導致樹的不平衡，影響性能。

平衡樹（Balanced Tree）

為了解決二叉搜索樹可能出現的不平衡問題，出現了多種平衡樹結構。
其中最經典的是紅黑樹（Red-Black Tree），它通過在二叉搜索樹的基礎上增加了額外的紅黑色屬性，保持了樹的平衡性。紅黑樹具有良好的平衡性和高效的查找、插入和刪除操作，被廣泛應用於各種應用中。
平衡樹（Balanced Tree）是一種廣泛的樹型資料結構，其中包括了許多種類的樹，如 AVL 樹、紅黑樹、B 樹、B+ 樹、B* 樹、2-3 樹等。
這些樹都有共同的性質：在進行插入或刪除操作時，能維持樹的平衡，也就是說，任意兩個葉節點之間的最長路徑和最短路徑的長度差是有限的。這樣的性質確保了在進行搜尋、插入、刪除等操作時，時間複雜度能維持在對數級別，提高了操作效率。

以下列出幾種平衡樹

AVL 樹（AVL Tree）
1. AVL樹是最早提出的自平衡二元搜尋樹。它通過維護每個節點的平衡因子（左子樹高度減去右子樹高度）在每次插入或刪除操作後進行旋轉調整，以確保樹保持平衡。
2. 【資料結構：平衡樹 (Balanced Tree) - AVL Tree】
紅黑樹（Red-Black Tree）
1. 通過在二叉搜索樹的基礎上增加了額外的紅黑色屬性，保持了樹的平衡性。
B樹（B-Tree, Balanced Sort Tree）
1. B樹是一種多路平衡搜索樹(查找路徑不止兩個)，特別適合處理大量的數據和磁盤存儲。B樹的特點是每個節點可以有多個子節點，並且可以容納多個鍵。
2. B樹通過調整節點的大小和節點的分裂合併策略，保持了樹的平衡性，同時提供了高效的插入、刪除和查找操作。
3. B樹廣泛應用於文件系統和數據庫等場景。
4. B樹相對平衡二叉樹在節點空間的利用率上進行改進，B樹在每個節點保存更多的數據，減少了樹的高度，從而提升了查找的性能，在數據庫應用中，B樹的每個節點存儲的數據量大約為4K, 這是因為考慮到磁盤數據存儲是採用塊的形式存儲的，每個塊的大小為4K，每次對磁盤進行IO數據讀取時，同一個磁盤塊的數據會被一次性讀取出來，所以每一次磁盤IO都可以讀取到B樹中一個節點的全部數據。
5. 一種特殊的 B 樹：2-3 樹
  1. 2-3 樹是一種特殊的 B 樹，其每個節點可以存儲 1 或 2 個值並且具有 2 或 3 個孩子節點，故名為 2-3 樹。
  2. 當一個節點的元素數量超過 2 個（即 3 個）時，則進行一次分裂，將中間的元素推送至父節點，並將原節點分裂為兩個節點。
  3. 由於 2-3 樹在插入和刪除操作時會進行動態調整，以確保所有葉子節點的深度保持一致，因此 2-3 樹是一種自平衡樹。
B+樹（B+ Tree）
1. B+樹是在B樹的基礎上又一次的改進，其主要對兩個方面進行了提升，一方面是查詢的穩定性，另外一方面是在數據排序方面更友好。
2. B+樹是在B樹基礎上進一步優化和擴展的一種結構。
3. 與B樹不同，B+樹將鍵值只存儲在葉子節點，內部節點只存儲鍵值的索引。這樣的設計使得B+樹具有更高的查找效率和更好的節點利用率。B+樹常用於關聯數據庫中的索引結構，能夠提供高效的範圍查詢和排序操作。
B* 樹
1. B* 樹又是對B+數的再一次改進，在B+樹的構建過程中，為了保持樹的平衡，節點的合併拆分是比較耗費時間的，所以B* 樹就是在如何減少構建中節點合併和拆分的次數，從而提升樹的數據插入、刪除性能。
2. B* 樹是 B 樹的一種變體，它和 B 樹相似，但在結構和調整規則上稍有不同。
3. 在 B* 樹中，非根和非葉子節點至少有 2/3 的子節點，這比 B 樹的一半多。此外，B* 樹在插入和刪除操作上也做了優化：在插入時，如果當前節點的子節點已經滿了，則會嘗試將數據轉移到相鄰的兄弟節點，只有當轉移無法完成時，才會分裂節點；在刪除時，如果該節點的子節點數少於最小值，則會嘗試從相鄰的兄弟節點借數據，只有當借用無法完成時，才會合併節點。這些優化使得 B* 樹的磁盤 I/O 操作相對較少，提高了效率。

B+ 樹和 B 樹的對比，來源：【平衡二叉樹、B樹、B+樹、B*樹理解其中一種你就都明白了】

B+ 樹查詢速度更穩定：B+ 所有關鍵字數據地址都存在葉子節點上，所以每次查找的次數都相同所以查詢速度要比B樹更穩定。
B+ 樹天然具備排序功能： B+ 樹所有的葉子節點數據構成了一個有序鍊錶，在查詢大小區間的數據時候更方便，數據緊密性很高，緩存的命中率也會比B樹高。
B+ 樹全節點遍歷更快： B+樹遍歷整棵樹只需要遍歷所有的葉子節點即可，而不需要像 B 樹一樣需要對每一層進行遍歷，這有利於數據庫做全表掃描。
B 樹相對於 B+ 樹的優點是，如果經常訪問的數據離根節點很近，而 B 樹的非葉子節點本身存有關鍵字和數據，所以在查詢這種數據檢索的時候會要比B+樹快。

堆（Heap）

一種特殊的樹結構，常用於實現優先級佇列。

字典樹（Trie）

一種用於有效儲存和檢索字符串的樹結構，也稱為前綴樹（Prefix Tree）。

哈夫曼樹（Huffman Tree）

一種用於無損數據壓縮的特殊二叉樹，將頻率較高的字符編碼為較短的位元串。

隨著技術的發展和需求的變化，還出現了其他種類的樹型結構，如AVL樹、Splay樹、Trie樹等，每種結構都針對不同的場景和需求進行了優化和改進。這些樹的演進史反映了對於高效查找和存儲的不斷追求和優化。

參考

【平衡二叉樹、B樹、B+樹、B*樹理解其中一種你就都明白了】

最後，如果你覺得我的分享對你有幫助，請給予我一個愛心，並且分享這篇文章，這將是對我最大的鼓勵！

資料結構：平衡樹 (Balanced Tree) - AVL Tree

Tue, 27 Jun 2023 07:15:40 +0800

AVL樹

AVL樹是最早提出的自平衡二元搜尋樹。它通過維護每個節點的平衡因子(左子樹高度減去右子樹高度)。
在每次插入或刪除操作後進行調整，以確保樹保持平衡。

AVL 樹由 Georgy Adelson-Velsky 和 Evgenii Landis 於 1962 年提出的一種自平衡二元搜尋樹。
它的平衡性通過維護每個節點的平衡因子（Balance Factor）來確保，該平衡因子表示左子樹高度減去右子樹高度的差值。

當在AVL樹中進行插入或刪除操作時，可能會破壞樹的平衡。
在這種情況下，需要通過旋轉操作來恢復平衡。旋轉操作分為左旋和右旋兩種：

左旋：當某個節點的右子樹高度過高時，進行左旋操作可以降低右子樹高度，同時提升該節點的左子樹高度。
右旋：當某個節點的左子樹高度過高時，進行右旋操作可以降低左子樹高度，同時提升該節點的右子樹高度。

這些旋轉操作的目的是保持樹的平衡，使得樹的高度始終保持在O(log n)的範圍內。儘管AVL樹提供了較嚴格的平衡性，但相對而言，它需要更多的旋轉操作，因此插入和刪除的成本較高。

以下是 AVL 樹進行平衡的規則

AVL 樹在插入或刪除節點後，可能會失去平衡，也就是某些節點的左子樹和右子樹的高度差超過 1。為了維護 AVL 樹的平衡性，我們需要進行旋轉操作。

左旋轉（Left Rotation）：
1. 條件：當一個節點的右子樹比左子樹高度多 2 層或以上時，我們進行左旋轉操作。
2. 作法：左旋轉可以將該節點的右子樹提升為新的根節點，同時將原根節點降低為新根節點的左子樹。這樣可以保持左子樹和右子樹的高度差不超過 1。
右旋轉（Right Rotation）：
1. 條件：當一個節點的左子樹比右子樹高度多 2 層或以上時，我們進行右旋轉操作。
2. 作法：右旋轉可以將該節點的左子樹提升為新的根節點，同時將原根節點降低為新根節點的右子樹。這樣可以保持左子樹和右子樹的高度差不超過 1。
左右旋轉（Left-Right Rotation）：
1. 條件：當一個節點的左子樹比右子樹高度多，且該節點的左子樹的右子樹比左子樹的左子樹高度多時，我們進行左右旋轉操作。
2. 作法：先對該節點的左子節點進行左旋轉，然後對原節點進行右旋轉。
右左旋轉（Right-Left Rotation）：
1. 條件：當一個節點的右子樹比左子樹高度多，且該節點的右子樹的左子樹比右子樹的右子樹高度多時，我們進行右左旋轉操作。
2. 作法：先對該節點的右子節點進行右旋轉，然後對原節點進行左旋轉。

這些旋轉操作可以調整 AVL 樹的結構，使其保持平衡。在進行插入或刪除操作後，我們需要檢查節點的平衡因子，即左子樹高度減去右子樹高度。

如果平衡因子大於 1，表示左子樹高於右子樹，則需要進行右旋轉或左右旋轉；
如果平衡因子小於 -1，表示右子樹高於左子樹，則需要進行左旋轉或右左旋轉。

通過這些旋轉操作，我們可以保持 AVL 樹的平衡性。

實作

class AVLNode {
  constructor(value) {
    this.value = value;
    this.left = null;
    this.right = null;
    this.height = 1;
  }
}

class AVLTree {
  constructor() {
    this.root = null;
  }

  // Helper function to get the height of a node
  getHeight(node) {
    if (node === null) return 0;
    return node.height;
  }

  // Helper function to update the height of a node
  updateHeight(node) {
    node.height = 1 + Math.max(this.getHeight(node.left), this.getHeight(node.right));
  }

  // Helper function to perform left rotation
  leftRotate(z) {
    const y = z.right;
    const T2 = y.left;

    y.left = z;
    z.right = T2;

    this.updateHeight(z);
    this.updateHeight(y);

    return y;
  }

  // Helper function to perform right rotation
  rightRotate(z) {
    const y = z.left;
    const T3 = y.right;

    y.right = z;
    z.left = T3;

    this.updateHeight(z);
    this.updateHeight(y);

    return y;
  }

  // Helper function to get the balance factor of a node
  getBalanceFactor(node) {
    if (node === null) return 0;
    return this.getHeight(node.left) - this.getHeight(node.right);
  }

  // Helper function to insert a value into the AVL tree
  insertHelper(node, value) {
    if (node === null) {
      return new AVLNode(value);
    }

    if (value < node.value) {
      node.left = this.insertHelper(node.left, value);
    } else if (value > node.value) {
      node.right = this.insertHelper(node.right, value);
    } else {
      // Duplicate values are not allowed in AVL tree
      return node;
    }

    this.updateHeight(node);

    const balanceFactor = this.getBalanceFactor(node);

    // Left Left Case
    if (balanceFactor > 1 && value < node.left.value) {
      return this.rightRotate(node);
    }

    // Right Right Case
    if (balanceFactor < -1 && value > node.right.value) {
      return this.leftRotate(node);
    }

    // Left Right Case
    if (balanceFactor > 1 && value > node.left.value) {
      node.left = this.leftRotate(node.left);
      return this.rightRotate(node);
    }

    // Right Left Case
    if (balanceFactor < -1 && value < node.right.value) {
      node.right = this.rightRotate(node.right);
      return this.leftRotate(node);
    }

    return node;
  }

  // Function to insert a value into the AVL tree
  insert(value) {
    this.root = this.insertHelper(this.root, value);
  }

}

參考資料

👍 大力推薦參考圖文並茂超完整圖解何時該左旋何時該右旋【JavaScript 學演算法（十五）- AVL-Tree】

最後，如果你覺得我的分享對你有幫助，請給予我一個愛心，並且分享這篇文章，這將是對我最大的鼓勵！

資料結構：字典樹或前綴樹 Trie

Mon, 19 Jun 2023 14:00:41 +0800

介紹

Trie（也稱為字典樹或前綴樹）是一種特殊的資料結構，用於高效地存儲和檢索字符串集合。
該結構的名稱來自於英文單詞「retrieval」的前三個字母。

Trie 使用一種樹狀結構來組織和存儲字符串。
每個節點代表一個字元，從根節點到葉節點的路徑形成一個字符串。
在 Trie 中，共享相同前綴的字符串共用相同的前綴節點，從而實現高效的儲存和檢索。

Trie 的主要優點是：

前綴匹配：Trie 可以非常快速地進行前綴匹配，這使得它在許多字符串檢索的應用中非常有用。例如，你可以使用 Trie 在一個大型字典中快速查詢以特定前綴開始的單詞。
空間效率：儘管 Trie 在存儲字符串集合時可能需要較多的內存，但當字符串共享相同前綴時，Trie 可以有效地壓縮存儲空間，減少重複數據的存儲。
插入和查詢效率：Trie 的插入和查詢操作的時間複雜度都是 O(m)，其中 m 是字符串的平均長度。這使得 Trie 在需要高效的插入和查詢操作的情況下非常有用。

Trie 的基本結構由節點和指向子節點的指針組成。每個節點包含一個字符和一個指向下一級節點的指針數組（通常是一個數組，索引對應於字符集中的字符）。
此外，每個節點還可以包含其他有關字符串的訊息，例如計數器或標記，以滿足特定的應用需求。

基本的插入和查詢操作

Trie 的插入操作非常簡單，只需按照字符串的每個字符在 Trie 中進行遞歸查找。如果遇到缺少的字符，則創建相應的節點。當達到字符串的結尾時，可以在終止節點中標記該字符串的結束。
Trie 的查詢操作也很簡單，只需按照要查詢的字符串的每個字符在 Trie 中進行遞歸查找。如果遇到缺少的字符或到達了 Trie 的結尾，則可以確定該字符串不在 Trie 中。否則，繼續遞歸查找直到字符串的結尾。

除了基本的插入和查詢操作，Trie 還可以進行前綴匹配、模式匹配和字典排序等操作。

總之，Trie 是一種非常有用的資料結構，特別適合處理字符串集合和字典應用。
它提供了高效的插入、查詢和前綴匹配功能，同時具有優秀的空間壓縮性能。

實作


class TrieNode {
    constructor() {
        this.children = {};
        this.isEndOfWord = false;
    }
}

class Trie {
    constructor() {
        this.root = new TrieNode();
    }

    insert(word) {
        let current = this.root;

        for (let i = 0; i < word.length; i++) {
            const char = word[i];

            if (!current.children[char]) {
                current.children[char] = new TrieNode();
            }

            current = current.children[char];
        }

        current.isEndOfWord = true;
    }

    search(word) {
        let current = this.root;

        for (let i = 0; i < word.length; i++) {
            let char = word[i];
            if (!current.children[char]) {
                return false;// 字符不存在，該字符串不在 Trie 中
            }

            current = current.children[char];
        }

        return current.isEndOfWord;// 判斷是否為一個完整的單詞
    }

    startsWith(prefix) {
        let current = this.root;
        for (let i = 0; i < prefix.length; i++) {
            let char = prefix[i];
            if (!current.children[char]) {
                return false; // 字符不存在，該前綴不在 Trie 中
            }
            current = current.children[char];
        }
        return true; // 所有前綴字符都存在於 Trie 中
    }

}

// 使用示例
const trie = new Trie();
trie.insert("apple");
trie.insert("banana");
trie.insert("cat");
console.log(JSON.stringify(trie));
/**
{"root":{"children":{
"a":{"children":{"p":{"children":{"p":{"children":{"l":{"children":{"e":{"children":{},"isEndOfWord":true}},"isEndOfWord":false}},"isEndOfWord":false}},"isEndOfWord":false}},"isEndOfWord":false},
"b":{"children":{"a":{"children":{"n":{"children":{"a":{"children":{"n":{"children":{"a":{"children":{},"isEndOfWord":true}},"isEndOfWord":false}},"isEndOfWord":false}},"isEndOfWord":false}},"isEndOfWord":false}},"isEndOfWord":false},
"c":{"children":{"a":{"children":{"t":{"children":{},"isEndOfWord":true}},"isEndOfWord":false}},"isEndOfWord":false}},"isEndOfWord":false}}
*/

console.log(trie.search("apple")); // true
console.log(trie.search("banana")); // true
console.log(trie.search("cat")); // true
console.log(trie.search("dog")); // false

console.log(trie.startsWith("app")); // true
console.log(trie.startsWith("ban")); // true
console.log(trie.startsWith("ca")); // true
console.log(trie.startsWith("do")); // false

說明

在 insert 方法中，我們從根節點開始遍歷 Trie。對於要插入的每個字符，我們檢查它是否已經在當前節點的子節點中存在。
如果不存在，我們創建一個新的節點並將其添加到子節點中。然後，我們將當前節點移至新創建的節點，繼續處理下一個字符。
當處理完所有字符後，我們將最後一個字符的 isEndOfWord 屬性設置為 true，以標記字符串的結束。
search 方法用於檢查給定的字符串是否存在於 Trie 中。我們從根節點開始遍歷 Trie，對於字符串的每個字符，我們檢查它是否存在於當前節點的子節點中。
如果遍歷完所有字符後，最後一個節點的 isEndOfWord 屬性為 true，則表示該字符串存在於 Trie 中。
startsWith 方法用於檢查是否存在以給定前綴開頭的字符串。過程與 search 方法類似，我們遍歷前綴的每個字符，檢查它們是否存在於當前節點的子節點中。
如果遍歷完所有前綴字符後，所有字符都存在於 Trie 中，則表示該前綴存在。

總結

Trie 來自於英文單詞「retrieval」，用於高效地存儲和檢索字符串集合。
每個節點代表一個字符，以及從根節點到葉節點的路徑形成一個字符串。同時，共享相同前綴的字符串共用相同的前綴節點。
關於 Trie 的優點：前綴匹配、空間效率，以及插入和查詢效率。
您對 Trie 節點的組成以及 Trie 插入和查詢操作的描述。
Trie 確實可以進行前綴匹配、模式匹配和字典排序等高級操作。
是一種非常有用的資料結構，特別適合處理字符串集合和字典應用，具有高效的插入、查詢和前綴匹配功能，同時具有優秀的空間壓縮性能。

最後，如果你覺得我的分享對你有幫助，請給予我一個愛心，並且分享這篇文章，這將是對我最大的鼓勵！

當你想要學習資料結構時，以下是一些建議的學習列表

Sat, 17 Jun 2023 10:21:51 +0800

介紹

當你想要學習資料結構時，以下是一些建議的學習列表：

陣列 (Array): 學習如何使用陣列存儲和訪問資料，以及陣列的基本操作，如插入、刪除和搜尋。
串列 (Linked List): 學習如何使用串列結構來組織和存儲資料，並理解串列的插入、刪除和搜尋操作。
堆疊 (Stack): 學習堆疊的概念和操作，包括推入 (push) 和彈出 (pop) 元素，以及堆疊的應用場景。
佇列 (Queue): 學習佇列的概念和操作，包括入列 (enqueue) 和出列 (dequeue) 元素，以及佇列的應用場景。
樹 (Tree): 學習樹的基本結構、遍歷方法 (如前序、中序和後序遍歷)，以及二元樹、二元搜索樹和平衡樹等特殊類型的樹。
圖 (Graph): 學習圖的基本結構和表示方法，以及圖的遍歷、搜索和最短路徑算法，如深度優先搜索 (DFS) 和廣度優先搜索 (BFS)。
哈希表 (Hash Table): 學習哈希表的原理和實現，理解哈希函數、碰撞解決方法和哈希表的查找和插入操作。
堆積 (Heap): 學習堆積的概念和操作，包括最大堆和最小堆，以及堆排序和優先級佇列的應用。
鏈接 (Hashing): 學習散列的概念和操作，包括散列函數、碰撞解決方法和散列表的查找和插入操作。
圖算法 (Graph Algorithms): 學習常見的圖算法，如最短路徑算法 (如Dijkstra和Bellman-Ford)、最小生成樹算法 (如Prim和Kruskal) 和拓撲排序。
字典樹 (Trie): 學習字典樹的概念和操作，特別適用於字串搜索和自動補全等應用。
平衡樹 (Balanced Tree): 學習平衡樹的概念和實現，如紅黑樹和AVL樹，了解平衡樹的插入、刪除和查找操作。
圖示演算法 (Graphical Algorithms): 學習用於圖示設計和模擬的算法，如迭代深化深度優先搜索 (IDDFS)。
雜湊圖 (Hashgraph): 學習分佈式共識機制的一種形式，可以實現高性能和安全性的分佈式資料結構。
高級資料結構 (Advanced Data Structures): 學習一些高級的資料結構，如B+樹、約瑟夫問題、線段樹、樹狀數組等。

總結

這些只是一些常見的資料結構，你可以根據自己的興趣和需求進一步深入學習。
此外，建議你閱讀相關的教科書或參考網上的資源，並通過編寫程式來實踐這些資料結構，以加深你的理解和熟練程度。

最後，如果你覺得我的分享對你有幫助，請給予我一個愛心，並且分享這篇文章，這將是對我最大的鼓勵！