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 9226ec0

Browse files
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

Lines changed: 323 additions & 144 deletions
Large diffs are not rendered by default.

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

Lines changed: 322 additions & 143 deletions
Large diffs are not rendered by default.
Lines changed: 59 additions & 0 deletions
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+
};
Lines changed: 61 additions & 0 deletions
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+
}
Lines changed: 44 additions & 66 deletions
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

Lines changed: 39 additions & 44 deletions
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)

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