Skip to content

Commit 9226ec0

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.0545 (#3315)
No.0545.Boundary of Binary Tree
1 parent 7840036 commit 9226ec0

File tree

8 files changed

+943
-438
lines changed

8 files changed

+943
-438
lines changed

‎solution/0500-0599/0545.Boundary of Binary Tree/README.md

+323-144
Large diffs are not rendered by default.

‎solution/0500-0599/0545.Boundary of Binary Tree/README_EN.md

+322-143
Large diffs are not rendered by default.

‎solution/0500-0599/0545.Boundary of Binary Tree/Solution.cpp

+59
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,59 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
8+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
9+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10+
* };
11+
*/
12+
class Solution {
13+
public:
14+
vector<int> boundaryOfBinaryTree(TreeNode* root) {
15+
auto dfs = [&](auto&& dfs, vector<int>& nums, TreeNode* root, int i) -> void {
16+
if (!root) {
17+
return;
18+
}
19+
if (i == 0) {
20+
if (root->left != root->right) {
21+
nums.push_back(root->val);
22+
if (root->left) {
23+
dfs(dfs, nums, root->left, i);
24+
} else {
25+
dfs(dfs, nums, root->right, i);
26+
}
27+
}
28+
} else if (i == 1) {
29+
if (root->left == root->right) {
30+
nums.push_back(root->val);
31+
} else {
32+
dfs(dfs, nums, root->left, i);
33+
dfs(dfs, nums, root->right, i);
34+
}
35+
} else {
36+
if (root->left != root->right) {
37+
nums.push_back(root->val);
38+
if (root->right) {
39+
dfs(dfs, nums, root->right, i);
40+
} else {
41+
dfs(dfs, nums, root->left, i);
42+
}
43+
}
44+
}
45+
};
46+
vector<int> ans = {root->val};
47+
if (root->left == root->right) {
48+
return ans;
49+
}
50+
vector<int> left, right, leaves;
51+
dfs(dfs, left, root->left, 0);
52+
dfs(dfs, leaves, root, 1);
53+
dfs(dfs, right, root->right, 2);
54+
ans.insert(ans.end(), left.begin(), left.end());
55+
ans.insert(ans.end(), leaves.begin(), leaves.end());
56+
ans.insert(ans.end(), right.rbegin(), right.rend());
57+
return ans;
58+
}
59+
};

‎solution/0500-0599/0545.Boundary of Binary Tree/Solution.go

+61
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,61 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* type TreeNode struct {
4+
* Val int
5+
* Left *TreeNode
6+
* Right *TreeNode
7+
* }
8+
*/
9+
func boundaryOfBinaryTree(root *TreeNode) []int {
10+
ans := []int{root.Val}
11+
if root.Left == root.Right {
12+
return ans
13+
}
14+
15+
left, leaves, right := []int{}, []int{}, []int{}
16+
17+
var dfs func(nums *[]int, root *TreeNode, i int)
18+
dfs = func(nums *[]int, root *TreeNode, i int) {
19+
if root == nil {
20+
return
21+
}
22+
if i == 0 {
23+
if root.Left != root.Right {
24+
*nums = append(*nums, root.Val)
25+
if root.Left != nil {
26+
dfs(nums, root.Left, i)
27+
} else {
28+
dfs(nums, root.Right, i)
29+
}
30+
}
31+
} else if i == 1 {
32+
if root.Left == root.Right {
33+
*nums = append(*nums, root.Val)
34+
} else {
35+
dfs(nums, root.Left, i)
36+
dfs(nums, root.Right, i)
37+
}
38+
} else {
39+
if root.Left != root.Right {
40+
*nums = append(*nums, root.Val)
41+
if root.Right != nil {
42+
dfs(nums, root.Right, i)
43+
} else {
44+
dfs(nums, root.Left, i)
45+
}
46+
}
47+
}
48+
}
49+
50+
dfs(&left, root.Left, 0)
51+
dfs(&leaves, root, 1)
52+
dfs(&right, root.Right, 2)
53+
54+
ans = append(ans, left...)
55+
ans = append(ans, leaves...)
56+
for i := len(right) - 1; i >= 0; i-- {
57+
ans = append(ans, right[i])
58+
}
59+
60+
return ans
61+
}

‎solution/0500-0599/0545.Boundary of Binary Tree/Solution.java

+44-66
Original file line numberDiff line numberDiff line change
@@ -1,75 +1,53 @@
1-
/**
2-
* Definition for a binary tree node.
3-
* public class TreeNode {
4-
* int val;
5-
* TreeNode left;
6-
* TreeNode right;
7-
* TreeNode() {}
8-
* TreeNode(int val) { this.val = val; }
9-
* TreeNode(int val, TreeNode left, TreeNode right) {
10-
* this.val = val;
11-
* this.left = left;
12-
* this.right = right;
13-
* }
14-
* }
15-
*/
161
class Solution {
17-
private List<Integer> res;
18-
192
public List<Integer> boundaryOfBinaryTree(TreeNode root) {
20-
if (root == null) {
21-
return Collections.emptyList();
22-
}
23-
res = new ArrayList<>();
24-
25-
// root
26-
if (!isLeaf(root)) {
27-
res.add(root.val);
28-
}
29-
30-
// left boundary
31-
TreeNode t = root.left;
32-
while (t != null) {
33-
if (!isLeaf(t)) {
34-
res.add(t.val);
35-
}
36-
t = t.left == null ? t.right : t.left;
37-
}
38-
39-
// leaves
40-
addLeaves(root);
41-
42-
// right boundary(reverse order)
43-
Deque<Integer> s = new ArrayDeque<>();
44-
t = root.right;
45-
while (t != null) {
46-
if (!isLeaf(t)) {
47-
s.offer(t.val);
48-
}
49-
t = t.right == null ? t.left : t.right;
50-
}
51-
while (!s.isEmpty()) {
52-
res.add(s.pollLast());
53-
}
54-
55-
// output
56-
return res;
3+
List<Integer> ans = new ArrayList<>();
4+
ans.add(root.val);
5+
if (root.left == root.right) {
6+
return ans;
7+
}
8+
List<Integer> left = new ArrayList<>();
9+
List<Integer> leaves = new ArrayList<>();
10+
List<Integer> right = new ArrayList<>();
11+
dfs(left, root.left, 0);
12+
dfs(leaves, root, 1);
13+
dfs(right, root.right, 2);
14+
15+
ans.addAll(left);
16+
ans.addAll(leaves);
17+
Collections.reverse(right);
18+
ans.addAll(right);
19+
return ans;
5720
}
5821

59-
private void addLeaves(TreeNode root) {
60-
if (isLeaf(root)) {
61-
res.add(root.val);
22+
private void dfs(List<Integer> nums, TreeNode root, int i) {
23+
if (root == null) {
6224
return;
6325
}
64-
if (root.left != null) {
65-
addLeaves(root.left);
66-
}
67-
if (root.right != null) {
68-
addLeaves(root.right);
26+
if (i == 0) {
27+
if (root.left != root.right) {
28+
nums.add(root.val);
29+
if (root.left != null) {
30+
dfs(nums, root.left, i);
31+
} else {
32+
dfs(nums, root.right, i);
33+
}
34+
}
35+
} else if (i == 1) {
36+
if (root.left == root.right) {
37+
nums.add(root.val);
38+
} else {
39+
dfs(nums, root.left, i);
40+
dfs(nums, root.right, i);
41+
}
42+
} else {
43+
if (root.left != root.right) {
44+
nums.add(root.val);
45+
if (root.right != null) {
46+
dfs(nums, root.right, i);
47+
} else {
48+
dfs(nums, root.left, i);
49+
}
50+
}
6951
}
7052
}
71-
72-
private boolean isLeaf(TreeNode node) {
73-
return node != null && node.left == null && node.right == null;
74-
}
7553
}

‎solution/0500-0599/0545.Boundary of Binary Tree/Solution.js

+39-44
Original file line numberDiff line numberDiff line change
@@ -11,54 +11,49 @@
1111
* @return {number[]}
1212
*/
1313
var boundaryOfBinaryTree = function (root) {
14-
let leftBoundary = function (root, res) {
15-
while (root) {
16-
let curVal = root.val;
17-
if (root.left) {
18-
root = root.left;
19-
} else if (root.right) {
20-
root = root.right;
21-
} else {
22-
break;
23-
}
24-
res.push(curVal);
14+
const ans = [root.val];
15+
if (root.left === root.right) {
16+
return ans;
17+
}
18+
19+
const left = [];
20+
const leaves = [];
21+
const right = [];
22+
23+
const dfs = function (nums, root, i) {
24+
if (!root) {
25+
return;
2526
}
26-
};
27-
let rightBoundary = function (root, res) {
28-
let stk = [];
29-
while (root) {
30-
let curVal = root.val;
31-
if (root.right) {
32-
root = root.right;
33-
} else if (root.left) {
34-
root = root.left;
27+
if (i === 0) {
28+
if (root.left !== root.right) {
29+
nums.push(root.val);
30+
if (root.left) {
31+
dfs(nums, root.left, i);
32+
} else {
33+
dfs(nums, root.right, i);
34+
}
35+
}
36+
} else if (i === 1) {
37+
if (root.left === root.right) {
38+
nums.push(root.val);
3539
} else {
36-
break;
40+
dfs(nums, root.left, i);
41+
dfs(nums, root.right, i);
3742
}
38-
stk.push(curVal);
39-
}
40-
let len = stk.length;
41-
for (let i = 0; i < len; i++) {
42-
res.push(stk.pop());
43-
}
44-
};
45-
let levelBoundary = function (root, res) {
46-
if (root) {
47-
levelBoundary(root.left, res);
48-
if (!root.left && !root.right) {
49-
res.push(root.val);
43+
} else {
44+
if (root.left !== root.right) {
45+
nums.push(root.val);
46+
if (root.right) {
47+
dfs(nums, root.right, i);
48+
} else {
49+
dfs(nums, root.left, i);
50+
}
5051
}
51-
levelBoundary(root.right, res);
5252
}
5353
};
54-
let res = [];
55-
if (root) {
56-
res.push(root.val);
57-
leftBoundary(root.left, res);
58-
if (root.left || root.right) {
59-
levelBoundary(root, res);
60-
}
61-
rightBoundary(root.right, res);
62-
}
63-
return res;
54+
55+
dfs(left, root.left, 0);
56+
dfs(leaves, root, 1);
57+
dfs(right, root.right, 2);
58+
return ans.concat(left).concat(leaves).concat(right.reverse());
6459
};

0 commit comments

Comments
 (0)