Skip to content

Commit 1e9d109

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc/lcci problems
* lc No.0897.Increasing Order Search Tree * lcci No.17.12.BiNode
1 parent 19ec8d9 commit 1e9d109

File tree

15 files changed

+607
-229
lines changed

15 files changed

+607
-229
lines changed

‎lcci/17.12.BiNode/README.md

+99-28
Original file line numberDiff line numberDiff line change
@@ -29,10 +29,15 @@
2929

3030
<!-- 这里可写通用的实现逻辑 -->
3131

32-
递归将左子树、右子树转换为左、右链表 left 和 right。然后将左链表 left 的最后一个结点的 right 指针指向 root，root 的 right 指针指向右链表 right，并将 root 的 left 指针值为空。
32+
**方法一：中序遍历**
33+
34+
中序遍历过程中改变指针指向。
35+
36+
时间复杂度 O(n)。
3337

3438
同 [897. 递增顺序查找树](/solution/0800-0899/0897.Increasing%20Order%20Search%20Tree/README.md)。
3539

40+
3641
<!-- tabs:start -->
3742

3843
### **Python3**
@@ -49,20 +54,20 @@
4954

5055
class Solution:
5156
def convertBiNode(self, root: TreeNode) -> TreeNode:
52-
if root is None:
53-
return None
54-
left = self.convertBiNode(root.left)
55-
right = self.convertBiNode(root.right)
56-
if left is None:
57-
root.right = right
58-
return root
59-
res = left
60-
while left and left.right:
61-
left = left.right
62-
left.right = root
63-
root.right = right
64-
root.left = None
65-
return res
57+
def dfs(root):
58+
if root is None:
59+
return
60+
nonlocal prev
61+
dfs(root.left)
62+
prev.right = root
63+
root.left = None
64+
prev = root
65+
dfs(root.right)
66+
67+
dummy = TreeNode(val=0, right=root)
68+
prev = dummy
69+
dfs(root)
70+
return dummy.right
6671
```
6772

6873
### **Java**
@@ -80,26 +85,92 @@ class Solution:
8085
* }
8186
*/
8287
class Solution {
88+
private TreeNode prev;
89+
8390
public TreeNode convertBiNode(TreeNode root) {
84-
if (root == null) return null;
85-
TreeNode left = convertBiNode(root.left);
86-
TreeNode right = convertBiNode(root.right);
87-
if (left == null) {
88-
root.right = right;
89-
return root;
90-
}
91-
TreeNode res = left;
92-
while (left != null && left.right != null) {
93-
left = left.right;
91+
TreeNode dummy = new TreeNode(0, null, root);
92+
prev = dummy;
93+
dfs(root);
94+
return dummy.right;
95+
}
96+
97+
private void dfs(TreeNode root) {
98+
if (root == null) {
99+
return;
94100
}
95-
left.right = root;
96-
root.right = right;
101+
dfs(root.left);
102+
prev.right = root;
97103
root.left = null;
98-
return res;
104+
prev = root;
105+
dfs(root.right);
99106
}
100107
}
101108
```
102109

110+
### **C++**
111+
112+
```cpp
113+
/**
114+
* Definition for a binary tree node.
115+
* struct TreeNode {
116+
* int val;
117+
* TreeNode *left;
118+
* TreeNode *right;
119+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
120+
* };
121+
*/
122+
class Solution {
123+
public:
124+
TreeNode* prev;
125+
126+
TreeNode* convertBiNode(TreeNode* root) {
127+
TreeNode* dummy = new TreeNode(0, nullptr, root);
128+
prev = dummy;
129+
dfs(root);
130+
return dummy->right;
131+
}
132+
133+
void dfs(TreeNode* root) {
134+
if (!root) return;
135+
dfs(root->left);
136+
prev->right = root;
137+
root->left = nullptr;
138+
prev = root;
139+
dfs(root->right);
140+
}
141+
};
142+
```
143+
144+
### **Go**
145+
146+
```go
147+
/**
148+
* Definition for a binary tree node.
149+
* type TreeNode struct {
150+
* Val int
151+
* Left *TreeNode
152+
* Right *TreeNode
153+
* }
154+
*/
155+
func convertBiNode(root *TreeNode) *TreeNode {
156+
dummy := &TreeNode{Val: 0, Right: root}
157+
prev := dummy
158+
var dfs func(root *TreeNode)
159+
dfs = func(root *TreeNode) {
160+
if root == nil {
161+
return
162+
}
163+
dfs(root.Left)
164+
prev.Right = root
165+
root.Left = nil
166+
prev = root
167+
dfs(root.Right)
168+
}
169+
dfs(root)
170+
return dummy.Right
171+
}
172+
```
173+
103174
### **...**
104175

105176
```

‎lcci/17.12.BiNode/README_EN.md

+94-28
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,7 @@
3030

3131
## Solutions
3232

33-
See [897. Increasing Order Search Tree](/solution/0800-0899/0897.Increasing%20Order%20Search%20Tree/README_EN.md).
33+
Similar to [897. Increasing Order Search Tree](/solution/0800-0899/0897.Increasing%20Order%20Search%20Tree/README_EN.md).
3434

3535
<!-- tabs:start -->
3636

@@ -46,20 +46,20 @@ See [897. Increasing Order Search Tree](/solution/0800-0899/0897.Increasing%20Or
4646

4747
class Solution:
4848
def convertBiNode(self, root: TreeNode) -> TreeNode:
49-
if root is None:
50-
return None
51-
left = self.convertBiNode(root.left)
52-
right = self.convertBiNode(root.right)
53-
if left is None:
54-
root.right = right
55-
return root
56-
res = left
57-
while left and left.right:
58-
left = left.right
59-
left.right = root
60-
root.right = right
61-
root.left = None
62-
return res
49+
def dfs(root):
50+
if root is None:
51+
return
52+
nonlocal prev
53+
dfs(root.left)
54+
prev.right = root
55+
root.left = None
56+
prev = root
57+
dfs(root.right)
58+
59+
dummy = TreeNode(val=0, right=root)
60+
prev = dummy
61+
dfs(root)
62+
return dummy.right
6363
```
6464

6565
### **Java**
@@ -75,23 +75,89 @@ class Solution:
7575
* }
7676
*/
7777
class Solution {
78+
private TreeNode prev;
79+
7880
public TreeNode convertBiNode(TreeNode root) {
79-
if (root == null) return null;
80-
TreeNode left = convertBiNode(root.left);
81-
TreeNode right = convertBiNode(root.right);
82-
if (left == null) {
83-
root.right = right;
84-
return root;
85-
}
86-
TreeNode res = left;
87-
while (left != null && left.right != null) {
88-
left = left.right;
81+
TreeNode dummy = new TreeNode(0, null, root);
82+
prev = dummy;
83+
dfs(root);
84+
return dummy.right;
85+
}
86+
87+
private void dfs(TreeNode root) {
88+
if (root == null) {
89+
return;
8990
}
90-
left.right = root;
91-
root.right = right;
91+
dfs(root.left);
92+
prev.right = root;
9293
root.left = null;
93-
return res;
94+
prev = root;
95+
dfs(root.right);
96+
}
97+
}
98+
```
99+
100+
### **C++**
101+
102+
```cpp
103+
/**
104+
* Definition for a binary tree node.
105+
* struct TreeNode {
106+
* int val;
107+
* TreeNode *left;
108+
* TreeNode *right;
109+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
110+
* };
111+
*/
112+
class Solution {
113+
public:
114+
TreeNode* prev;
115+
116+
TreeNode* convertBiNode(TreeNode* root) {
117+
TreeNode* dummy = new TreeNode(0, nullptr, root);
118+
prev = dummy;
119+
dfs(root);
120+
return dummy->right;
121+
}
122+
123+
void dfs(TreeNode* root) {
124+
if (!root) return;
125+
dfs(root->left);
126+
prev->right = root;
127+
root->left = nullptr;
128+
prev = root;
129+
dfs(root->right);
94130
}
131+
};
132+
```
133+
134+
### **Go**
135+
136+
```go
137+
/**
138+
* Definition for a binary tree node.
139+
* type TreeNode struct {
140+
* Val int
141+
* Left *TreeNode
142+
* Right *TreeNode
143+
* }
144+
*/
145+
func convertBiNode(root *TreeNode) *TreeNode {
146+
dummy := &TreeNode{Val: 0, Right: root}
147+
prev := dummy
148+
var dfs func(root *TreeNode)
149+
dfs = func(root *TreeNode) {
150+
if root == nil {
151+
return
152+
}
153+
dfs(root.Left)
154+
prev.Right = root
155+
root.Left = nil
156+
prev = root
157+
dfs(root.Right)
158+
}
159+
dfs(root)
160+
return dummy.Right
95161
}
96162
```
97163

‎lcci/17.12.BiNode/Solution.cpp

+29
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8+
* };
9+
*/
10+
class Solution {
11+
public:
12+
TreeNode* prev;
13+
14+
TreeNode* convertBiNode(TreeNode* root) {
15+
TreeNode* dummy = new TreeNode(0, nullptr, root);
16+
prev = dummy;
17+
dfs(root);
18+
return dummy->right;
19+
}
20+
21+
void dfs(TreeNode* root) {
22+
if (!root) return;
23+
dfs(root->left);
24+
prev->right = root;
25+
root->left = nullptr;
26+
prev = root;
27+
dfs(root->right);
28+
}
29+
};

‎lcci/17.12.BiNode/Solution.go

+25
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
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 convertBiNode(root *TreeNode) *TreeNode {
10+
dummy := &TreeNode{Val: 0, Right: root}
11+
prev := dummy
12+
var dfs func(root *TreeNode)
13+
dfs = func(root *TreeNode) {
14+
if root == nil {
15+
return
16+
}
17+
dfs(root.Left)
18+
prev.Right = root
19+
root.Left = nil
20+
prev = root
21+
dfs(root.Right)
22+
}
23+
dfs(root)
24+
return dummy.Right
25+
}

0 commit comments

Comments
 (0)