Skip to content

Commit 7d44336

Browse files
committed
review-tree
1 parent e68b7a7 commit 7d44336

9 files changed

Lines changed: 43 additions & 36 deletions

File tree

‎src/main/java/com/chen/algorithm/znn/note‎

Lines changed: 16 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -123,27 +123,27 @@ linkedlist
123123
//148. 排序链表
124124

125125
tree
126-
94. 二叉树的中序遍历
127-
144. 二叉树的前序遍历 *****
128-
145. 后序遍历二叉树 递归、迭代实现
129-
102. 二叉树的层序遍历 *****
130-
107. 二叉树的层次遍历 II *****
131-
103. 二叉树的锯齿形层次遍历 *****
132-
104. 二叉树的最大深度 ***
133-
111. 二叉树的最小深度 ***
134-
543. 二叉树的直径
135-
112. 路径总和 ***
136-
113. 路径之和 II ***
137-
437. 路径之和 III ***
138-
101. 对称二叉树 *****
139-
226. 翻转二叉树 *****
140-
617. 合并二叉树
141-
199. 二叉树的右视图 *****
126+
94. 二叉树的中序遍历 递归和迭代都要会,推荐迭代(一个stack实现)Stack<TreeNode> stack = new Stack<>();(两层while循环,内层放左子树)
127+
144. 二叉树的前序遍历 ***** 递归和迭代都要会,推荐迭代(一个stack实现)while(!stack.isEmpty())
128+
145. 后序遍历二叉树 递归和迭代都要会,推荐迭代(两个stack实现)
129+
102. 二叉树的层序遍历 ***** BFS(一个queue实现)Queue<TreeNode> queue = new LinkedList<>(); 写法同107
130+
107. 二叉树的层次遍历 II (自底向上的层次遍历) BFS(一个queue实现)1-使用队列存储每层元素,用栈存储每层的结果集;2-(推荐)使用java的LinkedList的性质,从上到下遍历,将新遍历的层结果集放入linkedlist的头部
131+
103. 二叉树的锯齿形层次遍历 ***** 使用两个stack交替迭代放值
132+
104. 二叉树的最大深度 *** 1-递归;2-(推荐)层次遍历+累加深度(广度优先搜索)
133+
111. 二叉树的最小深度 *** 1-深度优先搜索,即递归;2-层次遍历,相比104题,多加一个判断,判断是否已经到叶子结点,到了直接return depth
134+
543. 二叉树的直径 递归,左子树的深度+右子树的深度 Math.max(ans, leftDepth + rightDepth);return Math.max(leftDepth, rightDepth) + 1;
135+
101. 对称二叉树 ***** 迭代:队列,放左右结点和右左结点
136+
226. 翻转二叉树 ***** 迭代:用queue层次遍历交换处理
137+
617. 合并二叉树 递归
138+
199. 二叉树的右视图 ***** 1-广度优先搜索,即层次遍历(推荐)将每一层的最后一个节点放入结果列表
142139
96. 不同的二叉搜索树
143140
98. 验证二叉搜索树???
144141
235. 二叉搜索树的最近公共祖先 *****
145142
236. 二叉树的最近公共祖先 ***
146143
538. 把二叉搜索树转换为累加树
144+
112. 路径总和 ***
145+
113. 路径之和 II ***
146+
437. 路径之和 III ***
147147

148148
recursion
149149
汉诺塔问题 HanNuoTa

‎src/main/java/com/chen/algorithm/znn/tree/test101/Solution.java‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,7 @@
2424
*
2525
* @Auther: zhunn
2626
* @Date: 2020/10/29 11:03
27-
* @Description: 对称二叉树:1-递归,2-迭代
27+
* @Description: 对称二叉树:1-递归,2-迭代(推荐)
2828
*/
2929
public class Solution {
3030

‎src/main/java/com/chen/algorithm/znn/tree/test102/Solution.java‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -43,9 +43,10 @@ public List<List<Integer>> levelOrder(TreeNode root) {
4343
return null;
4444
}
4545

46-
List<List<Integer>> res = new ArrayList<>();
46+
List<List<Integer>> res = new LinkedList<>();
4747
Queue<TreeNode> queue = new LinkedList<>();
4848
queue.add(root);
49+
4950
while (!queue.isEmpty()) {
5051
int size = queue.size();
5152
List<Integer> levelList = new ArrayList<>();

‎src/main/java/com/chen/algorithm/znn/tree/test144/Solution.java‎

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,7 @@
1414
*
1515
* @Auther: zhunn
1616
* @Date: 2020/10/28 16:25
17-
* @Description: 二叉树的前序遍历:1-递归;2-迭代
17+
* @Description: 二叉树的前序遍历:1-递归;2-迭代 (推荐) 两种方式都要会
1818
*/
1919
public class Solution {
2020

@@ -43,6 +43,12 @@ private void preOrder(TreeNode root, List<Integer> res) {
4343
preOrder(root.right, res);
4444
}
4545

46+
/**
47+
* 2-迭代 (推荐)
48+
*
49+
* @param root
50+
* @return
51+
*/
4652
public List<Integer> preorderTraversal2(TreeNode root) {
4753
if (root == null) {
4854
return null;

‎src/main/java/com/chen/algorithm/znn/tree/test145/Solution.java‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,7 @@
1212
*
1313
* @Auther: zhunn
1414
* @Date: 2020/10/28 10:28
15-
* @Description: 二叉树的后序遍历:1-递归;2-迭代(时间复杂度和空间复杂度都是O(n))
15+
* @Description: 二叉树的后序遍历:1-递归;2-(推荐)迭代(时间复杂度和空间复杂度都是O(n)) 两种方式都要会
1616
*/
1717
public class Solution {
1818

@@ -40,7 +40,7 @@ private void postorder(TreeNode root, List<Integer> res) {
4040
}
4141

4242
/**
43-
* 2-迭代法,两个栈实现
43+
* 2-迭代法,两个栈实现(推荐)
4444
*
4545
* @param root
4646
* @return
@@ -52,12 +52,12 @@ public List<Integer> postorderTraversal2(TreeNode root) {
5252
Stack<TreeNode> stack1 = new Stack<>();
5353
Stack<TreeNode> stack2 = new Stack<>();
5454

55-
stack1.push(root);
55+
stack1.push(root); // 先放根
5656
while (!stack1.isEmpty()) {
57-
TreeNode node = stack1.pop();
57+
TreeNode node = stack1.pop(); // 出栈压入stack2的栈底
5858
stack2.push(node);
5959

60-
if (node.left != null) {
60+
if (node.left != null) { // 先入左子树,再出栈入stack2,迭代出栈就会先出
6161
stack1.push(node.left);
6262
}
6363

‎src/main/java/com/chen/algorithm/znn/tree/test199/Solution.java‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,7 @@
2222
*
2323
* @Auther: zhunn
2424
* @Date: 2020/10/28 17:41
25-
* @Description: 二叉树的右视图:1-广度优先搜索;2-深度优先搜索
25+
* @Description: 二叉树的右视图:1-广度优先搜索,即层次遍历(推荐);2-深度优先搜索
2626
*/
2727
public class Solution {
2828

‎src/main/java/com/chen/algorithm/znn/tree/test226/Solution.java‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -52,7 +52,7 @@ public TreeNode invertTree1(TreeNode root) {
5252
}
5353

5454
/**
55-
* 2-迭代
55+
* 2-迭代 用queue层次遍历交换处理
5656
*
5757
* @param root
5858
* @return
@@ -62,19 +62,19 @@ public TreeNode invertTree2(TreeNode root) {
6262
return root;
6363
}
6464

65-
Queue<TreeNode> queue = new LinkedList<>();
65+
Queue<TreeNode> queue = new LinkedList<>(); //将二叉树中的节点逐层放入队列中,再迭代处理队列中的元素
6666
queue.add(root);
6767
while (!queue.isEmpty()) {
68-
TreeNode node = queue.poll();
68+
TreeNode node = queue.poll(); // 如果当前节点的左子树不为空,则放入队列等待后续处理
6969

7070
TreeNode temp = node.right;
7171
node.right = node.left;
7272
node.left = temp;
7373

74-
if (node.left != null) {
74+
if (node.left != null) { //如果当前节点的左子树不为空,则放入队列等待后续处理
7575
queue.add(node.left);
7676
}
77-
if (node.right != null) {
77+
if (node.right != null) { //如果当前节点的右子树不为空,则放入队列等待后续处理
7878
queue.add(node.right);
7979
}
8080
}

‎src/main/java/com/chen/algorithm/znn/tree/test94/Solution.java‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -44,7 +44,7 @@ private void inOrder(TreeNode root, List<Integer> res) {
4444
}
4545

4646
/**
47-
* 2-迭代
47+
* 2-迭代,栈
4848
*
4949
* @param root
5050
* @return
@@ -59,14 +59,14 @@ public List<Integer> inorderTraversal2(TreeNode root) {
5959
TreeNode curr = root;
6060

6161
while (!stack.isEmpty() || curr != null) {
62-
while (curr != null) {
62+
while (curr != null) { // 当前节点不为空,一直将左子树入栈
6363
stack.push(curr);
6464
curr = curr.left;
6565
}
6666

67-
TreeNode temp = stack.pop();
68-
res.add(temp.val);
69-
curr = temp.right;
67+
TreeNode temp = stack.pop(); // 出栈
68+
res.add(temp.val); // 操作数据
69+
curr = temp.right; // 对出栈的节点检查是有否还有左节点,有的话继续入栈,没有的话就操作叶子节点的上一个节点
7070
}
7171
return res;
7272
}

‎src/main/java/com/chen/algorithm/znn/tree/test98/Solution.java‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,7 @@
3131
*
3232
* @Auther: zhunn
3333
* @Date: 2020/10/29 16:35
34-
* @Description: 验证二叉搜索树:1-递归,2-中序遍历
34+
* @Description: 验证二叉搜索树:1-递归,2-中序遍历(推荐)
3535
*/
3636
public class Solution {
3737

0 commit comments

Comments
 (0)