[Swift]LeetCode919. 完全二叉树插入器 | Complete Binary Tree Inserter

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

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

A complete binary tree is a binary tree in which every level, except possibly the last, is completely filled, and all nodes are as far left as possible.

Write a data structure CBTInserter that is initialized with a complete binary tree and supports the following operations:

• CBTInserter(TreeNode root) initializes the data structure on a given tree with head node root;
• CBTInserter.insert(int v) will insert a TreeNode into the tree with value node.val = v so that the tree remains complete, and returns the value of the parent of the inserted TreeNode;
• CBTInserter.get_root() will return the head node of the tree.

Example 1:

Input: inputs = ["CBTInserter","insert","get_root"], inputs = [[[1]],[2],[]]
Output: [null,1,[1,2]]

Example 2:

Input: inputs = ["CBTInserter","insert","insert","get_root"], inputs = [[[1,2,3,4,5,6]],[7],[8],[]]
Output: [null,3,4,[1,2,3,4,5,6,7,8]]

Note:

1. The initial given tree is complete and contains between 1 and 1000 nodes.
2. CBTInserter.insert is called at most 10000 times per test case.
3. Every value of a given or inserted node is between 0 and 5000.

---

完全二叉树是每一层（除最后一层外）都是完全填充（即，结点数达到最大）的，并且所有的结点都尽可能地集中在左侧。

设计一个用完全二叉树初始化的数据结构 CBTInserter，它支持以下几种操作：

• CBTInserter(TreeNode root) 使用头结点为 root 的给定树初始化该数据结构；
• CBTInserter.insert(int v) 将 TreeNode 插入到存在值为 node.val = v  的树中以使其保持完全二叉树的状态，并返回插入的 TreeNode 的父结点的值；
• CBTInserter.get_root() 将返回树的头结点。

示例 1：

输入：inputs = ["CBTInserter","insert","get_root"], inputs = [[[1]],[2],[]]
输出：[null,1,[1,2]]

示例 2：

输入：inputs = ["CBTInserter","insert","insert","get_root"], inputs = [[[1,2,3,4,5,6]],[7],[8],[]]
输出：[null,3,4,[1,2,3,4,5,6,7,8]]

提示：

1. 最初给定的树是完全二叉树，且包含 1 到 1000 个结点。
2. 每个测试用例最多调用 CBTInserter.insert  操作 10000 次。
3. 给定结点或插入结点的每个值都在 0 到 5000 之间。

---

68ms

class CBTInserter {

  var root: TreeNode?
  var nodeArray = [TreeNode]()

  init(_ root: TreeNode?) {
    self.root = root
    var nextLevelStack = [TreeNode]()
    if let node = root {
      nextLevelStack.append(node)
    }

    while nextLevelStack.count > 0 {
      let levelStack = nextLevelStack
      nextLevelStack = [TreeNode]()
      for node in levelStack {
        nodeArray.append(node)
        if let left = node.left {
          nextLevelStack.append(left)
        }
        if let right = node.right {
          nextLevelStack.append(right)
        }
      }
    }
  }

  func insert(_ v: Int) -> Int {
    let newNode = TreeNode(v)
    let newIndex = 1 + nodeArray.count
    if newIndex <= 1 {
      root = newNode
      nodeArray.append(newNode)
      return 0
    }

    let parentIndex = newIndex / 2
    let parentNode = nodeArray[parentIndex - 1]
    if newIndex % 2 == 0 {
      parentNode.left = newNode
    } else {
      parentNode.right = newNode
    }
    nodeArray.append(newNode)
    return parentNode.val
  }

  func get_root() -> TreeNode? {
    return root
  }
}

---

72ms

/**
 * 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 CBTInserter {
    var arr: [TreeNode] = []

    init(_ root: TreeNode?) {
        guard let root = root else { return }
        let q = Queue<TreeNode>()
        q.enqueue(root)
        while !q.isEmpty {
            var node = q.dequeue()!
            arr.append(node)
            if node.left != nil {
                q.enqueue(node.left!)
            }
            if node.right != nil {
                q.enqueue(node.right!)
            }
        }
    }

    func insert(_ v: Int) -> Int {
        let node = TreeNode(v)
        let index = arr.count
        arr.append(node)
        let parent = (index - 1)/2
        if parent >= 0 {
            let par = arr[parent]
            if (2*parent + 1) == index {
                par.left = node
            } else {
                par.right = node
            }
            return par.val
        } else {
            return 0
        }
    }

    func get_root() -> TreeNode? {
        return arr.first
    }
}

public class Queue<T> {
  fileprivate var array = [T?]()
  fileprivate var head = 0

  public var isEmpty: Bool {
    return count == 0
  }

  public var count: Int {
    return array.count - head
  }

  public func enqueue(_ element: T) {
    array.append(element)
  }

  public func dequeue() -> T? {
    guard head < array.count, let element = array[head] else { return nil }

    array[head] = nil
    head += 1

    let percentage = Double(head)/Double(array.count)
    if array.count > 50 && percentage > 0.25 {
      array.removeFirst(head)
      head = 0
    }

    return element
  }

  public var front: T? {
    if isEmpty {
      return nil
    } else {
      return array[head]
    }
  }
}

/**
 * Your CBTInserter object will be instantiated and called as such:
 * let obj = CBTInserter(root)
 * let ret_1: Int = obj.insert(v)
 * let ret_2: TreeNode? = obj.get_root()
 */
 

---

76ms

/**
 * 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 CBTInserter {
    var root: TreeNode?
    var total = 0
    init(_ root: TreeNode?) {
        self.root = root
        count(root)
        //print(total)
    }
    
    func count(_ r: TreeNode?) {
        guard let r = r else {
            return
        }
        total += 1
        count(r.left)
        count(r.right)
    }

    func insert(_ v: Int) -> Int {
        total += 1
        let bs = String(total, radix: 2)
        //print(bs)
        var p = root
        for i in 1 ..< bs.count {
            let b = bs[bs.index(bs.startIndex, offsetBy: i)]
            let q = b == "0" ? p?.left : p?.right
            if q == nil {
                if b == "0" {
                    p?.left = TreeNode(v)
                }
                else {
                    p?.right = TreeNode(v)
                }
                return p!.val
            }
            p = q
        }
        return -1
    }

    func get_root() -> TreeNode? {
        return root
    }
}

/**
 * Your CBTInserter object will be instantiated and called as such:
 * let obj = CBTInserter(root)
 * let ret_1: Int = obj.insert(v)
 * let ret_2: TreeNode? = obj.get_root()
 */

---

80ms

/**
 * 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 CBTInserter {
    var root:TreeNode?
    var deque:[TreeNode?] = [TreeNode?]()
    init(_ root: TreeNode?) {
        self.root = root
        var queue:[TreeNode?] = [TreeNode?]()
        queue.append(root)
        
        // BFS to populate deque
        while(!queue.isEmpty)
        {
           var node:TreeNode? = queue.removeFirst()
            if node?.left == nil || node?.right == nil
            {
                deque.append(node)
            }
            
            if node?.left != nil
            {
                queue.append(node?.left)
            }
            if  node?.right != nil
            {
                queue.append(node?.right)
            }
        }
    }

    func insert(_ v: Int) -> Int {
        var node:TreeNode? = deque.first!
        deque.append(TreeNode(v))
        if node?.left == nil
        {
            node?.left = deque.last!
        }
        else
        {
            node?.right = deque.last!
            deque.removeFirst()
        }
        return node!.val
    }

    func get_root() -> TreeNode? {
        return root
    }
}