Skip to content

Commit f3ce24c

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

16 files changed

Lines changed: 178 additions & 95 deletions

File tree

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

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -130,20 +130,20 @@ tree
130130
107. 二叉树的层次遍历 II (自底向上的层次遍历) BFS(一个queue实现)1-使用队列存储每层元素,用栈存储每层的结果集;2-(推荐)使用java的LinkedList的性质,从上到下遍历,将新遍历的层结果集放入linkedlist的头部
131131
103. 二叉树的锯齿形层次遍历 ***** 使用两个stack交替迭代放值
132132
104. 二叉树的最大深度 *** 1-递归;2-(推荐)层次遍历+累加深度(广度优先搜索)
133-
111. 二叉树的最小深度 *** 1-深度优先搜索,即递归;2-层次遍历,相比104题,多加一个判断,判断是否已经到叶子结点,到了直接return depth
133+
111. 二叉树的最小深度 *** 1-深度优先搜索,即递归;2-层次遍历,相比104题,多加一个判断,判断是否已经到叶子结点,到了直接return depth(if (node.left == null && node.right == null) )
134+
199. 二叉树的右视图 ***** 1-广度优先搜索,即层次遍历(推荐)将每一层的最后一个节点放入结果列表
134135
543. 二叉树的直径 递归,左子树的深度+右子树的深度 Math.max(ans, leftDepth + rightDepth);return Math.max(leftDepth, rightDepth) + 1;
135136
101. 对称二叉树 ***** 迭代:队列,放左右结点和右左结点
136-
226. 翻转二叉树 ***** 迭代:用queue层次遍历交换处理
137+
226. 翻转二叉树 ***** 迭代:用queue层次遍历交换处理,循环体内,每次取出一个node
137138
617. 合并二叉树 递归
138-
199. 二叉树的右视图 ***** 1-广度优先搜索,即层次遍历(推荐)将每一层的最后一个节点放入结果列表
139-
96. 不同的二叉搜索树
140-
98. 验证二叉搜索树???
141-
235. 二叉搜索树的最近公共祖先 *****
142-
236. 二叉树的最近公共祖先 ***
143-
538. 把二叉搜索树转换为累加树
144-
112. 路径总和 ***
145-
113. 路径之和 II ***
146-
437. 路径之和 III ***
139+
96. 不同的二叉搜索树 动态规划,i为根,G(i-1)*G(n-i) 求和(1<= i <=n)
140+
98. 验证二叉搜索树??? 中序遍历:遍历后是升序
141+
235. 二叉搜索树的最近公共祖先 ***** while循环判断根的值和另两个参数的大小。while (root != null) {
142+
236. 二叉树的最近公共祖先 *** 递归
143+
538. 把二叉搜索树转换为累加树 递归-反序中序遍历
144+
112. 路径总和 *** 判断是否存在 层次遍历(BFS推荐)
145+
113. 路径之和 II *** 返回所有路径 同112,用map把结点父节点记录下来,最后求路径反转
146+
437. 路径之和 III *** 不需要到叶子结点返回所有路径 两层递归
147147

148148
recursion
149149
汉诺塔问题 HanNuoTa

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

Lines changed: 30 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -49,7 +49,7 @@ private boolean isMirror(TreeNode root1, TreeNode root2) {
4949
}
5050

5151
/**
52-
* 2-迭代
52+
* 2-迭代(推荐)
5353
*
5454
* @param root
5555
* @return
@@ -91,7 +91,35 @@ public void test() {
9191
TreeNode right2 = new TreeNode(2, right4_4, left3_3);
9292
TreeNode root = new TreeNode(1, left2, right2);
9393

94-
System.out.println(isSymmetric2(root));
94+
System.out.println(isSymmetric3(root));
9595

9696
}
97+
98+
public boolean isSymmetric3(TreeNode root){
99+
return check(root,root);
100+
}
101+
private boolean check2(TreeNode u,TreeNode v){
102+
Queue<TreeNode> queue = new LinkedList<>();
103+
104+
queue.add(u);
105+
queue.add(v);
106+
107+
while(!queue.isEmpty()){
108+
u = queue.poll();
109+
v = queue.poll();
110+
if(u == null && v == null){
111+
continue;
112+
}
113+
if(u == null || v == null || u.val != v.val){
114+
return false;
115+
}
116+
117+
queue.add(u.left);
118+
queue.add(v.right);
119+
120+
queue.add(u.right);
121+
queue.add(v.left);
122+
}
123+
return true;
124+
}
97125
}

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

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,7 @@
2222
*
2323
* @Auther: zhunn
2424
* @Date: 2020/10/29 17:57
25-
* @Description: 二叉树的最大深度:1-递归;2-广度优先搜索(BFS-层次遍历)
25+
* @Description: 二叉树的最大深度:1-递归;2-广度优先搜索(BFS-层次遍历)(推荐)
2626
*/
2727
public class Solution {
2828

@@ -37,7 +37,7 @@ public int maxDepth(TreeNode root) {
3737
}
3838

3939
/**
40-
* 2-广度优先搜索(层次遍历)
40+
* 2-广度优先搜索(层次遍历)(推荐)
4141
*
4242
* @param root
4343
* @return

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -70,7 +70,7 @@ public List<List<Integer>> levelOrderBottom(TreeNode root) {
7070
}
7171

7272
/**
73-
* 使用java的LinkedList的性质,从上到下遍历,将新遍历的层结果集放入linkedlist的头部
73+
* (推荐)使用java的LinkedList的性质,从上到下遍历,将新遍历的层结果集放入linkedlist的头部
7474
* @param root
7575
* @return
7676
*/

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

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@
2020
*
2121
* @Auther: zhunn
2222
* @Date: 2020/10/29 18:40
23-
* @Description: 二叉树的最小深度:1-深度优先搜索(DFS),即递归;2-广度优先搜索(BFS)
23+
* @Description: 二叉树的最小深度:1-深度优先搜索(DFS),即递归;2-广度优先搜索(BFS)(推荐)
2424
*/
2525
public class Solution {
2626

@@ -60,7 +60,7 @@ public int minDepth1(TreeNode root) {
6060
}
6161

6262
/**
63-
* 2-广度优先搜索(BFS)
63+
* 2-广度优先搜索(BFS)(推荐)
6464
*
6565
* @param root
6666
* @return
@@ -101,7 +101,7 @@ public void test() {
101101
TreeNode right = new TreeNode(7, new TreeNode(15), new TreeNode(20));
102102
TreeNode root = new TreeNode(3, left, right);
103103

104-
int res = minDepth1(left);
104+
int res = minDepth2(left);
105105
System.out.println(res);
106106
}
107107
}

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

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -13,19 +13,19 @@
1313
* 说明: 叶子节点是指没有子节点的节点。
1414
* 示例:
1515
* 给定如下二叉树,以及目标和 sum = 22,
16-
*
17-
* 5
18-
* / \
19-
* 4 8
20-
* / / \
21-
* 11 13 4
22-
* / \ \
23-
* 7 2 1
16+
* <p>
17+
* 5
18+
* / \
19+
* 4 8
20+
* / / \
21+
* 11 13 4
22+
* / \ \
23+
* 7 2 1
2424
* 返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。
2525
*
2626
* @Auther: zhunn
2727
* @Date: 2020/11/08 15:25
28-
* @Description: 路径总和:1-递归;2-广度优先搜索
28+
* @Description: 路径总和:1-递归;2-广度优先搜索(推荐)
2929
*/
3030
public class Solution {
3131

@@ -47,7 +47,7 @@ public boolean hasPathSum(TreeNode root, int sum) {
4747
}
4848

4949
/**
50-
* 2-广度优先搜索
50+
* 2-广度优先搜索(推荐)
5151
*
5252
* @param root
5353
* @param sum

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

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -11,23 +11,23 @@
1111
* 说明: 叶子节点是指没有子节点的节点。
1212
* 示例:
1313
* 给定如下二叉树,以及目标和 sum = 22,
14-
*
15-
* 5
16-
* / \
17-
* 4 8
18-
* / / \
19-
* 11 13 4
20-
* / \ / \
21-
* 7 2 5 1
14+
* <p>
15+
* 5
16+
* / \
17+
* 4 8
18+
* / / \
19+
* 11 13 4
20+
* / \ / \
21+
* 7 2 5 1
2222
* 返回:
2323
* [
24-
* [5,4,11,2],
25-
* [5,8,4,5]
24+
* [5,4,11,2],
25+
* [5,8,4,5]
2626
* ]
2727
*
2828
* @Auther: zhunn
2929
* @Date: 2020/10/28 10:11
30-
* @Description: 路径之和 II,二叉树中和为某一值的路径:1-深度优先搜索;2-广度优先搜索
30+
* @Description: 路径之和 II,二叉树中和为某一值的路径:1-深度优先搜索;2-广度优先搜索(推荐)
3131
* 同剑指 Offer 34
3232
*/
3333
public class Solution {

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

Lines changed: 13 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,8 @@
11
package com.chen.algorithm.znn.tree.test199;
22

3+
import com.alibaba.fastjson.JSON;
34
import com.chen.algorithm.znn.tree.TreeNode;
5+
import org.junit.Test;
46

57
import java.util.ArrayList;
68
import java.util.LinkedList;
@@ -27,7 +29,7 @@
2729
public class Solution {
2830

2931
/**
30-
* 1-广度优先搜索
32+
* 1-广度优先搜索(推荐)
3133
*
3234
* @param root
3335
* @return
@@ -84,4 +86,14 @@ private void dfs(TreeNode root, int depth) {
8486
dfs(root.right, depth);
8587
dfs(root.left, depth);
8688
}
89+
90+
@Test
91+
public void test() {
92+
TreeNode left = new TreeNode(9);
93+
TreeNode right = new TreeNode(20, new TreeNode(15), new TreeNode(7));
94+
TreeNode root = new TreeNode(3, left, right);
95+
96+
List<Integer> res = rightSideView(root);
97+
System.out.println(JSON.toJSON(res));
98+
}
8799
}

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

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -14,21 +14,21 @@
1414
* 翻转一棵二叉树。
1515
* 示例:
1616
* 输入:
17-
* 4
18-
* / \
19-
* 2 7
20-
* / \ / \
17+
* 4
18+
* / \
19+
* 2 7
20+
* / \ / \
2121
* 1 3 6 9
2222
* 输出:
23-
* 4
24-
* / \
25-
* 7 2
26-
* / \ / \
23+
* 4
24+
* / \
25+
* 7 2
26+
* / \ / \
2727
* 9 6 3 1
2828
*
2929
* @Auther: zhunn
3030
* @Date: 2020/10/28 17:58
31-
* @Description: 翻转二叉树:1-递归;2-迭代
31+
* @Description: 翻转二叉树:1-递归;2-迭代(推荐)
3232
*/
3333
public class Solution {
3434

@@ -52,7 +52,7 @@ public TreeNode invertTree1(TreeNode root) {
5252
}
5353

5454
/**
55-
* 2-迭代 用queue层次遍历交换处理
55+
* 2-迭代 用queue层次遍历交换处理(推荐)
5656
*
5757
* @param root
5858
* @return
@@ -65,7 +65,7 @@ public TreeNode invertTree2(TreeNode root) {
6565
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;

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

Lines changed: 11 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,7 @@
99
import java.util.Set;
1010

1111
/**
12+
* https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree/solution/er-cha-shu-de-zui-jin-gong-gong-zu-xian-by-leetc-2/
1213
* 236. 二叉树的最近公共祖先 (需要看leetcode题上面的图)
1314
* 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
1415
* 百度百科中最近公共祖先的定义为:“对于有根树 T 的两个结点 p、q,最近公共祖先表示为一个结点 x,满足 x 是 p、q 的祖先且 x 的深度尽可能大(一个节点也可以是它自己的祖先)。”
@@ -24,10 +25,18 @@
2425
*
2526
* @Auther: zhunn
2627
* @Date: 2020/10/29 15:29
27-
* @Description: 二叉树的最近公共祖先:1-递归;2-存储父节点
28+
* @Description: 二叉树的最近公共祖先:1-递归(推荐);2-存储父节点
2829
*/
2930
public class Solution {
3031

32+
/**
33+
* 1-递归(推荐)
34+
*
35+
* @param root
36+
* @param p
37+
* @param q
38+
* @return
39+
*/
3140
public TreeNode lowestCommonAncestor1(TreeNode root, TreeNode p, TreeNode q) {
3241
if (root == null || root == p || root == q) {
3342
return root;
@@ -92,7 +101,7 @@ public void test() {
92101
TreeNode right = new TreeNode(2);
93102
TreeNode root = new TreeNode(8, left, right);
94103

95-
TreeNode res = lowestCommonAncestor2(root, left, right);
104+
TreeNode res = lowestCommonAncestor1(root, left, right);
96105
System.out.println(res.val);
97106
}
98107

0 commit comments

Comments
 (0)