Tree
Binary Search Tree
Binary Tree
Description
Given a root node reference of a BST and a key, delete the node with the given key in the BST. Return the root node reference (possibly updated) of the BST .
Basically, the deletion can be divided into two stages:
Search for a node to remove.
If the node is found, delete the node.
Example 1:
Input: root = [5,3,6,2,4,null,7], key = 3
Output: [5,4,6,2,null,null,7]
Explanation: Given key to delete is 3. So we find the node with value 3 and delete it.
One valid answer is [5,4,6,2,null,null,7], shown in the above BST.
Please notice that another valid answer is [5,2,6,null,4,null,7] and it's also accepted.
Example 2:
Input: root = [5,3,6,2,4,null,7], key = 0
Output: [5,3,6,2,4,null,7]
Explanation: The tree does not contain a node with value = 0.
Example 3:
Input: root = [], key = 0
Output: []
Constraints:
The number of nodes in the tree is in the range [0, 104 ]
.
-105 <= Node.val <= 105
Each node has a unique value.
root
is a valid binary search tree.
-105 <= key <= 105
Follow up: Could you solve it with time complexity O(height of tree)
?
Solutions
Solution 1
Python3 Java C++ Go TypeScript Rust
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26 # Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution :
def deleteNode ( self , root : Optional [ TreeNode ], key : int ) -> Optional [ TreeNode ]:
if root is None :
return None
if root . val > key :
root . left = self . deleteNode ( root . left , key )
return root
if root . val < key :
root . right = self . deleteNode ( root . right , key )
return root
if root . left is None :
return root . right
if root . right is None :
return root . left
node = root . right
while node . left :
node = node . left
node . left = root . left
root = root . right
return root
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43 /**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public TreeNode deleteNode ( TreeNode root , int key ) {
if ( root == null ) {
return null ;
}
if ( root . val > key ) {
root . left = deleteNode ( root . left , key );
return root ;
}
if ( root . val < key ) {
root . right = deleteNode ( root . right , key );
return root ;
}
if ( root . left == null ) {
return root . right ;
}
if ( root . right == null ) {
return root . left ;
}
TreeNode node = root . right ;
while ( node . left != null ) {
node = node . left ;
}
node . left = root . left ;
root = root . right ;
return root ;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32 /**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public :
TreeNode * deleteNode ( TreeNode * root , int key ) {
if ( ! root ) return root ;
if ( root -> val > key ) {
root -> left = deleteNode ( root -> left , key );
return root ;
}
if ( root -> val < key ) {
root -> right = deleteNode ( root -> right , key );
return root ;
}
if ( ! root -> left ) return root -> right ;
if ( ! root -> right ) return root -> left ;
TreeNode * node = root -> right ;
while ( node -> left ) node = node -> left ;
node -> left = root -> left ;
root = root -> right ;
return root ;
}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34 /**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func deleteNode ( root * TreeNode , key int ) * TreeNode {
if root == nil {
return nil
}
if root . Val > key {
root . Left = deleteNode ( root . Left , key )
return root
}
if root . Val < key {
root . Right = deleteNode ( root . Right , key )
return root
}
if root . Left == nil {
return root . Right
}
if root . Right == nil {
return root . Left
}
node := root . Right
for node . Left != nil {
node = node . Left
}
node . Left = root . Left
root = root . Right
return root
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45 /**
* Definition for a binary tree node.
* class TreeNode {
* val: number
* left: TreeNode | null
* right: TreeNode | null
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
* }
*/
function deleteNode ( root : TreeNode | null , key : number ) : TreeNode | null {
if ( root == null ) {
return root ;
}
const { val , left , right } = root ;
if ( val > key ) {
root . left = deleteNode ( left , key );
} else if ( val < key ) {
root . right = deleteNode ( right , key );
} else {
if ( left == null && right == null ) {
root = null ;
} else if ( left == null || right == null ) {
root = left || right ;
} else {
if ( right . left == null ) {
right . left = left ;
root = right ;
} else {
let minPreNode = right ;
while ( minPreNode . left . left != null ) {
minPreNode = minPreNode . left ;
}
const minVal = minPreNode . left . val ;
root . val = minVal ;
minPreNode . left = deleteNode ( minPreNode . left , minVal );
}
}
}
return root ;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71 // Definition for a binary tree node.
// #[derive(Debug, PartialEq, Eq)]
// pub struct TreeNode {
// pub val: i32,
// pub left: Option<Rc<RefCell<TreeNode>>>,
// pub right: Option<Rc<RefCell<TreeNode>>>,
// }
//
// impl TreeNode {
// #[inline]
// pub fn new(val: i32) -> Self {
// TreeNode {
// val,
// left: None,
// right: None
// }
// }
// }
use std :: cell :: RefCell ;
use std :: rc :: Rc ;
impl Solution {
fn dfs ( root : & Option < Rc < RefCell < TreeNode >>> ) -> i32 {
let node = root . as_ref (). unwrap (). borrow ();
if node . left . is_none () {
return node . val ;
}
Self :: dfs ( & node . left )
}
pub fn delete_node (
mut root : Option < Rc < RefCell < TreeNode >>> ,
key : i32 ,
) -> Option < Rc < RefCell < TreeNode >>> {
if root . is_some () {
let mut node = root . as_mut (). unwrap (). borrow_mut ();
match node . val . cmp ( & key ) {
std :: cmp :: Ordering :: Less => {
node . right = Self :: delete_node ( node . right . take (), key );
}
std :: cmp :: Ordering :: Greater => {
node . left = Self :: delete_node ( node . left . take (), key );
}
std :: cmp :: Ordering :: Equal => {
match ( node . left . is_some (), node . right . is_some ()) {
( false , false ) => {
return None ;
}
( true , false ) => {
return node . left . take ();
}
( false , true ) => {
return node . right . take ();
}
( true , true ) => {
if node . right . as_ref (). unwrap (). borrow (). left . is_none () {
let mut r = node . right . take ();
r . as_mut (). unwrap (). borrow_mut (). left = node . left . take ();
return r ;
} else {
let val = Self :: dfs ( & node . right );
node . val = val ;
node . right = Self :: delete_node ( node . right . take (), val );
}
}
};
}
}
}
root
}
}
GitHub