[Swift]LeetCode173. 二叉搜索树迭代器 | Binary Search Tree Iterator

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

Implement an iterator over a binary search tree (BST). Your iterator will be initialized with the root node of a BST.

Calling next() will return the next smallest number in the BST.

Note: next() and hasNext() should run in average O(1) time and uses O(h) memory, where h is the height of the tree.

---

实现一个二叉搜索树迭代器。你将使用二叉搜索树的根节点初始化迭代器。

调用 next() 将返回二叉搜索树中的下一个最小的数。

注意: next() 和hasNext() 操作的时间复杂度是O(1)，并使用 O(h) 内存，其中 h 是树的高度。

---

212ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */

class BSTIterator {
    
    //we need a storage to store the values
    //let's define an array
    private var storage = [Int]()
    
    //we also need a counter to run the iterator
    private var counter = -1
    
    //we need to traverse in an inorder fashion and store the elements
    //in the storage
    private func traverseInorder(_ root: TreeNode?) {
        if root == nil { return }
        traverseInorder(root!.left)
        storage.append(root!.val)
        traverseInorder(root!.right)
    }

    init(_ root: TreeNode?) {
        traverseInorder(root)
    }
    
    /** @return the next smallest number */
    func next() -> Int {
        if hasNext() {
            counter += 1
            return storage[counter]
        }
        return -1
    }
    
    /** @return whether we have a next smallest number */
    func hasNext() -> Bool {
        if counter < storage.count - 1{
            return true
        }
        return false
    }
}

---

216ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */

class BSTIterator {

    private var stack = [TreeNode]()

    // MARK: - Initialization

    init(_ root: TreeNode?) {
        var curr = root
        while let node = curr {
            stack.append(node)
            curr = node.left
        }
    }

    // MARK: - Iterator methods

    func next() -> Int {
        guard let node = stack.popLast() else { fatalError("No values to iterate over") }
        var curr = node.right
        while let new = curr {
            stack.append(new)
            curr = new.left
        }

        return node.val
    }

    func hasNext() -> Bool {
        return !stack.isEmpty
    }
}

/**
 * Your BSTIterator object will be instantiated and called as such:
 * let obj = BSTIterator(root)
 * let ret_1: Int = obj.next()
 * let ret_2: Bool = obj.hasNext()
 */

---

220ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */

class BSTIterator {

      var nodesArray = [TreeNode?]()
  
      init(_ root: TreeNode?) {

        var node = root

        while node != nil {
          nodesArray.append(node)
          node = node?.left
        }
      }

      /** @return the next smallest number */
      func next() -> Int {

        var lastNode = nodesArray.removeLast()
        let nextValue = lastNode?.val ?? 0

        lastNode = lastNode?.right

        while lastNode != nil {
          nodesArray.append(lastNode)
          lastNode = lastNode?.left
        }

        return nextValue
      }

      /** @return whether we have a next smallest number */
      func hasNext() -> Bool {
        return !nodesArray.isEmpty
      }
}

/**
 * Your BSTIterator object will be instantiated and called as such:
 * let obj = BSTIterator(root)
 * let ret_1: Int = obj.next()
 * let ret_2: Bool = obj.hasNext()
 */

---

224ms

class BSTIterator {
    var stack : Array<TreeNode?> = []
    init(_ root: TreeNode?) {
        addElements(root)
    }
    
    /** @return the next smallest number */
    func next() -> Int {
        let node = stack.popLast()!
        addElements(node?.right)
        return (node?.val)!
    }
    
    /** @return whether we have a next smallest number */
    func hasNext() -> Bool {
        return !stack.isEmpty
    }
    func addElements(_ root : TreeNode?)  {
        if nil != root {
            var temp : TreeNode? = root
            while nil != temp {
                stack.append(temp)
                temp = temp?.left
            }
        }
    }
}

---

228ms

class BSTIterator {

    var nodes:[TreeNode] = [TreeNode]()
    
    init(_ root: TreeNode?) {
        loadTree(root)
    }
    
    private func loadTree(_ node:TreeNode?){
        
        guard let node = node else{
            return
        }
        
        loadTree(node.left)
        nodes.append(node)
        loadTree(node.right)
    }
    /** @return the next smallest number */

    func next() -> Int {
        return self.nodes.removeFirst().val
    }
    /** @return whether we have a next smallest number */

    func hasNext() -> Bool {
        return self.nodes.count > 0
    }
}

---

236ms

class BSTIterator {

    var fakeQueue = [Int]()
    
    init(_ root: TreeNode?) {
        constructFakeQueue(root, &fakeQueue)
    }
    
    /** @return the next smallest number */
    func next() -> Int {
        return fakeQueue.removeFirst()
    }
    
    /** @return whether we have a next smallest number */
    func hasNext() -> Bool {
        return fakeQueue.isEmpty == false
    }
    
    // In order traversal to store vals
    private func constructFakeQueue(_ root: TreeNode?, _ fakeQueue: inout [Int]) {
        if root == nil {
            return
        }
        
        constructFakeQueue(root?.left, &fakeQueue)
        fakeQueue.append((root?.val)!)
        constructFakeQueue(root?.right, &fakeQueue)
    }
}

---

240ms

class BSTIterator {
    var root: TreeNode?
    var stack: [TreeNode?]
    init(_ root: TreeNode?) {
        self.root = root 
        self.stack = [TreeNode?]()
        helper(root)
    }
    
    /** @return the next smallest number */
    func next() -> Int {
        let n = stack.removeLast()
        helper(n!.right)
        return n!.val
        
    }
    func helper(_ root: TreeNode?) {
        var root = root
        while root != nil {
            self.stack.append(root)
            root = root!.left
        }
    }
    
    /** @return whether we have a next smallest number */
    func hasNext() -> Bool {
        return !stack.isEmpty
    }
}

---

244ms

class BSTIterator {
    
    //we need a storage to store the values
    //let's define an array
    private var storage = [Int]()
    
    //we also need a counter to run the iterator
    private var counter = -1
    
    //we need to traverse in an inorder fashion and store the elements
    //in the storage
    private func traverseInorder(_ root: TreeNode?) {
        if root == nil { return }
        traverseInorder(root!.left)
        storage.append(root!.val)
        traverseInorder(root!.right)
    }
    
    //let's also write traverseInorder iteratively
    private func traverseInorderIt(_ root: TreeNode?) {
        if root == nil { return }
        var root = root
        var stack = [TreeNode]()
        
        while root != nil || !stack.isEmpty {
            if root != nil {
                stack.append(root!)
                root = root!.left
            } else {
                root = stack.removeLast()
                storage.append(root!.val)
                root = root!.right
            }
        } 
    }

    init(_ root: TreeNode?) {
        //traverseInorder(root)
        traverseInorderIt(root)
    }
    
    /** @return the next smallest number */
    func next() -> Int {
        if hasNext() {
            counter += 1
            return storage[counter]
        }
        return -1
    }
    
    /** @return whether we have a next smallest number */
    func hasNext() -> Bool {
        if counter < storage.count - 1{
            return true
        }
        return false
    }
}

---

264ms

class BSTIterator {
    
    var all = [TreeNode]()
    var currentIndex = 0
    
    init(_ root: TreeNode?) {
        self.dfs(root)
    }
    /** @return the next smallest number */

    func next() -> Int {
        guard self.currentIndex < self.all.count else { return -1 }
        let next = all[self.currentIndex]
        self.currentIndex += 1
        return next.val
        
    }
    /** @return whether we have a next smallest number */

    func hasNext() -> Bool {
        return self.currentIndex < self.all.count
    }
    
    private func dfs(_ root: TreeNode?) {
        guard let node = root else { return }
        dfs(node.left)
        self.all.append(node)
        dfs(node.right)
    }
}