update notes

src/main/java/leetcode/medium/LeetCode_0102_BinaryTreeLevelOrderTraversal.java

@@ -7,10 +7,11 @@ import java.util.List;
 import java.util.Map;
 import java.util.Queue;
 
-//树的按层遍历
-//1. hash表+LinkedList
-//2. 仅用LinkedList
-//3. 自定义队列
+// 笔记：https://www.cnblogs.com/greyzeng/p/16356829.html
+// 树的按层遍历
+// 1. hash表+LinkedList
+// 2. 仅用LinkedList
+// 3. 自定义队列
 // https://leetcode-cn.com/problems/binary-tree-level-order-traversal/
 public class LeetCode_0102_BinaryTreeLevelOrderTraversal {
   // 哈希表结合Java自带的LinkedList
@@ -52,37 +53,35 @@ public class LeetCode_0102_BinaryTreeLevelOrderTraversal {
     ans.add(levelRecords);
     return ans;
   }
-
   // 用LinkedList
-    public static List<List<Integer>> levelOrder2(TreeNode head) {
-        if (head == null) {
+  public static List<List<Integer>> levelOrder2(TreeNode root) {
+    if (null == root) {
       return new ArrayList<>();
     }
-        List<List<Integer>> ans = new ArrayList<>();
+    List<List<Integer>> result = new ArrayList<>();
     List<Integer> levelRecords = new ArrayList<>();
-        Queue<TreeNode> queue = new LinkedList<>();
-        TreeNode curEnd = head;
+    TreeNode curEnd = root;
     TreeNode nextEnd = null;
-        queue.offer(curEnd);
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.offer(root);
     while (!queue.isEmpty()) {
-            TreeNode c = queue.poll();
-            levelRecords.add(c.val);
-            if (c.left != null) {
-                queue.offer(c.left);
-                nextEnd = c.left;
+      TreeNode poll = queue.poll();
+      levelRecords.add(poll.val);
+      if (null != poll.left) {
+        queue.offer(poll.left);
+        nextEnd = poll.left;
       }
-            if (c.right != null) {
-                queue.offer(c.right);
-                nextEnd = c.right;
+      if (null != poll.right) {
+        queue.offer(poll.right);
+        nextEnd = poll.right;
       }
-            if (c == curEnd) {
-                // 来到新的一层了
+      if (poll == curEnd) {
         curEnd = nextEnd;
-                ans.add(levelRecords);
+        result.add(levelRecords);
         levelRecords = new ArrayList<>();
       }
     }
-        return ans;
+    return result;
   }
 
   public static class MyNode {
@@ -125,7 +124,6 @@ public class LeetCode_0102_BinaryTreeLevelOrderTraversal {
       ans.next = null;
       return ans;
     }
-
   }
 
   // 用自定义Queue

src/main/java/leetcode/medium/LeetCode_0107_BinaryTreeLevelOrderTraversalII.java

-//Given a binary tree, return the bottom-up level order traversal of its nodes' values. (ie, from left to right, level by level from leaf to root).
+// Given a binary tree, return the bottom-up level order traversal of its nodes' values. (ie, from
+// left to right, level by level from leaf to root).
 //
-//For example:
-//Given binary tree [3,9,20,null,null,15,7],
+// For example:
+// Given binary tree [3,9,20,null,null,15,7],
 //    3
 //   / \
 //  9  20
 //    /  \
 //   15   7
-//return its bottom-up level order traversal as:
-//[
+// return its bottom-up level order traversal as:
+// [
 //  [15,7],
 //  [9,20],
 //  [3]
-//]
+// ]
 package leetcode.medium;
 
 import java.util.ArrayDeque;
@@ -22,7 +23,8 @@ import java.util.LinkedList;
 import java.util.List;
 import java.util.Queue;
 
-
+// 笔记：https://www.cnblogs.com/greyzeng/p/16356829.html
+// 按层遍历进阶
 public class LeetCode_0107_BinaryTreeLevelOrderTraversalII {
 
   public static class TreeNode {
@@ -32,38 +34,36 @@ public class LeetCode_0107_BinaryTreeLevelOrderTraversalII {
   }
 
   public List<List<Integer>> levelOrderBottom(TreeNode root) {
-		List<List<Integer>> ans = new ArrayList<>();
-		Deque<List<Integer>> stack = new ArrayDeque<>();
-		if (root == null) {
-			return ans;
+    if (null == root) {
+      return new ArrayList<>();
     }
-		TreeNode cur = root;
-		TreeNode curEnd = cur;
+    Deque<List<Integer>> stack = new ArrayDeque<>();
+    List<List<Integer>> result = new ArrayList<>();
+    List<Integer> levelRecords = new ArrayList<>();
+    TreeNode curEnd = root;
     TreeNode nextEnd = null;
     Queue<TreeNode> queue = new LinkedList<>();
-		queue.offer(cur);
-		List<Integer> item = new ArrayList<>();
-		while (!queue.isEmpty() ) {
-			cur = queue.poll();
-			if (cur.left != null) {
-				queue.offer(cur.left);
-				nextEnd = cur.left;
+    queue.offer(root);
+    while (!queue.isEmpty()) {
+      TreeNode poll = queue.poll();
+      levelRecords.add(poll.val);
+      if (null != poll.left) {
+        queue.offer(poll.left);
+        nextEnd = poll.left;
       }
-			if (cur.right != null) {
-				queue.offer(cur.right);
-				nextEnd = cur.right;
+      if (null != poll.right) {
+        queue.offer(poll.right);
+        nextEnd = poll.right;
       }
-			item.add(cur.val);
-			if (cur == curEnd) {
-				stack.push(item);
-				item = new ArrayList<>();
+      if (poll == curEnd) {
         curEnd = nextEnd;
+        stack.push(levelRecords);
+        levelRecords = new ArrayList<>();
       }
     }
-		while (!stack.isEmpty() ) {
-			ans.add(stack.pop());
+    while (!stack.isEmpty()) {
+      result.add(stack.poll());
     }
-		
-		return ans;
+    return result;
   }
 }