Skip to content

Commit 72118bf

Browse files
AnnatxuAnnatxu
authored
Update README.md
1 parent 34b4b96 commit 72118bf

File tree

1 file changed

+59
-231
lines changed
  • solution/0400-0499/0450.Delete Node in a BST

1 file changed

+59
-231
lines changed

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

Lines changed: 59 additions & 231 deletions
Original file line numberDiff line numberDiff line change
@@ -100,35 +100,65 @@ tags:
100100

101101
<!-- tabs:start -->
102102

103-
#### Python3
104-
105-
```python
106-
# Definition for a binary tree node.
107-
# class TreeNode:
108-
# def __init__(self, val=0, left=None, right=None):
109-
# self.val = val
110-
# self.left = left
111-
# self.right = right
112-
class Solution:
113-
def deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:
114-
if root is None:
115-
return None
116-
if root.val > key:
117-
root.left = self.deleteNode(root.left, key)
118-
return root
119-
if root.val < key:
120-
root.right = self.deleteNode(root.right, key)
121-
return root
122-
if root.left is None:
123-
return root.right
124-
if root.right is None:
125-
return root.left
126-
node = root.right
127-
while node.left:
128-
node = node.left
129-
node.left = root.left
130-
root = root.right
131-
return root
103+
#### java iteration
104+
105+
```java 1
106+
/**
107+
* Definition for a binary tree node.
108+
* public class TreeNode {
109+
* int val;
110+
* TreeNode left;
111+
* TreeNode right;
112+
* TreeNode() {}
113+
* TreeNode(int val) { this.val = val; }
114+
* TreeNode(int val, TreeNode left, TreeNode right) {
115+
* this.val = val;
116+
* this.left = left;
117+
* this.right = right;
118+
* }
119+
* }
120+
*/
121+
class Solution {
122+
public TreeNode deleteNode(TreeNode root, int key) {
123+
if (root == null) return null;
124+
if (root.val == key) return helper(root);
125+
126+
TreeNode dummy = root;
127+
while (root != null) {
128+
if (root.val > key) {
129+
if (root.left != null && root.left.val == key) {
130+
root.left = helper(root.left);
131+
break;
132+
} else {
133+
root = root.left;
134+
}
135+
} else {
136+
if (root.right != null && root.right.val == key) {
137+
root.right = helper(root.right);
138+
break;
139+
} else {
140+
root = root.right;
141+
}
142+
}
143+
}
144+
return dummy;
145+
}
146+
147+
private TreeNode helper(TreeNode root) {
148+
if (root.left == null) return root.right;
149+
if (root.right == null) return root.left;
150+
151+
TreeNode rightChild = root.right;
152+
TreeNode lastRight = findLastRight(root.left);
153+
lastRight.right = rightChild;
154+
return root.left;
155+
}
156+
157+
private TreeNode findLastRight(TreeNode root) {
158+
if (root.right == null) return root;
159+
return findLastRight(root.right);
160+
}
161+
}
132162
```
133163

134164
#### Java
@@ -179,208 +209,6 @@ class Solution {
179209
}
180210
```
181211

182-
#### C++
183-
184-
```cpp
185-
/**
186-
* Definition for a binary tree node.
187-
* struct TreeNode {
188-
* int val;
189-
* TreeNode *left;
190-
* TreeNode *right;
191-
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
192-
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
193-
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
194-
* };
195-
*/
196-
class Solution {
197-
public:
198-
TreeNode* deleteNode(TreeNode* root, int key) {
199-
if (!root) return root;
200-
if (root->val > key) {
201-
root->left = deleteNode(root->left, key);
202-
return root;
203-
}
204-
if (root->val < key) {
205-
root->right = deleteNode(root->right, key);
206-
return root;
207-
}
208-
if (!root->left) return root->right;
209-
if (!root->right) return root->left;
210-
TreeNode* node = root->right;
211-
while (node->left) node = node->left;
212-
node->left = root->left;
213-
root = root->right;
214-
return root;
215-
}
216-
};
217-
```
218-
219-
#### Go
220-
221-
```go
222-
/**
223-
* Definition for a binary tree node.
224-
* type TreeNode struct {
225-
* Val int
226-
* Left *TreeNode
227-
* Right *TreeNode
228-
* }
229-
*/
230-
func deleteNode(root *TreeNode, key int) *TreeNode {
231-
if root == nil {
232-
return nil
233-
}
234-
if root.Val > key {
235-
root.Left = deleteNode(root.Left, key)
236-
return root
237-
}
238-
if root.Val < key {
239-
root.Right = deleteNode(root.Right, key)
240-
return root
241-
}
242-
if root.Left == nil {
243-
return root.Right
244-
}
245-
if root.Right == nil {
246-
return root.Left
247-
}
248-
node := root.Right
249-
for node.Left != nil {
250-
node = node.Left
251-
}
252-
node.Left = root.Left
253-
root = root.Right
254-
return root
255-
}
256-
```
257-
258-
#### TypeScript
259-
260-
```ts
261-
/**
262-
* Definition for a binary tree node.
263-
* class TreeNode {
264-
* val: number
265-
* left: TreeNode | null
266-
* right: TreeNode | null
267-
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
268-
* this.val = (val===undefined ? 0 : val)
269-
* this.left = (left===undefined ? null : left)
270-
* this.right = (right===undefined ? null : right)
271-
* }
272-
* }
273-
*/
274-
275-
function deleteNode(root: TreeNode | null, key: number): TreeNode | null {
276-
if (root == null) {
277-
return root;
278-
}
279-
const { val, left, right } = root;
280-
if (val > key) {
281-
root.left = deleteNode(left, key);
282-
} else if (val < key) {
283-
root.right = deleteNode(right, key);
284-
} else {
285-
if (left == null && right == null) {
286-
root = null;
287-
} else if (left == null || right == null) {
288-
root = left || right;
289-
} else {
290-
if (right.left == null) {
291-
right.left = left;
292-
root = right;
293-
} else {
294-
let minPreNode = right;
295-
while (minPreNode.left.left != null) {
296-
minPreNode = minPreNode.left;
297-
}
298-
const minVal = minPreNode.left.val;
299-
root.val = minVal;
300-
minPreNode.left = deleteNode(minPreNode.left, minVal);
301-
}
302-
}
303-
}
304-
return root;
305-
}
306-
```
307-
308-
#### Rust
309-
310-
```rust
311-
// Definition for a binary tree node.
312-
// #[derive(Debug, PartialEq, Eq)]
313-
// pub struct TreeNode {
314-
// pub val: i32,
315-
// pub left: Option<Rc<RefCell<TreeNode>>>,
316-
// pub right: Option<Rc<RefCell<TreeNode>>>,
317-
// }
318-
//
319-
// impl TreeNode {
320-
// #[inline]
321-
// pub fn new(val: i32) -> Self {
322-
// TreeNode {
323-
// val,
324-
// left: None,
325-
// right: None
326-
// }
327-
// }
328-
// }
329-
use std::cell::RefCell;
330-
use std::rc::Rc;
331-
impl Solution {
332-
fn dfs(root: &Option<Rc<RefCell<TreeNode>>>) -> i32 {
333-
let node = root.as_ref().unwrap().borrow();
334-
if node.left.is_none() {
335-
return node.val;
336-
}
337-
Self::dfs(&node.left)
338-
}
339-
340-
pub fn delete_node(
341-
mut root: Option<Rc<RefCell<TreeNode>>>,
342-
key: i32,
343-
) -> Option<Rc<RefCell<TreeNode>>> {
344-
if root.is_some() {
345-
let mut node = root.as_mut().unwrap().borrow_mut();
346-
match node.val.cmp(&key) {
347-
std::cmp::Ordering::Less => {
348-
node.right = Self::delete_node(node.right.take(), key);
349-
}
350-
std::cmp::Ordering::Greater => {
351-
node.left = Self::delete_node(node.left.take(), key);
352-
}
353-
std::cmp::Ordering::Equal => {
354-
match (node.left.is_some(), node.right.is_some()) {
355-
(false, false) => {
356-
return None;
357-
}
358-
(true, false) => {
359-
return node.left.take();
360-
}
361-
(false, true) => {
362-
return node.right.take();
363-
}
364-
(true, true) => {
365-
if node.right.as_ref().unwrap().borrow().left.is_none() {
366-
let mut r = node.right.take();
367-
r.as_mut().unwrap().borrow_mut().left = node.left.take();
368-
return r;
369-
} else {
370-
let val = Self::dfs(&node.right);
371-
node.val = val;
372-
node.right = Self::delete_node(node.right.take(), val);
373-
}
374-
}
375-
};
376-
}
377-
}
378-
}
379-
root
380-
}
381-
}
382-
```
383-
384212
<!-- tabs:end -->
385213

386214
<!-- solution:end -->

0 commit comments

Comments
 (0)