Skip to content

Commit ad26a58

Browse files
maolonglongmaolonglong
committed
feat: add solutions to lcof2 problem: No.052
1 parent aade7c0 commit ad26a58

File tree

5 files changed

+267
-1
lines changed

5 files changed

+267
-1
lines changed

‎lcof2/剑指 Offer II 052. 展平二叉搜索树/README.md

+139-1
Original file line numberDiff line numberDiff line change
@@ -44,22 +44,160 @@
4444

4545
<!-- 这里可写通用的实现逻辑 -->
4646

47+
由于二叉搜索树的性质，可以利用中序遍历得到递增序列
48+
4749
<!-- tabs:start -->
4850

4951
### **Python3**
5052

5153
<!-- 这里可写当前语言的特殊实现逻辑 -->
5254

5355
```python
54-
56+
# Definition for a binary tree node.
57+
# class TreeNode:
58+
# def __init__(self, val=0, left=None, right=None):
59+
# self.val = val
60+
# self.left = left
61+
# self.right = right
62+
class Solution:
63+
def increasingBST(self, root: TreeNode) -> TreeNode:
64+
head, tail = None, None
65+
stack = []
66+
cur = root
67+
while stack or cur:
68+
while cur:
69+
stack.append(cur)
70+
cur = cur.left
71+
cur = stack.pop()
72+
if not head:
73+
head = cur
74+
else:
75+
tail.right = cur
76+
tail = cur
77+
cur.left = None
78+
cur = cur.right
79+
return head
5580
```
5681

5782
### **Java**
5883

5984
<!-- 这里可写当前语言的特殊实现逻辑 -->
6085

6186
```java
87+
/**
88+
* Definition for a binary tree node.
89+
* public class TreeNode {
90+
* int val;
91+
* TreeNode left;
92+
* TreeNode right;
93+
* TreeNode() {}
94+
* TreeNode(int val) { this.val = val; }
95+
* TreeNode(int val, TreeNode left, TreeNode right) {
96+
* this.val = val;
97+
* this.left = left;
98+
* this.right = right;
99+
* }
100+
* }
101+
*/
102+
class Solution {
103+
public TreeNode increasingBST(TreeNode root) {
104+
TreeNode head = null, tail = null;
105+
Deque<TreeNode> stack = new ArrayDeque<>();
106+
TreeNode cur = root;
107+
while (!stack.isEmpty() || cur != null) {
108+
while (cur != null) {
109+
stack.push(cur);
110+
cur = cur.left;
111+
}
112+
cur = stack.pop();
113+
if (head == null) {
114+
head = cur;
115+
} else {
116+
tail.right = cur;
117+
}
118+
tail = cur;
119+
cur.left = null;
120+
cur = cur.right;
121+
}
122+
return head;
123+
}
124+
}
125+
```
126+
127+
### **Go**
128+
129+
```go
130+
/**
131+
* Definition for a binary tree node.
132+
* type TreeNode struct {
133+
* Val int
134+
* Left *TreeNode
135+
* Right *TreeNode
136+
* }
137+
*/
138+
func increasingBST(root *TreeNode) *TreeNode {
139+
var head, tail *TreeNode
140+
stack := make([]*TreeNode, 0)
141+
cur := root
142+
for len(stack) > 0 || cur != nil {
143+
for cur != nil {
144+
stack = append(stack, cur)
145+
cur = cur.Left
146+
}
147+
cur = stack[len(stack)-1]
148+
stack = stack[:len(stack)-1]
149+
if head == nil {
150+
head = cur
151+
} else {
152+
tail.Right = cur
153+
}
154+
tail = cur
155+
cur.Left = nil
156+
cur = cur.Right
157+
}
158+
return head
159+
}
160+
```
62161

162+
### **C++**
163+
164+
```cpp
165+
/**
166+
* Definition for a binary tree node.
167+
* struct TreeNode {
168+
* int val;
169+
* TreeNode *left;
170+
* TreeNode *right;
171+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
172+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
173+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
174+
* };
175+
*/
176+
class Solution {
177+
public:
178+
TreeNode* increasingBST(TreeNode* root) {
179+
TreeNode *head = nullptr, *tail = nullptr;
180+
stack<TreeNode*> stk;
181+
TreeNode* cur = root;
182+
while (!stk.empty() || cur != nullptr) {
183+
while (cur != nullptr) {
184+
stk.push(cur);
185+
cur = cur->left;
186+
}
187+
cur = stk.top();
188+
stk.pop();
189+
if (head == nullptr) {
190+
head = cur;
191+
} else {
192+
tail->right = cur;
193+
}
194+
tail = cur;
195+
cur->left = nullptr;
196+
cur = cur->right;
197+
}
198+
return head;
199+
}
200+
};
63201
```
64202
65203
### **...**

‎lcof2/剑指 Offer II 052. 展平二叉搜索树/Solution.cpp

+36
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
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+
TreeNode* increasingBST(TreeNode* root) {
15+
TreeNode *head = nullptr, *tail = nullptr;
16+
stack<TreeNode*> stk;
17+
TreeNode* cur = root;
18+
while (!stk.empty() || cur != nullptr) {
19+
while (cur != nullptr) {
20+
stk.push(cur);
21+
cur = cur->left;
22+
}
23+
cur = stk.top();
24+
stk.pop();
25+
if (head == nullptr) {
26+
head = cur;
27+
} else {
28+
tail->right = cur;
29+
}
30+
tail = cur;
31+
cur->left = nullptr;
32+
cur = cur->right;
33+
}
34+
return head;
35+
}
36+
};

‎lcof2/剑指 Offer II 052. 展平二叉搜索树/Solution.go

+30
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
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 increasingBST(root *TreeNode) *TreeNode {
10+
var head, tail *TreeNode
11+
stack := make([]*TreeNode, 0)
12+
cur := root
13+
for len(stack) > 0 || cur != nil {
14+
for cur != nil {
15+
stack = append(stack, cur)
16+
cur = cur.Left
17+
}
18+
cur = stack[len(stack)-1]
19+
stack = stack[:len(stack)-1]
20+
if head == nil {
21+
head = cur
22+
} else {
23+
tail.Right = cur
24+
}
25+
tail = cur
26+
cur.Left = nil
27+
cur = cur.Right
28+
}
29+
return head
30+
}

‎lcof2/剑指 Offer II 052. 展平二叉搜索树/Solution.java

+38
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,38 @@
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+
*/
16+
class Solution {
17+
public TreeNode increasingBST(TreeNode root) {
18+
TreeNode head = null, tail = null;
19+
Deque<TreeNode> stack = new ArrayDeque<>();
20+
TreeNode cur = root;
21+
while (!stack.isEmpty() || cur != null) {
22+
while (cur != null) {
23+
stack.push(cur);
24+
cur = cur.left;
25+
}
26+
cur = stack.pop();
27+
if (head == null) {
28+
head = cur;
29+
} else {
30+
tail.right = cur;
31+
}
32+
tail = cur;
33+
cur.left = null;
34+
cur = cur.right;
35+
}
36+
return head;
37+
}
38+
}

‎lcof2/剑指 Offer II 052. 展平二叉搜索树/Solution.py

+24
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
# Definition for a binary tree node.
2+
# class TreeNode:
3+
# def __init__(self, val=0, left=None, right=None):
4+
# self.val = val
5+
# self.left = left
6+
# self.right = right
7+
class Solution:
8+
def increasingBST(self, root: TreeNode) -> TreeNode:
9+
head, tail = None, None
10+
stack = []
11+
cur = root
12+
while stack or cur:
13+
while cur:
14+
stack.append(cur)
15+
cur = cur.left
16+
cur = stack.pop()
17+
if not head:
18+
head = cur
19+
else:
20+
tail.right = cur
21+
tail = cur
22+
cur.left = None
23+
cur = cur.right
24+
return head

0 commit comments

Comments
 (0)