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 513982c

Browse files
committed
feat: add solutions to lc problem: No.0450
No.0450.Delete Node in a BST
1 parent 43b3253 commit 513982c

File tree

6 files changed

+417
-21
lines changed

6 files changed

+417
-21
lines changed

‎solution/0400-0499/0450.Delete Node in a BST/README.md‎

Lines changed: 146 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -48,7 +48,6 @@ key = 3
4848
4 7
4949
</pre>
5050

51-
5251
## 解法
5352

5453
<!-- 这里可写通用的实现逻辑 -->
@@ -60,15 +59,160 @@ key = 3
6059
<!-- 这里可写当前语言的特殊实现逻辑 -->
6160

6261
```python
63-
62+
# Definition for a binary tree node.
63+
# class TreeNode:
64+
# def __init__(self, val=0, left=None, right=None):
65+
# self.val = val
66+
# self.left = left
67+
# self.right = right
68+
class Solution:
69+
def deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:
70+
if root is None:
71+
return None
72+
if root.val > key:
73+
root.left = self.deleteNode(root.left, key)
74+
return root
75+
if root.val < key:
76+
root.right = self.deleteNode(root.right, key)
77+
return root
78+
if root.left is None:
79+
return root.right
80+
if root.right is None:
81+
return root.left
82+
node = root.right
83+
while node.left:
84+
node = node.left
85+
node.left = root.left
86+
root = root.right
87+
return root
6488
```
6589

6690
### **Java**
6791

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

7094
```java
95+
/**
96+
* Definition for a binary tree node.
97+
* public class TreeNode {
98+
* int val;
99+
* TreeNode left;
100+
* TreeNode right;
101+
* TreeNode() {}
102+
* TreeNode(int val) { this.val = val; }
103+
* TreeNode(int val, TreeNode left, TreeNode right) {
104+
* this.val = val;
105+
* this.left = left;
106+
* this.right = right;
107+
* }
108+
* }
109+
*/
110+
class Solution {
111+
public TreeNode deleteNode(TreeNode root, int key) {
112+
if (root == null) {
113+
return null;
114+
}
115+
if (root.val > key) {
116+
root.left = deleteNode(root.left, key);
117+
return root;
118+
}
119+
if (root.val < key) {
120+
root.right = deleteNode(root.right, key);
121+
return root;
122+
}
123+
if (root.left == null) {
124+
return root.right;
125+
}
126+
if (root.right == null) {
127+
return root.left;
128+
}
129+
TreeNode node = root.right;
130+
while (node.left != null) {
131+
node = node.left;
132+
}
133+
node.left = root.left;
134+
root = root.right;
135+
return root;
136+
}
137+
}
138+
```
139+
140+
### **C++**
141+
142+
```cpp
143+
/**
144+
* Definition for a binary tree node.
145+
* struct TreeNode {
146+
* int val;
147+
* TreeNode *left;
148+
* TreeNode *right;
149+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
150+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
151+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
152+
* };
153+
*/
154+
class Solution {
155+
public:
156+
TreeNode* deleteNode(TreeNode* root, int key) {
157+
if (!root) return root;
158+
if (root->val > key)
159+
{
160+
root->left = deleteNode(root->left, key);
161+
return root;
162+
}
163+
if (root->val < key)
164+
{
165+
root->right = deleteNode(root->right, key);
166+
return root;
167+
}
168+
if (!root->left) return root->right;
169+
if (!root->right) return root->left;
170+
TreeNode* node = root->right;
171+
while (node->left) node = node->left;
172+
node->left = root->left;
173+
root = root->right;
174+
return root;
175+
}
176+
};
177+
```
71178
179+
### **Go**
180+
181+
```go
182+
/**
183+
* Definition for a binary tree node.
184+
* type TreeNode struct {
185+
* Val int
186+
* Left *TreeNode
187+
* Right *TreeNode
188+
* }
189+
*/
190+
func deleteNode(root *TreeNode, key int) *TreeNode {
191+
if root == nil {
192+
return nil
193+
}
194+
if root.Val > key {
195+
root.Left = deleteNode(root.Left, key)
196+
return root
197+
}
198+
if root.Val < key {
199+
root.Right = deleteNode(root.Right, key)
200+
return root
201+
}
202+
if root.Left == nil {
203+
return root.Right
204+
}
205+
if root.Right == nil {
206+
return root.Left
207+
}
208+
node := root.Right
209+
for node.Left != nil {
210+
node = node.Left
211+
}
212+
node.Left = root.Left
213+
root = root.Right
214+
return root
215+
}
72216
```
73217

74218
### **...**

‎solution/0400-0499/0450.Delete Node in a BST/README_EN.md‎

Lines changed: 146 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -53,21 +53,165 @@ Please notice that another valid answer is [5,2,6,null,4,null,7] and it&#39;s al
5353
<li><code>-10<sup>5</sup> &lt;= key &lt;= 10<sup>5</sup></code></li>
5454
</ul>
5555

56-
5756
## Solutions
5857

5958
<!-- tabs:start -->
6059

6160
### **Python3**
6261

6362
```python
64-
63+
# Definition for a binary tree node.
64+
# class TreeNode:
65+
# def __init__(self, val=0, left=None, right=None):
66+
# self.val = val
67+
# self.left = left
68+
# self.right = right
69+
class Solution:
70+
def deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:
71+
if root is None:
72+
return None
73+
if root.val > key:
74+
root.left = self.deleteNode(root.left, key)
75+
return root
76+
if root.val < key:
77+
root.right = self.deleteNode(root.right, key)
78+
return root
79+
if root.left is None:
80+
return root.right
81+
if root.right is None:
82+
return root.left
83+
node = root.right
84+
while node.left:
85+
node = node.left
86+
node.left = root.left
87+
root = root.right
88+
return root
6589
```
6690

6791
### **Java**
6892

6993
```java
94+
/**
95+
* Definition for a binary tree node.
96+
* public class TreeNode {
97+
* int val;
98+
* TreeNode left;
99+
* TreeNode right;
100+
* TreeNode() {}
101+
* TreeNode(int val) { this.val = val; }
102+
* TreeNode(int val, TreeNode left, TreeNode right) {
103+
* this.val = val;
104+
* this.left = left;
105+
* this.right = right;
106+
* }
107+
* }
108+
*/
109+
class Solution {
110+
public TreeNode deleteNode(TreeNode root, int key) {
111+
if (root == null) {
112+
return null;
113+
}
114+
if (root.val > key) {
115+
root.left = deleteNode(root.left, key);
116+
return root;
117+
}
118+
if (root.val < key) {
119+
root.right = deleteNode(root.right, key);
120+
return root;
121+
}
122+
if (root.left == null) {
123+
return root.right;
124+
}
125+
if (root.right == null) {
126+
return root.left;
127+
}
128+
TreeNode node = root.right;
129+
while (node.left != null) {
130+
node = node.left;
131+
}
132+
node.left = root.left;
133+
root = root.right;
134+
return root;
135+
}
136+
}
137+
```
138+
139+
### **C++**
140+
141+
```cpp
142+
/**
143+
* Definition for a binary tree node.
144+
* struct TreeNode {
145+
* int val;
146+
* TreeNode *left;
147+
* TreeNode *right;
148+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
149+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
150+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
151+
* };
152+
*/
153+
class Solution {
154+
public:
155+
TreeNode* deleteNode(TreeNode* root, int key) {
156+
if (!root) return root;
157+
if (root->val > key)
158+
{
159+
root->left = deleteNode(root->left, key);
160+
return root;
161+
}
162+
if (root->val < key)
163+
{
164+
root->right = deleteNode(root->right, key);
165+
return root;
166+
}
167+
if (!root->left) return root->right;
168+
if (!root->right) return root->left;
169+
TreeNode* node = root->right;
170+
while (node->left) node = node->left;
171+
node->left = root->left;
172+
root = root->right;
173+
return root;
174+
}
175+
};
176+
```
70177
178+
### **Go**
179+
180+
```go
181+
/**
182+
* Definition for a binary tree node.
183+
* type TreeNode struct {
184+
* Val int
185+
* Left *TreeNode
186+
* Right *TreeNode
187+
* }
188+
*/
189+
func deleteNode(root *TreeNode, key int) *TreeNode {
190+
if root == nil {
191+
return nil
192+
}
193+
if root.Val > key {
194+
root.Left = deleteNode(root.Left, key)
195+
return root
196+
}
197+
if root.Val < key {
198+
root.Right = deleteNode(root.Right, key)
199+
return root
200+
}
201+
if root.Left == nil {
202+
return root.Right
203+
}
204+
if root.Right == nil {
205+
return root.Left
206+
}
207+
node := root.Right
208+
for node.Left != nil {
209+
node = node.Left
210+
}
211+
node.Left = root.Left
212+
root = root.Right
213+
return root
214+
}
71215
```
72216

73217
### **...**
Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
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* deleteNode(TreeNode* root, int key) {
15+
if (!root) return root;
16+
if (root->val > key)
17+
{
18+
root->left = deleteNode(root->left, key);
19+
return root;
20+
}
21+
if (root->val < key)
22+
{
23+
root->right = deleteNode(root->right, key);
24+
return root;
25+
}
26+
if (!root->left) return root->right;
27+
if (!root->right) return root->left;
28+
TreeNode* node = root->right;
29+
while (node->left) node = node->left;
30+
node->left = root->left;
31+
root = root->right;
32+
return root;
33+
}
34+
};

0 commit comments

Comments
(0)

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