feat: add solutions to lc problem: No.0919

No.0919.Complete Binary Tree Inserter

Author: yanglbme

solution/0900-0999/0919.Complete Binary Tree Inserter/README.md

@@ -43,7 +43,6 @@
 	<li>给定节点或插入节点的每个值都在&nbsp;<code>0</code>&nbsp;到&nbsp;<code>5000</code>&nbsp;之间。</li>
 </ol>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
@@ -55,15 +54,219 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class CBTInserter:
+
+    def __init__(self, root: TreeNode):
+        self.tree = []
+        q = collections.deque([root])
+        while q:
+            n = len(q)
+            for _ in range(n):
+                node = q.popleft()
+                self.tree.append(node)
+                if node.left:
+                    q.append(node.left)
+                if node.right:
+                    q.append(node.right)
+
+    def insert(self, val: int) -> int:
+        pidx = (len(self.tree) - 1) >> 1
+        node = TreeNode(val=val)
+        self.tree.append(node)
+        if self.tree[pidx].left is None:
+            self.tree[pidx].left = node
+        else:
+            self.tree[pidx].right = node
+        return self.tree[pidx].val
 
+    def get_root(self) -> TreeNode:
+        return self.tree[0]
+
+
+# Your CBTInserter object will be instantiated and called as such:
+# obj = CBTInserter(root)
+# param_1 = obj.insert(val)
+# param_2 = obj.get_root()
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class CBTInserter {
+    private List<TreeNode> tree;
+
+    public CBTInserter(TreeNode root) {
+        tree = new ArrayList<>();
+        Deque<TreeNode> q = new ArrayDeque<>();
+        q.offerLast(root);
+        while (!q.isEmpty()) {
+            TreeNode node = q.pollFirst();
+            tree.add(node);
+            if (node.left != null) {
+                q.offerLast(node.left);
+            }
+            if (node.right != null) {
+                q.offerLast(node.right);
+            }
+        }
+    }
+
+    public int insert(int val) {
+        int pidx = (tree.size() - 1) >> 1;
+        TreeNode node = new TreeNode(val);
+        tree.add(node);
+        if (tree.get(pidx).left == null) {
+            tree.get(pidx).left = node;
+        } else {
+            tree.get(pidx).right = node;
+        }
+        return tree.get(pidx).val;
+    }
+
+    public TreeNode get_root() {
+        return tree.get(0);
+    }
+}
+
+/**
+ * Your CBTInserter object will be instantiated and called as such:
+ * CBTInserter obj = new CBTInserter(root);
+ * int param_1 = obj.insert(val);
+ * TreeNode param_2 = obj.get_root();
+ */
+```
+
+### **C++**
+
+```cpp
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class CBTInserter {
+public:
+    vector<TreeNode*> tree;
+
+    CBTInserter(TreeNode* root) {
+        queue<TreeNode*> q;
+        q.push(root);
+        while (!q.empty())
+        {
+            auto node = q.front();
+            q.pop();
+            tree.push_back(node);
+            if (node->left) q.push(node->left);
+            if (node->right) q.push(node->right);
+        }
+    }
+
+    int insert(int val) {
+        int pidx = tree.size() - 1 >> 1;
+        TreeNode* node = new TreeNode(val);
+        tree.push_back(node);
+        if (!tree[pidx]->left) tree[pidx]->left = node;
+        else tree[pidx]->right = node;
+        return tree[pidx]->val;
+    }
+
+    TreeNode* get_root() {
+        return tree[0];
+    }
+};
+
+/**
+ * Your CBTInserter object will be instantiated and called as such:
+ * CBTInserter* obj = new CBTInserter(root);
+ * int param_1 = obj->insert(val);
+ * TreeNode* param_2 = obj->get_root();
+ */
+```
+
+### **Go**
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+type CBTInserter struct {
+	tree []*TreeNode
+}
+
+func Constructor(root *TreeNode) CBTInserter {
+	var q []*TreeNode
+	var tree []*TreeNode
+	q = append(q, root)
+	for len(q) > 0 {
+		node := q[0]
+		tree = append(tree, node)
+		q = q[1:]
+		if node.Left != nil {
+			q = append(q, node.Left)
+		}
+		if node.Right != nil {
+			q = append(q, node.Right)
+		}
+	}
+	return CBTInserter{tree}
+}
+
+func (this *CBTInserter) Insert(val int) int {
+	pidx := (len(this.tree) - 1) >> 1
+	node := &TreeNode{Val: val}
+	this.tree = append(this.tree, node)
+	if this.tree[pidx].Left == nil {
+		this.tree[pidx].Left = node
+	} else {
+		this.tree[pidx].Right = node
+	}
+	return this.tree[pidx].Val
+}
+
+func (this *CBTInserter) Get_root() *TreeNode {
+	return this.tree[0]
+}
 
+/**
+ * Your CBTInserter object will be instantiated and called as such:
+ * obj := Constructor(root);
+ * param_1 := obj.Insert(val);
+ * param_2 := obj.Get_root();
+ */
 ```
 
 ### **...**