Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 8278820

Browse files
Added solutions 101-107.
1 parent 0e12446 commit 8278820

File tree

14 files changed

+370
-0
lines changed

14 files changed

+370
-0
lines changed
Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
package g0101_0200.s0101_symmetric_tree;
2+
3+
import com_github_leetcode.TreeNode;
4+
5+
public class Solution {
6+
public boolean isSymmetric(TreeNode root) {
7+
if (root == null) {
8+
return true;
9+
}
10+
11+
return helper(root.left, root.right);
12+
}
13+
14+
private boolean helper(TreeNode leftNode, TreeNode rightNode) {
15+
if (leftNode == null || rightNode == null) {
16+
boolean isSymetrical = false;
17+
if (leftNode == null && rightNode == null) {
18+
isSymetrical = true;
19+
}
20+
return isSymetrical;
21+
}
22+
23+
if (leftNode.val != rightNode.val) {
24+
return false;
25+
}
26+
27+
return helper(leftNode.left, rightNode.right) && helper(leftNode.right, rightNode.left);
28+
}
29+
}
Lines changed: 41 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,41 @@
1+
package g0101_0200.s0102_binary_tree_level_order_traversal;
2+
3+
import com_github_leetcode.TreeNode;
4+
import java.util.ArrayList;
5+
import java.util.LinkedList;
6+
import java.util.List;
7+
import java.util.Queue;
8+
9+
public class Solution {
10+
public List<List<Integer>> levelOrder(TreeNode root) {
11+
List<List<Integer>> result = new ArrayList<>();
12+
if (root == null) {
13+
return result;
14+
}
15+
Queue<TreeNode> queue = new LinkedList<>();
16+
queue.add(root);
17+
queue.add(null);
18+
List<Integer> level = new ArrayList<>();
19+
while (!queue.isEmpty()) {
20+
root = queue.remove();
21+
while (!queue.isEmpty() && root != null) {
22+
level.add(root.val);
23+
24+
if (root.left != null) {
25+
queue.add(root.left);
26+
}
27+
if (root.right != null) {
28+
queue.add(root.right);
29+
}
30+
31+
root = queue.remove();
32+
}
33+
result.add(level);
34+
level = new ArrayList<>();
35+
if (!queue.isEmpty()) {
36+
queue.add(null);
37+
}
38+
}
39+
return result;
40+
}
41+
}
Lines changed: 41 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,41 @@
1+
package g0101_0200.s0103_binary_tree_zigzag_level_order_traversal;
2+
3+
import com_github_leetcode.TreeNode;
4+
import java.util.ArrayList;
5+
import java.util.LinkedList;
6+
import java.util.List;
7+
import java.util.Queue;
8+
9+
public class Solution {
10+
public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
11+
List<List<Integer>> result = new ArrayList<>();
12+
if (root == null) return result;
13+
Queue<TreeNode> q = new LinkedList<>();
14+
q.add(root);
15+
q.add(null);
16+
boolean zig = true;
17+
LinkedList<Integer> level = new LinkedList<>();
18+
while (!q.isEmpty()) {
19+
TreeNode node = q.remove();
20+
while (!q.isEmpty() && node != null) {
21+
if (zig) {
22+
level.add(node.val);
23+
} else {
24+
level.addFirst(node.val);
25+
}
26+
27+
if (node.left != null) q.add(node.left);
28+
if (node.right != null) q.add(node.right);
29+
node = q.remove();
30+
}
31+
result.add(level);
32+
zig = !zig;
33+
34+
level = new LinkedList<>();
35+
if (!q.isEmpty()) {
36+
q.add(null);
37+
}
38+
}
39+
return result;
40+
}
41+
}
Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
package g0101_0200.s0104_maximum_depth_of_binary_tree;
2+
3+
import com_github_leetcode.TreeNode;
4+
5+
public class Solution {
6+
public int maxDepth(TreeNode root) {
7+
return findDepth(root, 0);
8+
}
9+
10+
private int findDepth(TreeNode node, int currentDepth) {
11+
if (node == null) {
12+
return 0;
13+
}
14+
currentDepth++;
15+
return 1
16+
+ Math.max(findDepth(node.left, currentDepth), findDepth(node.right, currentDepth));
17+
}
18+
}
Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
package g0101_0200.s0105_construct_binary_tree_from_preorder_and_inorder_traversal;
2+
3+
import com_github_leetcode.TreeNode;
4+
import java.util.HashMap;
5+
import java.util.Map;
6+
7+
public class Solution {
8+
int j;
9+
Map<Integer, Integer> map = new HashMap<>();
10+
11+
public int get(int key) {
12+
return map.get(key);
13+
}
14+
15+
private TreeNode answer(int[] preorder, int[] inorder, int start, int end) {
16+
if (start > end || j > preorder.length) return null;
17+
int value = preorder[j++];
18+
int index = get(value);
19+
TreeNode node = new TreeNode(value);
20+
node.left = answer(preorder, inorder, start, index - 1);
21+
node.right = answer(preorder, inorder, index + 1, end);
22+
return node;
23+
}
24+
25+
public TreeNode buildTree(int[] preorder, int[] inorder) {
26+
j = 0;
27+
for (int i = 0; i < preorder.length; i++) map.put(inorder[i], i);
28+
return answer(preorder, inorder, 0, preorder.length - 1);
29+
}
30+
}
Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
package g0101_0200.s0106_construct_binary_tree_from_inorder_and_postorder_traversal;
2+
3+
import com_github_leetcode.TreeNode;
4+
5+
public class Solution {
6+
public TreeNode buildTree(int[] inorder, int[] postorder) {
7+
int[] inIndex = new int[] {inorder.length - 1};
8+
int[] postIndex = new int[] {postorder.length - 1};
9+
return helper(inorder, postorder, inIndex, postIndex, Integer.MAX_VALUE);
10+
}
11+
12+
private TreeNode helper(int[] in, int[] post, int[] index, int[] pIndex, int target) {
13+
if (index[0] < 0 || in[index[0]] == target) {
14+
return null;
15+
}
16+
TreeNode root = new TreeNode(post[pIndex[0]--]);
17+
root.right = helper(in, post, index, pIndex, root.val);
18+
index[0]--;
19+
root.left = helper(in, post, index, pIndex, target);
20+
return root;
21+
}
22+
}
Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
package g0101_0200.s0107_binary_tree_level_order_traversal_ii;
2+
3+
import com_github_leetcode.TreeNode;
4+
import java.util.ArrayList;
5+
import java.util.Collections;
6+
import java.util.List;
7+
8+
public class Solution {
9+
List<List<Integer>> order = new ArrayList<>();
10+
11+
public List<List<Integer>> levelOrderBottom(TreeNode root) {
12+
getOrder(root, 0);
13+
Collections.reverse(order);
14+
return order;
15+
}
16+
17+
public void getOrder(TreeNode root, int level) {
18+
if (root == null) {
19+
return;
20+
} else {
21+
if (level + 1 > order.size()) {
22+
order.add(new ArrayList<>());
23+
}
24+
order.get(level).add(root.val);
25+
getOrder(root.left, level + 1);
26+
getOrder(root.right, level + 1);
27+
}
28+
}
29+
}
Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
package g0101_0200.s0101_symmetric_tree;
2+
3+
import static org.hamcrest.CoreMatchers.equalTo;
4+
import static org.hamcrest.MatcherAssert.assertThat;
5+
6+
import com_github_leetcode.TreeNode;
7+
import org.junit.Test;
8+
9+
public class SolutionTest {
10+
@Test
11+
public void symmetricTree() {
12+
TreeNode left = new TreeNode(2, new TreeNode(3), new TreeNode(4));
13+
TreeNode right = new TreeNode(2, new TreeNode(4), new TreeNode(3));
14+
TreeNode root = new TreeNode(1, left, right);
15+
assertThat(new Solution().isSymmetric(root), equalTo(true));
16+
}
17+
}
Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
package g0101_0200.s0102_binary_tree_level_order_traversal;
2+
3+
import static org.hamcrest.CoreMatchers.equalTo;
4+
import static org.hamcrest.MatcherAssert.assertThat;
5+
6+
import com_github_leetcode.TreeNode;
7+
import java.util.ArrayList;
8+
import java.util.Arrays;
9+
import java.util.List;
10+
import org.junit.Test;
11+
12+
public class SolutionTest {
13+
@Test
14+
public void binaryTreeLevelOrderTraversal() {
15+
TreeNode left = new TreeNode(9, null, null);
16+
TreeNode right = new TreeNode(20, new TreeNode(15), new TreeNode(7));
17+
TreeNode root = new TreeNode(3, left, right);
18+
19+
List<List<Integer>> expected = new ArrayList<>();
20+
expected.add(Arrays.asList(3));
21+
expected.add(Arrays.asList(9, 20));
22+
expected.add(Arrays.asList(15, 7));
23+
24+
List<List<Integer>> actual = new Solution().levelOrder(root);
25+
26+
for (int i = 0; i < expected.size(); i++) {
27+
assertThat(actual.get(i), equalTo(expected.get(i)));
28+
}
29+
}
30+
}
Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
package g0101_0200.s0103_binary_tree_zigzag_level_order_traversal;
2+
3+
import static org.hamcrest.CoreMatchers.equalTo;
4+
import static org.hamcrest.MatcherAssert.assertThat;
5+
6+
import com_github_leetcode.TreeNode;
7+
import java.util.ArrayList;
8+
import java.util.Arrays;
9+
import java.util.List;
10+
import org.junit.Test;
11+
12+
public class SolutionTest {
13+
@Test
14+
public void binaryTreeZigzagLevelOrderTraversal() {
15+
TreeNode left = new TreeNode(9, null, null);
16+
TreeNode right = new TreeNode(20, new TreeNode(15), new TreeNode(7));
17+
TreeNode root = new TreeNode(3, left, right);
18+
19+
List<List<Integer>> expected = new ArrayList<>();
20+
expected.add(Arrays.asList(3));
21+
expected.add(Arrays.asList(20, 9));
22+
expected.add(Arrays.asList(15, 7));
23+
24+
List<List<Integer>> actual = new Solution().zigzagLevelOrder(root);
25+
26+
for (int i = 0; i < expected.size(); i++) {
27+
assertThat(actual.get(i), equalTo(expected.get(i)));
28+
}
29+
}
30+
}

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /