feat: add solutions to lcci problems: No.04.03,04.04 (#1064)

* No.04.03.List of Depth
* No.04.04.Check Balance

Author: yanglbme

lcci/04.03.List of Depth/README.md

@@ -28,7 +28,11 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-层序遍历。
+**方法一：BFS 层序遍历**
+
+我们可以使用 BFS 层序遍历的方法，每次遍历一层，将当前层的节点值存入链表中，然后将链表加入到结果数组中。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为二叉树的节点数。
 
 <!-- tabs:start -->
 
@@ -44,30 +48,28 @@
 #         self.left = None
 #         self.right = None
 
-
 # Definition for singly-linked list.
 # class ListNode:
 #     def __init__(self, x):
 #         self.val = x
 #         self.next = None
+
+
 class Solution:
     def listOfDepth(self, tree: TreeNode) -> List[ListNode]:
-        q = [tree]
         ans = []
+        q = deque([tree])
         while q:
-            n = len(q)
-            head = ListNode(-1)
-            tail = head
-            for i in range(n):
-                front = q.pop(0)
-                node = ListNode(front.val)
-                tail.next = node
-                tail = node
-                if front.left:
-                    q.append(front.left)
-                if front.right:
-                    q.append(front.right)
-            ans.append(head.next)
+            dummy = cur = ListNode(0)
+            for _ in range(len(q)):
+                node = q.popleft()
+                cur.next = ListNode(node.val)
+                cur = cur.next
+                if node.left:
+                    q.append(node.left)
+                if node.right:
+                    q.append(node.right)
+            ans.append(dummy.next)
         return ans
 ```
 
@@ -95,26 +97,24 @@ class Solution:
  */
 class Solution {
     public ListNode[] listOfDepth(TreeNode tree) {
-        Queue<TreeNode> queue = new LinkedList<>();
-        queue.offer(tree);
         List<ListNode> ans = new ArrayList<>();
-        while (!queue.isEmpty()) {
-            int n = queue.size();
-            ListNode head = new ListNode(-1);
-            ListNode tail = head;
-            for (int i = 0; i < n; i++) {
-                TreeNode front = queue.poll();
-                ListNode node = new ListNode(front.val);
-                tail.next = node;
-                tail = node;
-                if (front.left != null) {
-                    queue.offer(front.left);
+        Deque<TreeNode> q = new ArrayDeque<>();
+        q.offer(tree);
+        while (!q.isEmpty()) {
+            ListNode dummy = new ListNode(0);
+            ListNode cur = dummy;
+            for (int k = q.size(); k > 0; --k) {
+                TreeNode node = q.poll();
+                cur.next = new ListNode(node.val);
+                cur = cur.next;
+                if (node.left != null) {
+                    q.offer(node.left);
                 }
-                if (front.right != null) {
-                    queue.offer(front.right);
+                if (node.right != null) {
+                    q.offer(node.right);
                 }
             }
-            ans.add(head.next);
+            ans.add(dummy.next);
         }
         return ans.toArray(new ListNode[0]);
     }
@@ -145,29 +145,23 @@ class Solution {
 public:
     vector<ListNode*> listOfDepth(TreeNode* tree) {
         vector<ListNode*> ans;
-        if (tree == nullptr) {
-            return ans;
-        }
-        queue<TreeNode*> q;
-        q.push(tree);
+        queue<TreeNode*> q{{tree}};
         while (!q.empty()) {
-            int n = q.size();
-            ListNode* head = new ListNode(-1);
-            ListNode* tail = head;
-            for (int i = 0; i < n; ++i) {
-                TreeNode* front = q.front();
+            ListNode* dummy = new ListNode(0);
+            ListNode* cur = dummy;
+            for (int k = q.size(); k; --k) {
+                TreeNode* node = q.front();
                 q.pop();
-                ListNode* node = new ListNode(front->val);
-                tail->next = node;
-                tail = node;
-                if (front->left != nullptr) {
-                    q.push(front->left);
+                cur->next = new ListNode(node->val);
+                cur = cur->next;
+                if (node->left) {
+                    q.push(node->left);
                 }
-                if (front->right != nullptr) {
-                    q.push(front->right);
+                if (node->right) {
+                    q.push(node->right);
                 }
             }
-            ans.push_back(head->next);
+            ans.push_back(dummy->next);
         }
         return ans;
     }
@@ -192,30 +186,26 @@ public:
  *     Next *ListNode
  * }
  */
-func listOfDepth(tree *TreeNode) []*ListNode {
-	queue := make([]*TreeNode, 0)
-	queue = append(queue, tree)
-	ans := make([]*ListNode, 0)
-	for len(queue) > 0 {
-		n := len(queue)
-		head := new(ListNode)
-		tail := head
-		for i := 0; i < n; i++ {
-			front := queue[0]
-			queue = queue[1:]
-			node := &ListNode{Val: front.Val}
-			tail.Next = node
-			tail = node
-			if front.Left != nil {
-				queue = append(queue, front.Left)
+func listOfDepth(tree *TreeNode) (ans []*ListNode) {
+	q := []*TreeNode{tree}
+	for len(q) > 0 {
+		dummy := &ListNode{}
+		cur := dummy
+		for k := len(q); k > 0; k-- {
+			node := q[0]
+			q = q[1:]
+			cur.Next = &ListNode{Val: node.Val}
+			cur = cur.Next
+			if node.Left != nil {
+				q = append(q, node.Left)
 			}
-			if front.Right != nil {
-				queue = append(queue, front.Right)
+			if node.Right != nil {
+				q = append(q, node.Right)
 			}
 		}
-		ans = append(ans, head.Next)
+		ans = append(ans, dummy.Next)
 	}
-	return ans
+	return
 }
 ```
 
@@ -249,25 +239,21 @@ func listOfDepth(tree *TreeNode) []*ListNode {
  */
 
 function listOfDepth(tree: TreeNode | null): Array<ListNode | null> {
-    const res = [];
-    if (tree == null) {
-        return res;
-    }
-    const queue = [tree];
-    while (queue.length !== 0) {
-        const n = queue.length;
+    const ans: Array<ListNode | null> = [];
+    const q: Array<TreeNode | null> = [tree];
+    while (q.length) {
         const dummy = new ListNode();
         let cur = dummy;
-        for (let i = 0; i < n; i++) {
-            const { val, left, right } = queue.shift();
-            left && queue.push(left);
-            right && queue.push(right);
+        for (let k = q.length; k; --k) {
+            const { val, left, right } = q.shift()!;
             cur.next = new ListNode(val);
             cur = cur.next;
+            left && q.push(left);
+            right && q.push(right);
         }
-        res.push(dummy.next);
+        ans.push(dummy.next);
     }
-    return res;
+    return ans;
 }
 ```