feat: add solutions to lc/lcof2 problems

lc No.0208 & lcof2 No.062. Implement Trie (Prefix Tree)

Author: yanglbme

lcof2/剑指 Offer II 062. 实现前缀树/README.md

@@ -52,27 +52,363 @@ trie.search("app");     // 返回 True
 
 <p><meta charset="UTF-8" />注意：本题与主站 208 题相同：<a href="https://leetcode-cn.com/problems/implement-trie-prefix-tree/">https://leetcode-cn.com/problems/implement-trie-prefix-tree/</a>&nbsp;</p>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
 
+前缀树每个节点包括两部分：
+
+1. 指向子节点的指针数组 children，对于本题而言，数组长度为 26，即小写英文字母的数量。`children[0]` 对应小写字母 a，...，`children[25]` 对应小写字母 z。
+1. 布尔字段 `isEnd`，表示该节点是否为字符串的结尾。
+
+### 1. 插入字符串
+
+我们从字典树的根开始，插入字符串。对于当前字符对应的子节点，有两种情况：
+
+- 子节点存在。沿着指针移动到子节点，继续处理下一个字符。
+- 子节点不存在。创建一个新的子节点，记录在 `children` 数组的对应位置上，然后沿着指针移动到子节点，继续搜索下一个字符。
+
+重复以上步骤，直到处理字符串的最后一个字符，然后将当前节点标记为字符串的结尾。
+
+### 2. 查找前缀
+
+我们从字典树的根开始，查找前缀。对于当前字符对应的子节点，有两种情况：
+
+- 子节点存在。沿着指针移动到子节点，继续搜索下一个字符。
+- 子节点不存在。说明字典树中不包含该前缀，返回空指针。
+
+重复以上步骤，直到返回空指针或搜索完前缀的最后一个字符。
+
+若搜索到了前缀的末尾，就说明字典树中存在该前缀。此外，若前缀末尾对应节点的 `isEnd` 为真，则说明字典树中存在该字符串。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
+class Trie:
+
+    def __init__(self):
+        self.children = [None] * 26
+        self.is_end = False
 
+    def insert(self, word: str) -> None:
+        node = self
+        for c in word:
+            idx = ord(c) - ord('a')
+            if node.children[idx] is None:
+                node.children[idx] = Trie()
+            node = node.children[idx]
+        node.is_end = True
+
+    def search(self, word: str) -> bool:
+        node = self._search_prefix(word)
+        return node is not None and node.is_end
+
+    def startsWith(self, prefix: str) -> bool:
+        node = self._search_prefix(prefix)
+        return node is not None
+
+    def _search_prefix(self, prefix: str):
+        node = self
+        for c in prefix:
+            idx = ord(c) - ord('a')
+            if node.children[idx] is None:
+                return None
+            node = node.children[idx]
+        return node
+
+# Your Trie object will be instantiated and called as such:
+# obj = Trie()
+# obj.insert(word)
+# param_2 = obj.search(word)
+# param_3 = obj.startsWith(prefix)
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Trie {
+    private Trie[] children;
+    private boolean isEnd;
+
+    public Trie() {
+        children = new Trie[26];
+    }
+    
+    public void insert(String word) {
+        Trie node = this;
+        for (char c : word.toCharArray()) {
+            int idx = c - 'a';
+            if (node.children[idx] == null) {
+                node.children[idx] = new Trie();
+            }
+            node = node.children[idx];
+        }
+        node.isEnd = true;
+    }
+    
+    public boolean search(String word) {
+        Trie node = searchPrefix(word);
+        return node != null && node.isEnd;
+    }
+    
+    public boolean startsWith(String prefix) {
+        Trie node = searchPrefix(prefix);
+        return node != null;
+    }
+
+    private Trie searchPrefix(String s) {
+        Trie node = this;
+        for (char c : s.toCharArray()) {
+            int idx = c - 'a';
+            if (node.children[idx] == null) {
+                return null;
+            }
+            node = node.children[idx];
+        }
+        return node;
+    }
+}
+
+/**
+ * Your Trie object will be instantiated and called as such:
+ * Trie obj = new Trie();
+ * obj.insert(word);
+ * boolean param_2 = obj.search(word);
+ * boolean param_3 = obj.startsWith(prefix);
+ */
+```
+
+### **JavaScript**
+
+```js
+/**
+ * Initialize your data structure here.
+ */
+var Trie = function() {
+    this.children = {};
+};
+
+/**
+ * Inserts a word into the trie. 
+ * @param {string} word
+ * @return {void}
+ */
+Trie.prototype.insert = function(word) {
+    let node = this.children;
+    for (let char of word) {
+        if (!node[char]) {
+            node[char] = {};
+        }
+        node = node[char];
+    }
+    node.isEnd = true;
+};
+
+/**
+ * Returns if the word is in the trie. 
+ * @param {string} word
+ * @return {boolean}
+ */
+Trie.prototype.search = function(word) {
+    let node = this.searchPrefix(word);
+    return node != undefined && node.isEnd != undefined;
+};
+
+Trie.prototype.searchPrefix = function (prefix) {
+    let node = this.children;
+    for (let char of prefix) {
+        if (!node[char]) return false;
+        node = node[char];
+    }
+    return node;
+}
+
+/**
+ * Returns if there is any word in the trie that starts with the given prefix. 
+ * @param {string} prefix
+ * @return {boolean}
+ */
+Trie.prototype.startsWith = function(prefix) {
+    return this.searchPrefix(prefix);
+};
+
+/**
+ * Your Trie object will be instantiated and called as such:
+ * var obj = new Trie()
+ * obj.insert(word)
+ * var param_2 = obj.search(word)
+ * var param_3 = obj.startsWith(prefix)
+ */
+```
+
+### **C++**
+
+```cpp
+class Trie {
+private:
+    vector<Trie*> children;
+    bool isEnd;
+
+    Trie* searchPrefix(string s) {
+        Trie* node = this;
+        for (char c : s)
+        {
+            int idx = c - 'a';
+            if (!node->children[idx]) return nullptr;
+            node = node->children[idx];
+        }
+        return node;
+    }
+
+public:
+    Trie() : children(26), isEnd(false) {}
+    
+    void insert(string word) {
+        Trie* node = this;
+        for (char c : word)
+        {
+            int idx = c - 'a';
+            if (!node->children[idx]) node->children[idx] = new Trie();
+            node = node->children[idx];
+        }
+        node->isEnd = true;
+    }
+    
+    bool search(string word) {
+        Trie* node = searchPrefix(word);
+        return node != nullptr && node->isEnd;
+    }
+    
+    bool startsWith(string prefix) {
+        Trie* node = searchPrefix(prefix);
+        return node != nullptr;
+    }
+};
+
+/**
+ * Your Trie object will be instantiated and called as such:
+ * Trie* obj = new Trie();
+ * obj->insert(word);
+ * bool param_2 = obj->search(word);
+ * bool param_3 = obj->startsWith(prefix);
+ */
+```
+
+### **Go**
+
+```go
+type Trie struct {
+	children [26]*Trie
+	isEnd    bool
+}
+
+func Constructor() Trie {
+	return Trie{}
+}
+
+func (this *Trie) Insert(word string) {
+	node := this
+	for _, c := range word {
+		idx := c - 'a'
+		if node.children[idx] == nil {
+			node.children[idx] = &Trie{}
+		}
+		node = node.children[idx]
+	}
+	node.isEnd = true
+}
+
+func (this *Trie) Search(word string) bool {
+	node := this.SearchPrefix(word)
+	return node != nil && node.isEnd
+}
+
+func (this *Trie) StartsWith(prefix string) bool {
+	node := this.SearchPrefix(prefix)
+	return node != nil
+}
+
+func (this *Trie) SearchPrefix(s string) *Trie {
+	node := this
+	for _, c := range s {
+		idx := c - 'a'
+		if node.children[idx] == nil {
+			return nil
+		}
+		node = node.children[idx]
+	}
+	return node
+}
+
+/**
+ * Your Trie object will be instantiated and called as such:
+ * obj := Constructor();
+ * obj.Insert(word);
+ * param_2 := obj.Search(word);
+ * param_3 := obj.StartsWith(prefix);
+ */
+```
+
+### **C#**
+
+```cs
+public class Trie {
+    bool isEnd;
+    Trie[] children = new Trie[26];
+
+    public Trie() {
+
+    }
+
+    public void Insert(string word) {
+        Trie node = this;
+        foreach (var c in word)
+        {
+            var idx = c - 'a';
+            node.children[idx] ??= new Trie();
+            node = node.children[idx];
+        }
+        node.isEnd = true;
+    }
+
+    public bool Search(string word) {
+        Trie node = SearchPrefix(word);
+        return node != null && node.isEnd;
+    }
+
+    public bool StartsWith(string prefix) {
+        Trie node = SearchPrefix(prefix);
+        return node != null;
+    }
+
+    private Trie SearchPrefix(string s) {
+        Trie node = this;
+        foreach (var c in s)
+        {
+            var idx = c - 'a';
+            if (node.children[idx] == null)
+            {
+                return null;
+            }
+            node = node.children[idx];
+        }
+        return node;
+    }
+}
 
+/**
+ * Your Trie object will be instantiated and called as such:
+ * Trie obj = new Trie();
+ * obj.Insert(word);
+ * bool param_2 = obj.Search(word);
+ * bool param_3 = obj.StartsWith(prefix);
+ */
 ```
 
 ### **...**