[Swift]LeetCode208. 实现 Trie (前缀树) | Implement Trie (Prefix Tree)

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10187360.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Implement a trie with insert, search, and startsWith methods.

Example:

Trie trie = new Trie();

trie.insert("apple");
trie.search("apple");   // returns true
trie.search("app");     // returns false
trie.startsWith("app"); // returns true
trie.insert("app");   
trie.search("app");     // returns true

Note:

• You may assume that all inputs are consist of lowercase letters a-z.
• All inputs are guaranteed to be non-empty strings.

---

实现一个 Trie (前缀树)，包含 insert, search, 和 startsWith 这三个操作。

示例:

Trie trie = new Trie();

trie.insert("apple");
trie.search("apple");   // 返回 true
trie.search("app");     // 返回 false
trie.startsWith("app"); // 返回 true
trie.insert("app");   
trie.search("app");     // 返回 true

说明:

• 你可以假设所有的输入都是由小写字母 a-z 构成的。
• 保证所有输入均为非空字符串。

---

424ms

class Node {
    var wordEnd = false
    var next : [Character : Node] = [:]
}

class Trie {
    let root = Node()
    /** Initialize your data structure here. */
    init() {
        
    }
    
    /** Inserts a word into the trie. */
    func insert(_ word: String) {
      var currentNode = root
        for c in word {
            if let nextNode = currentNode.next[c] {
                currentNode = nextNode
            } else {
                let nextNode = Node()
                currentNode.next[c] = nextNode
                currentNode = nextNode
            }
        }
        currentNode.wordEnd = true
    }
    
    /** Returns if the word is in the trie. */
    func search(_ word: String) -> Bool {
      var currentNode = root
      for c in word {
          if let node = currentNode.next[c] {
              currentNode = node
          } else {
              return false
          }
      }
        return currentNode.wordEnd
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    func startsWith(_ prefix: String) -> Bool {
      var currentNode = root
      for c in prefix {
          if let node = currentNode.next[c] {
              currentNode = node
          } else {
              return false
          }
      }
        return true
    }
}

/**
 * Your Trie object will be instantiated and called as such:
 * let obj = Trie()
 * obj.insert(word)
 * let ret_2: Bool = obj.search(word)
 * let ret_3: Bool = obj.startsWith(prefix)
 */
 

---

432ms

class Node {
    var ch: Character
    var children: [Node?]
    var isWord: Bool
    init () {
        self.ch = "*"
        self.children = Array(repeating: nil, count: 26)
        self.isWord = false
    }
        
    init (_ ch: Character) {
        self.ch = ch
        self.children = Array(repeating: nil, count: 26)
        self.isWord = false
    }
}
class Trie {

    private var root: Node
    /** Initialize your data structure here. */
    init() {
        root = Node()
    }
    
    /** Inserts a word into the trie. */
    func insert(_ word: String) {
        var cur = root
          for c in word {
              if let node = cur.children[c.toValue - 97] {
                  cur = node
              }
              else {
                  let node = Node(c)
                  cur.children[c.toValue - 97] = node
                  cur = node
              }
          }
        cur.isWord = true
        
    }
    
    /** Returns if the word is in the trie. */
    func search(_ word: String) -> Bool {
        var cur = root
          for c in word {
              if let node = cur.children[c.toValue - 97] {
                  cur = node
              }
              else {
                  return false
              }
          }
        return cur.isWord == true   
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    func startsWith(_ prefix: String) -> Bool {
              var cur = root
          for c in prefix {
              if let node = cur.children[c.toValue - 97] {
                  cur = node
              }
              else {
                  return false
              }
          }
        return  true    
    }
}
extension Character {
    var toValue: Int {
        let characterString = String(self)
        let scalars = characterString.unicodeScalars

        return Int(scalars[scalars.startIndex].value)
    }
}
/**
 * Your Trie object will be instantiated and called as such:
 * let obj = Trie()
 * obj.insert(word)
 * let ret_2: Bool = obj.search(word)
 * let ret_3: Bool = obj.startsWith(prefix)
 */
 

---

436ms

class Trie {

    class TrieNode {
        let val: Character
        var childs = [Character: TrieNode]()
        
        init(_ val: Character) {
            self.val = val
        }
    }
    
    let trie = TrieNode("0")
    
    /** Initialize your data structure here. */
    init() {
        
    }
    
    /** Inserts a word into the trie. */
    func insert(_ word: String) {
        var current = trie
        for c in word+"#" {
            if let child = current.childs[c] {
                current = child
            } else {
                let new = TrieNode(c)
                current.childs[c] = new
                current = new
            }
        }
    }
    
    /** Returns if the word is in the trie. */
    func search(_ word: String) -> Bool {
        var current = trie
        for c in word+"#" {
            if let child = current.childs[c] {
                current = child
            } else {
                return false
            }
        }
      
        return current.childs.isEmpty
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    func startsWith(_ prefix: String) -> Bool {
      var current = trie
        for c in prefix {
            if let child = current.childs[c] {
                current = child
            } else {
                return false
            }
        }
      
        return true
    }
}

/**
 * Your Trie object will be instantiated and called as such:
 * let obj = Trie()
 * obj.insert(word)
 * let ret_2: Bool = obj.search(word)
 * let ret_3: Bool = obj.startsWith(prefix)
 */
 

---

452ms

class TrieNode
{
    var child:[TrieNode?]
    var isWord:Bool = false
    init()
    {
        child = [TrieNode?](repeating:nil,count:26)
    }
}


class Trie {
    var root:TrieNode?

    /** Initialize your data structure here. */
    init() {
        root = TrieNode()
    }
    
    /** Inserts a word into the trie. */
    func insert(_ word: String) {
        var p:TrieNode? = root
        for a in word.characters
        {
            var i:Int = a.ascii - 97
            if p!.child[i] == nil
            {
                p!.child[i] = TrieNode()
            }
            p = p!.child[i]
        }
        p!.isWord = true
    }
    
    /** Returns if the word is in the trie. */
    func search(_ word: String) -> Bool {
        var p:TrieNode? = root
        for a in word.characters
        {
            var i:Int = a.ascii - 97
            if p?.child[i] == nil
            {
               return false
            }
            p = p!.child[i]
        }
        return p!.isWord
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    func startsWith(_ prefix: String) -> Bool {
        var p:TrieNode? = root
        for a in prefix.characters
        {
            var i:Int = a.ascii - 97
            if p?.child[i] == nil
            {
               return false
            }
            p = p!.child[i]
        }
        return true
    }
}

//Character扩展方法  
extension Character  
{  
  //属性：ASCII整数值(定义小写为整数值)
   var ascii: Int {
        get {
            let s = String(self).unicodeScalars
            return Int(s[s.startIndex].value)
        }
    }
}
/**
 * Your Trie object will be instantiated and called as such:
 * let obj = Trie()
 * obj.insert(word)
 * let ret_2: Bool = obj.search(word)
 * let ret_3: Bool = obj.startsWith(prefix)
 */
 

---

460ms

class Trie {
    /** Initialize your data structure here. */
    init() {
        
    }
    
    /** Inserts a word into the trie. */
    func insert(_ word: String) {
        var root = self.root
        
        let unicodeScalars = Array(word.utf8)
        
        for character in unicodeScalars {
            let ascii = Int(character - 97)
            
            if root.children[ascii] == nil {
                
                root.children[ascii] = TrieNode(String(character))
            }
            
            root = root.children[ascii]!
        }
        root.isEnd = true
    }
    
    /** Returns if the word is in the trie. */
    func search(_ word: String) -> Bool {
        var root = self.root
        
        let unicodeScalars = Array(word.utf8)
        
        for character in unicodeScalars {
            let ascii = Int(character - 97)
            
            guard let node = root.children[ascii] else {
                return false
            }
            root = node
        }
        
        return root.isEnd
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    func startsWith(_ prefix: String) -> Bool {
        var root = self.root
        
        let unicodeScalars = Array(prefix.utf8)
        
        for character in unicodeScalars {
            let ascii = Int(character - 97)
            
            guard let node = root.children[ascii] else {
                return false
            }
            root = node
        }
        
        return true
    }
    
    var root = TrieNode("")
    
}

class TrieNode {
    
    init(_ value: String) {
        self.value = value
    }
    
    var value : String
    
    
    var isEnd = false
    
    var children : [TrieNode?] = Array(repeating: nil, count: 26)
    
}

/**
 * Your Trie object will be instantiated and called as such:
 * let obj = Trie()
 * obj.insert(word)
 * let ret_2: Bool = obj.search(word)
 * let ret_3: Bool = obj.startsWith(prefix)
 */