A Binary Search Tree (BST) is a special type of binary tree in which the left child of a node has a value less than the node’s value and the right child has a value greater than the node’s value. This property is called the BST property and it makes it possible to efficiently search, insert, and delete elements in the tree.
The root of a BST is the node that has the smallest value in the left subtree and the largest value in the right subtree. Each left subtree is a BST with nodes that have smaller values than the root and each right subtree is a BST with nodes that have larger values than the root.
Binary Search Tree is a node-based binary tree data structure that has the following properties:
- The left subtree of a node contains only nodes with keys lesser than the node’s key.
- The right subtree of a node contains only nodes with keys greater than the node’s key.
- This means everything to the left of the root is less than the value of the root and everything to the right of the root is greater than the value of the root. Due to this performing, a binary search is very easy.
- The left and right subtree each must also be a binary search tree.
There must be no duplicate nodes(BST may have duplicate values with different handling approaches)
Handling approach for Duplicate values in the Binary Search tree:
- You can not allow the duplicated values at all.
- We must follow a consistent process throughout i.e either store duplicate value at the left or store the duplicate value at the right of the root, but be consistent with your approach.
- We can keep the counter with the node and if we found the duplicate value, then we can increment the counter
Below are the various operations that can be performed on a BST:
- Insert a node into a BST: A new key is always inserted at the leaf. Start searching a key from the root till a leaf node. Once a leaf node is found, the new node is added as a child of the leaf node.
C++
#include <bits/stdc++.h>
using namespace std;
struct node
{
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp = (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key)
{
node->left = insert(node->left, key);
}
else if (key > node->key)
{
node->right = insert(node->right, key);
}
return node;
}
void inorder(struct node* root)
{
if (root != NULL)
{
inorder(root->left);
cout << root->key << " ";
inorder(root->right);
}
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
inorder(root);
return 0;
}
|
C
#include <stdio.h>
#include <stdlib.h>
struct node {
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp
= (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key) {
node->left = insert(node->left, key);
}
else if (key > node->key) {
node->right = insert(node->right, key);
}
return node;
}
void inorder(struct node* root)
{
if (root != NULL) {
inorder(root->left);
printf("%d ", root->key);
inorder(root->right);
}
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
inorder(root);
return 0;
}
|
Java
import java.io.*;
class GFG {
static class node {
int key;
node left, right;
};
static node newNode(int item)
{
node temp = new node();
temp.key = item;
temp.left = temp.right = null;
return temp;
}
static node insert(node node, int key)
{
if (node == null)
return newNode(key);
if (key < node.key) {
node.left = insert(node.left, key);
}
else if (key > node.key) {
node.right = insert(node.right, key);
}
return node;
}
static void inorder(node root)
{
if (root != null) {
inorder(root.left);
System.out.print(" " + root.key);
inorder(root.right);
}
}
public static void main(String[] args)
{
node root = null;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
inorder(root);
}
}
|
Python3
class Node:
def __init__(self, key):
self.key = key
self.left = None
self.right = None
def insert(node, key):
if node is None:
return Node(key)
if key < node.key:
node.left = insert(node.left, key)
elif key > node.key:
node.right = insert(node.right, key)
return node
def inorder(root):
if root is not None:
inorder(root.left)
print(root.key, end=" ")
inorder(root.right)
if __name__ == '__main__':
root = None
root = insert(root, 50)
insert(root, 30)
insert(root, 20)
insert(root, 40)
insert(root, 70)
insert(root, 60)
insert(root, 80)
inorder(root)
|
Javascript
class Node
{
constructor(key){
this.key = key;
this.left = null;
this.right = null;
}
}
function insert(node, key)
{
if (node == null)
return new Node(key);
if (key < node.key)
{
node.left = insert(node.left, key);
}
else if (key > node.key)
{
node.right = insert(node.right, key);
}
return node;
}
function inorder(root)
{
if (root != null)
{
inorder(root.left);
document.write(root.key + " ");
inorder(root.right);
}
}
let root = null;
root = insert(root, 50);
root = insert(root, 30);
root = insert(root, 20);
root = insert(root, 40);
root = insert(root, 70);
root = insert(root, 60);
root = insert(root, 80);
inorder(root);
|
Output
20 30 40 50 60 70 80
Time Complexity: O(N), where N is the number of nodes of the BST
Auxiliary Space: O(1)
- Inorder traversal: In case of binary search trees (BST), Inorder traversal gives nodes in non-decreasing order. We visit the left child first, then the root, and then the right child.
C++
#include <bits/stdc++.h>
using namespace std;
struct node
{
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp = (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key)
{
node->left = insert(node->left, key);
}
else if (key > node->key)
{
node->right = insert(node->right, key);
}
return node;
}
void inorder(struct node* root)
{
if (root != NULL)
{
inorder(root->left);
cout << " " << root->key;
inorder(root->right);
}
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
inorder(root);
return 0;
}
|
C
#include <stdio.h>
#include <stdlib.h>
struct node {
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp
= (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key) {
node->left = insert(node->left, key);
}
else if (key > node->key) {
node->right = insert(node->right, key);
}
return node;
}
void inorder(struct node* root)
{
if (root != NULL) {
inorder(root->left);
printf("%d ", root->key);
inorder(root->right);
}
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
inorder(root);
return 0;
}
|
Java
import java.io.*;
class GFG {
static class node {
int key;
node left, right;
};
static node newNode(int item)
{
node temp = new node();
temp.key = item;
temp.left = temp.right = null;
return temp;
}
static node insert(node node, int key)
{
if (node == null)
return newNode(key);
if (key < node.key) {
node.left = insert(node.left, key);
}
else if (key > node.key) {
node.right = insert(node.right, key);
}
return node;
}
static void inorder(node root)
{
if (root != null) {
inorder(root.left);
System.out.print(" " + root.key);
inorder(root.right);
}
}
public static void main(String[] args)
{
node root = null;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
inorder(root);
}
}
|
Python3
class Node:
def __init__(self, key):
self.key = key
self.left = None
self.right = None
def newNode(item):
temp = Node(item)
temp.key = item
temp.left = temp.right = None
return temp
def insert(node, key):
if node is None:
return newNode(key)
if key < node.key:
node.left = insert(node.left, key)
elif key > node.key:
node.right = insert(node.right, key)
return node
def inorder(root):
if root:
inorder(root.left)
print(root.key, end=" ")
inorder(root.right)
if __name__ == '__main__':
root = None
root = insert(root, 50)
insert(root, 30)
insert(root, 20)
insert(root, 40)
insert(root, 70)
insert(root, 60)
insert(root, 80)
inorder(root)
|
Output
20 30 40 50 60 70 80
Time Complexity: O(N), where N is the number of nodes of the BST
Auxiliary Space: O(1)
- Preorder traversal: Preorder traversal first visits the root node and then traverses the left and the right subtree. It is used to create a copy of the tree. Preorder traversal is also used to get prefix expression on of an expression tree.
C++
#include <bits/stdc++.h>
using namespace std;
struct node {
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp
= (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key) {
node->left = insert(node->left, key);
}
else if (key > node->key) {
node->right = insert(node->right, key);
}
return node;
}
void preOrder(struct node* root)
{
if (root != NULL) {
cout << " " << root->key;
preOrder(root->left);
preOrder(root->right);
}
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
preOrder(root);
return 0;
}
|
C
#include <stdio.h>
#include <stdlib.h>
struct node {
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp
= (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key) {
node->left = insert(node->left, key);
}
else if (key > node->key) {
node->right = insert(node->right, key);
}
return node;
}
void preOrder(struct node* root)
{
if (root != NULL) {
printf("%d ", root->key);
preOrder(root->left);
preOrder(root->right);
}
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
preOrder(root);
return 0;
}
|
Java
import java.io.*;
class GFG {
static class node {
int key;
node left, right;
};
static node newNode(int item)
{
node temp = new node();
temp.key = item;
temp.left = temp.right = null;
return temp;
}
static node insert(node node, int key)
{
if (node == null)
return newNode(key);
if (key < node.key) {
node.left = insert(node.left, key);
}
else if (key > node.key) {
node.right = insert(node.right, key);
}
return node;
}
static void preOrder(node root)
{
if (root != null) {
System.out.print(root.key + " ");
preOrder(root.left);
preOrder(root.right);
}
}
public static void main(String[] args)
{
node root = null;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
preOrder(root);
}
}
|
Python3
class Node:
def __init__(self, key):
self.key = key
self.left = None
self.right = None
def insert(node, key):
if node is None:
return Node(key)
if key < node.key:
node.left = insert(node.left, key)
elif key > node.key:
node.right = insert(node.right, key)
return node
def preOrder(root):
if root:
print(root.key, end=" ")
preOrder(root.left)
preOrder(root.right)
if __name__ == '__main__':
root = None
keys = [50, 30, 20, 40, 70, 60, 80]
for key in keys:
root = insert(root, key)
preOrder(root)
|
Output
50 30 20 40 70 60 80
Time Complexity: O(N), where N is the number of nodes of the BST
Auxiliary Space: O(1)
- Postorder traversal: Postorder traversal first traverses the left and the right subtree and then visits the root node. It is used to delete the tree. In simple words, visit the root of every subtree last.
C++
#include <iostream>
using namespace std;
struct node
{
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp = (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key)
{
node->left = insert(node->left, key);
}
else if (key > node->key)
{
node->right = insert(node->right, key);
}
return node;
}
void postOrder(struct node* root)
{
if (root != NULL)
{
postOrder(root->left);
postOrder(root->right);
cout << " " << root->key;
}
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
postOrder(root);
return 0;
}
|
C
#include <stdio.h>
#include <stdlib.h>
struct node {
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp
= (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key) {
node->left = insert(node->left, key);
}
else if (key > node->key) {
node->right = insert(node->right, key);
}
return node;
}
void postOrder(struct node* root)
{
if (root != NULL) {
postOrder(root->left);
postOrder(root->right);
printf("%d ", root->key);
}
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
postOrder(root);
return 0;
}
|
Java
import java.io.*;
class GFG {
static class node {
int key;
node left, right;
};
static node newNode(int item)
{
node temp = new node();
temp.key = item;
temp.left = temp.right = null;
return temp;
}
static node insert(node node, int key)
{
if (node == null)
return newNode(key);
if (key < node.key) {
node.left = insert(node.left, key);
}
else if (key > node.key) {
node.right = insert(node.right, key);
}
return node;
}
static void postOrder(node root)
{
if (root != null) {
postOrder(root.left);
postOrder(root.right);
System.out.print(" " + root.key);
}
}
public static void main(String[] args)
{
node root = null;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
postOrder(root);
}
}
|
Python3
class Node:
def __init__(self, key):
self.key = key
self.left = None
self.right = None
def insert(node, key):
if node is None:
return Node(key)
if key < node.key:
node.left = insert(node.left, key)
elif key > node.key:
node.right = insert(node.right, key)
return node
def postOrder(root):
if root:
postOrder(root.left)
postOrder(root.right)
print(root.key, end=" ")
if __name__ == '__main__':
root = None
root = insert(root, 50)
insert(root, 30)
insert(root, 20)
insert(root, 40)
insert(root, 70)
insert(root, 60)
insert(root, 80)
postOrder(root)
|
Output
20 40 30 60 80 70 50
Time Complexity: O(N), where N is the number of nodes of the BST
Auxiliary Space: O(1)
- Level order traversal: Level order traversal of a BST is breadth first traversal for the tree. It visits all nodes at a particular level first before moving to the next level.
C++
#include <bits/stdc++.h>
using namespace std;
struct node {
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp
= (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key) {
node->left = insert(node->left, key);
}
else if (key > node->key) {
node->right = insert(node->right, key);
}
return node;
}
int height(struct node* node)
{
if (node == NULL)
return 0;
else {
int lDepth = height(node->left);
int rDepth = height(node->right);
if (lDepth > rDepth)
return (lDepth + 1);
else
return (rDepth + 1);
}
}
void printGivenLevel(struct node* root,
int level)
{
if (root == NULL)
return;
if (level == 1)
cout <<" "<< root->key;
else if (level > 1) {
printGivenLevel(root->left, level - 1);
printGivenLevel(root->right, level - 1);
}
}
void printLevelOrder(struct node* root)
{
int h = height(root);
int i;
for (i = 1; i <= h; i++) {
printGivenLevel(root, i);
cout <<"\n";
}
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
printLevelOrder(root);
return 0;
}
|
C
#include <stdio.h>
#include <stdlib.h>
struct node {
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp
= (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key) {
node->left = insert(node->left, key);
}
else if (key > node->key) {
node->right = insert(node->right, key);
}
return node;
}
int height(struct node* node)
{
if (node == NULL)
return 0;
else {
int lDepth = height(node->left);
int rDepth = height(node->right);
if (lDepth > rDepth)
return (lDepth + 1);
else
return (rDepth + 1);
}
}
void printGivenLevel(struct node* root,
int level)
{
if (root == NULL)
return;
if (level == 1)
printf("%d ", root->key);
else if (level > 1) {
printGivenLevel(root->left, level - 1);
printGivenLevel(root->right, level - 1);
}
}
void printLevelOrder(struct node* root)
{
int h = height(root);
int i;
for (i = 1; i <= h; i++) {
printGivenLevel(root, i);
printf("\n");
}
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
printLevelOrder(root);
return 0;
}
|
Java
import java.io.*;
class GFG {
static class node {
int key;
node left, right;
};
static node newNode(int item)
{
node temp = new node();
temp.key = item;
temp.left = temp.right = null;
return temp;
}
static node insert(node node, int key)
{
if (node == null)
return newNode(key);
if (key < node.key) {
node.left = insert(node.left, key);
}
else if (key > node.key) {
node.right = insert(node.right, key);
}
return node;
}
static int height(node node)
{
if (node == null)
return 0;
else {
int lDepth = height(node.left);
int rDepth = height(node.right);
if (lDepth > rDepth)
return (lDepth + 1);
else
return (rDepth + 1);
}
}
static void printGivenLevel(node root, int level)
{
if (root == null)
return;
if (level == 1)
System.out.print(" " + root.key);
else if (level > 1) {
printGivenLevel(root.left, level - 1);
printGivenLevel(root.right, level - 1);
}
}
static void printLevelOrder(node root)
{
int h = height(root);
int i;
for (i = 1; i <= h; i++) {
printGivenLevel(root, i);
System.out.println();
}
}
public static void main(String[] args)
{
node root = null;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
printLevelOrder(root);
}
}
|
Python3
import queue
class Node:
def __init__(self, key):
self.key = key
self.left = None
self.right = None
def insert(node, key):
if node is None:
return Node(key)
if key < node.key:
node.left = insert(node.left, key)
elif key > node.key:
node.right = insert(node.right, key)
return node
def height(node):
if node is None:
return 0
else:
lDepth = height(node.left)
rDepth = height(node.right)
if lDepth > rDepth:
return (lDepth + 1)
else:
return (rDepth + 1)
def printGivenLevel(root, level):
if root is None:
return
if level == 1:
print(root.key, end=" ")
elif level > 1:
printGivenLevel(root.left, level - 1)
printGivenLevel(root.right, level - 1)
def printLevelOrder(root):
h = height(root)
for i in range(1, h+1):
printGivenLevel(root, i)
print()
if __name__ == '__main__':
root = None
root = insert(root, 50)
insert(root, 30)
insert(root, 20)
insert(root, 40)
insert(root, 70)
insert(root, 60)
insert(root, 80)
printLevelOrder(root)
|
Output
50
30 70
20 40 60 80
Time Complexity: O(N), where N is the number of nodes of the BST
Auxiliary Space: O(1)
C++
#include <bits/stdc++.h>
using namespace std;
struct node {
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp
= (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key) {
node->left = insert(node->left, key);
}
else if (key > node->key) {
node->right = insert(node->right, key);
}
return node;
}
void printGivenLevel(struct node* root,
int level)
{
if (root == NULL)
return;
if (level == 1)
cout <<" "<< root->key;
else if (level > 1) {
printGivenLevel(root->left, level - 1);
printGivenLevel(root->right, level - 1);
}
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
printGivenLevel(root, 2);
return 0;
}
|
C
#include <stdio.h>
#include <stdlib.h>
struct node {
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp
= (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key) {
node->left = insert(node->left, key);
}
else if (key > node->key) {
node->right = insert(node->right, key);
}
return node;
}
void printGivenLevel(struct node* root,
int level)
{
if (root == NULL)
return;
if (level == 1)
printf("%d ", root->key);
else if (level > 1) {
printGivenLevel(root->left, level - 1);
printGivenLevel(root->right, level - 1);
}
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
printGivenLevel(root, 2);
return 0;
}
|
Java
import java.io.*;
class GFG {
static class node {
int key;
node left, right;
};
static node newNode(int item)
{
node temp = new node();
temp.key = item;
temp.left = temp.right = null;
return temp;
}
static node insert(node node, int key)
{
if (node == null)
return newNode(key);
if (key < node.key) {
node.left = insert(node.left, key);
}
else if (key > node.key) {
node.right = insert(node.right, key);
}
return node;
}
static void printGivenLevel(node root, int level)
{
if (root == null)
return;
if (level == 1)
System.out.print(" " + root.key);
else if (level > 1) {
printGivenLevel(root.left, level - 1);
printGivenLevel(root.right, level - 1);
}
}
public static void main(String[] args)
{
node root = null;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
printGivenLevel(root, 2);
}
}
|
Python3
class Node:
def __init__(self, key):
self.key = key
self.left = None
self.right = None
def insert(node, key):
if node is None:
return Node(key)
if key < node.key:
node.left = insert(node.left, key)
elif key > node.key:
node.right = insert(node.right, key)
return node
def printGivenLevel(root, level):
if root is None:
return
if level == 1:
print(root.key, end=' ')
elif level > 1:
printGivenLevel(root.left, level - 1)
printGivenLevel(root.right, level - 1)
if __name__ == '__main__':
root = None
root = insert(root, 50)
insert(root, 30)
insert(root, 20)
insert(root, 40)
insert(root, 70)
insert(root, 60)
insert(root, 80)
printGivenLevel(root, 2)
|
Time Complexity: O(N), where N is the number of nodes of the BST
Auxiliary Space: O(1)
C++
#include <bits/stdc++.h>
using namespace std;
struct node {
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp
= (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key) {
node->left = insert(node->left, key);
}
else if (key > node->key) {
node->right = insert(node->right, key);
}
return node;
}
void printLeafNodes(struct node* root)
{
if (!root)
return;
if (!root->left && !root->right) {
cout <<" "<< root->key;
return;
}
if (root->left)
printLeafNodes(root->left);
if (root->right)
printLeafNodes(root->right);
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
printLeafNodes(root);
return 0;
}
|
C
#include <stdio.h>
#include <stdlib.h>
struct node {
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp
= (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key) {
node->left = insert(node->left, key);
}
else if (key > node->key) {
node->right = insert(node->right, key);
}
return node;
}
void printLeafNodes(struct node* root)
{
if (!root)
return;
if (!root->left && !root->right) {
printf("%d ", root->key);
return;
}
if (root->left)
printLeafNodes(root->left);
if (root->right)
printLeafNodes(root->right);
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
printLeafNodes(root);
return 0;
}
|
Java
import java.io.*;
class GFG {
static class node {
int key;
node left, right;
};
static node newNode(int item)
{
node temp = new node();
temp.key = item;
temp.left = temp.right = null;
return temp;
}
static node insert(node node, int key)
{
if (node == null)
return newNode(key);
if (key < node.key) {
node.left = insert(node.left, key);
}
else if (key > node.key) {
node.right = insert(node.right, key);
}
return node;
}
static void printLeafNodes(node root)
{
if (root == null)
return;
if (root.left == null && root.right == null) {
System.out.print(" " + root.key);
return;
}
if (root.left != null)
printLeafNodes(root.left);
if (root.right != null)
printLeafNodes(root.right);
}
public static void main(String[] args)
{
node root = null;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
printLeafNodes(root);
}
}
|
Python3
class Node:
def __init__(self, item):
self.key = item
self.left = None
self.right = None
def insert(node, key):
if node is None:
return Node(key)
if key < node.key:
node.left = insert(node.left, key)
elif key > node.key:
node.right = insert(node.right, key)
return node
def printLeafNodes(root):
if not root:
return
if not root.left and not root.right:
print(root.key, end=" ")
if root.left:
printLeafNodes(root.left)
if root.right:
printLeafNodes(root.right)
if __name__ == "__main__":
root = None
root = insert(root, 50)
insert(root, 30)
insert(root, 20)
insert(root, 40)
insert(root, 70)
insert(root, 60)
insert(root, 80)
printLeafNodes(root)
|
Time Complexity: O(N), where N is the number of nodes of the BST
Auxiliary Space: O(1)
C++
#include <bits/stdc++.h>
using namespace std;
struct node {
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp
= (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key) {
node->left = insert(node->left, key);
}
else if (key > node->key) {
node->right = insert(node->right, key);
}
return node;
}
void printNonLeafNode(struct node* root)
{
if (root == NULL
|| (root->left == NULL
&& root->right == NULL))
return;
if (root->left != NULL
|| root->right != NULL) {
cout <<" "<< root->key;
}
printNonLeafNode(root->left);
printNonLeafNode(root->right);
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
printNonLeafNode(root);
return 0;
}
|
C
#include <stdio.h>
#include <stdlib.h>
struct node {
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp
= (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key) {
node->left = insert(node->left, key);
}
else if (key > node->key) {
node->right = insert(node->right, key);
}
return node;
}
void printNonLeafNode(struct node* root)
{
if (root == NULL
|| (root->left == NULL
&& root->right == NULL))
return;
if (root->left != NULL
|| root->right != NULL) {
printf("%d ", root->key);
}
printNonLeafNode(root->left);
printNonLeafNode(root->right);
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
printNonLeafNode(root);
return 0;
}
|
Java
import java.io.*;
class GFG {
static class node {
int key;
node left, right;
};
static node newNode(int item)
{
node temp = new node();
temp.key = item;
temp.left = temp.right = null;
return temp;
}
static node insert(node node, int key)
{
if (node == null)
return newNode(key);
if (key < node.key) {
node.left = insert(node.left, key);
}
else if (key > node.key) {
node.right = insert(node.right, key);
}
return node;
}
static void printNonLeafNode(node root)
{
if (root == null
|| (root.left == null && root.right == null))
return;
if (root.left != null || root.right != null) {
System.out.print(" " + root.key);
}
printNonLeafNode(root.left);
printNonLeafNode(root.right);
}
public static void main(String[] args)
{
node root = null;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
printNonLeafNode(root);
}
}
|
Python3
class Node:
def __init__(self, key):
self.key = key
self.left = None
self.right = None
def insert(root, key):
if root is None:
return Node(key)
if key < root.key:
root.left = insert(root.left, key)
elif key > root.key:
root.right = insert(root.right, key)
return root
def printNonLeafNode(root):
if root is None or (root.left is None and root.right is None):
return
if root.left is not None or root.right is not None:
print(root.key, end=" ")
printNonLeafNode(root.left)
printNonLeafNode(root.right)
if __name__ == '__main__':
root = None
root = insert(root, 50)
insert(root, 30)
insert(root, 20)
insert(root, 40)
insert(root, 70)
insert(root, 60)
insert(root, 80)
printNonLeafNode(root)
|
Time Complexity: O(N), where N is the number of nodes of the BST
Auxiliary Space: O(1)
- Right view of BST: Right view of a Binary Search Tree is set of nodes visible when tree is visited from Right side.
C++
#include <bits/stdc++.h>
using namespace std;
struct node {
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp
= (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key) {
node->left = insert(node->left, key);
}
else if (key > node->key) {
node->right = insert(node->right, key);
}
return node;
}
void rightViewUtil(struct node* root,
int level,
int* max_level)
{
if (root == NULL)
return;
if (*max_level < level) {
cout <<"\t"<< root->key;
*max_level = level;
}
rightViewUtil(root->right, level + 1,
max_level);
rightViewUtil(root->left, level + 1,
max_level);
}
void rightView(struct node* root)
{
int max_level = 0;
rightViewUtil(root, 1, &max_level);
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
rightView(root);
return 0;
}
|
C
#include <stdio.h>
#include <stdlib.h>
struct node {
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp
= (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key) {
node->left = insert(node->left, key);
}
else if (key > node->key) {
node->right = insert(node->right, key);
}
return node;
}
void rightViewUtil(struct node* root,
int level,
int* max_level)
{
if (root == NULL)
return;
if (*max_level < level) {
printf("%d\t", root->key);
*max_level = level;
}
rightViewUtil(root->right, level + 1,
max_level);
rightViewUtil(root->left, level + 1,
max_level);
}
void rightView(struct node* root)
{
int max_level = 0;
rightViewUtil(root, 1, &max_level);
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
rightView(root);
return 0;
}
|
Java
import java.io.*;
class GFG {
static class node {
int key;
node left, right;
};
static node newNode(int item)
{
node temp = new node();
temp.key = item;
temp.left = temp.right = null;
return temp;
}
static node insert(node node, int key)
{
if (node == null)
return newNode(key);
if (key < node.key) {
node.left = insert(node.left, key);
}
else if (key > node.key) {
node.right = insert(node.right, key);
}
return node;
}
static void rightViewUtil(node root, int level,
int max_level)
{
if (root == null)
return;
if (max_level < level) {
System.out.print(" " + root.key);
max_level = level;
}
rightViewUtil(root.right, level + 1, max_level);
}
static void rightView(node root)
{
int max_level = 0;
rightViewUtil(root, 1, max_level);
}
public static void main(String[] args)
{
node root = null;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
rightView(root);
}
}
|
Python3
import sys
class Node:
def __init__(self, key):
self.key = key
self.left = None
self.right = None
def insert(node, key):
if node is None:
return Node(key)
if key < node.key:
node.left = insert(node.left, key)
else:
node.right = insert(node.right, key)
return node
def rightViewUtil(root, level, max_level):
if root is None:
return
if (max_level[0] < level):
print("\t", root.key, end="")
max_level[0] = level
rightViewUtil(root.right, level + 1, max_level)
rightViewUtil(root.left, level + 1, max_level)
def rightView(root):
max_level = [0]
rightViewUtil(root, 1, max_level)
if __name__ == "__main__":
root = None
root = insert(root, 50)
insert(root, 30)
insert(root, 20)
insert(root, 40)
insert(root, 70)
insert(root, 60)
insert(root, 80)
rightView(root)
|
Time Complexity: O(N), where N is the number of nodes of the BST
Auxiliary Space: O(1)
- Left view of BST: Left view of a Binary Search Tree is set of nodes visible when tree is visited from Left side.
C++
#include<bits/stdc++.h>
using namespace std;
struct node {
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp
= (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key) {
node->left = insert(node->left, key);
}
else if (key > node->key) {
node->right = insert(node->right, key);
}
return node;
}
void leftViewUtil(struct node* root,
int level,
int* max_level)
{
if (root == NULL)
return;
if (*max_level < level) {
cout <<" "<< root->key;
*max_level = level;
}
leftViewUtil(root->left, level + 1,
max_level);
leftViewUtil(root->right, level + 1,
max_level);
}
void leftView(struct node* root)
{
int max_level = 0;
leftViewUtil(root, 1, &max_level);
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
leftView(root);
return 0;
}
|
C
#include <stdio.h>
#include <stdlib.h>
struct node {
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp
= (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key) {
node->left = insert(node->left, key);
}
else if (key > node->key) {
node->right = insert(node->right, key);
}
return node;
}
void leftViewUtil(struct node* root,
int level,
int* max_level)
{
if (root == NULL)
return;
if (*max_level < level) {
printf("%d\t", root->key);
*max_level = level;
}
leftViewUtil(root->left, level + 1,
max_level);
leftViewUtil(root->right, level + 1,
max_level);
}
void leftView(struct node* root)
{
int max_level = 0;
leftViewUtil(root, 1, &max_level);
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
leftView(root);
return 0;
}
|
Java
import java.io.*;
class GFG {
static class node {
int key;
node left, right;
};
static node newNode(int item)
{
node temp = new node();
temp.key = item;
temp.left = temp.right = null;
return temp;
}
static node insert(node node, int key)
{
if (node == null)
return newNode(key);
if (key < node.key) {
node.left = insert(node.left, key);
}
else if (key > node.key) {
node.right = insert(node.right, key);
}
return node;
}
static void leftViewUtil(node root, int level,
int max_level)
{
if (root == null)
return;
if (max_level < level) {
System.out.print(" " + root.key);
max_level = level;
}
leftViewUtil(root.left, level + 1, max_level);
}
static void leftView(node root)
{
int max_level = 0;
leftViewUtil(root, 1, max_level);
}
public static void main(String[] args)
{
node root = null;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
leftView(root);
}
}
|
Python3
class Node:
def __init__(self, key):
self.key = key
self.left = None
self.right = None
def insert(node, key):
if node is None:
return Node(key)
if key < node.key:
node.left = insert(node.left, key)
elif key > node.key:
node.right = insert(node.right, key)
return node
def leftViewUtil(root, level, max_level):
if root is None:
return
if max_level[0] < level:
print(root.key, end=" ")
max_level[0] = level
leftViewUtil(root.left, level + 1, max_level)
leftViewUtil(root.right, level + 1, max_level)
def leftView(root):
max_level = [0]
leftViewUtil(root, 1, max_level)
if __name__ == '__main__':
root = None
root = insert(root, 50)
insert(root, 30)
insert(root, 20)
insert(root, 40)
insert(root, 70)
insert(root, 60)
insert(root, 80)
leftView(root)
|
Time Complexity: O(N), where N is the number of nodes of the BST
Auxiliary Space: O(1)
- Height of BST: It is recursively calculated using height of left and right subtrees of the node and assigns height to the node as max of the heights of two children plus 1.
C++
#include <bits/stdc++.h>
using namespace std;
struct node
{
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp = (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key)
{
node->left = insert(node->left, key);
}
else if (key > node->key)
{
node->right = insert(node->right, key);
}
return node;
}
int height(struct node* node)
{
if (node == NULL)
return 0;
else
{
int lDepth = height(node->left);
int rDepth = height(node->right);
if (lDepth > rDepth)
return (lDepth + 1);
else
return (rDepth + 1);
}
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
cout << " " << height(root);
return 0;
}
|
C
#include <stdio.h>
#include <stdlib.h>
struct node {
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp
= (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key) {
node->left = insert(node->left, key);
}
else if (key > node->key) {
node->right = insert(node->right, key);
}
return node;
}
int height(struct node* node)
{
if (node == NULL)
return 0;
else {
int lDepth = height(node->left);
int rDepth = height(node->right);
if (lDepth > rDepth)
return (lDepth + 1);
else
return (rDepth + 1);
}
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
printf("%d", height(root));
return 0;
}
|
Java
import java.io.*;
class GFG {
static class node {
int key;
node left, right;
};
static node newNode(int item)
{
node temp = new node();
temp.key = item;
temp.left = temp.right = null;
return temp;
}
static node insert(node node, int key)
{
if (node == null)
return newNode(key);
if (key < node.key) {
node.left = insert(node.left, key);
}
else if (key > node.key) {
node.right = insert(node.right, key);
}
return node;
}
static int height(node node)
{
if (node == null)
return 0;
else {
int lDepth = height(node.left);
int rDepth = height(node.right);
if (lDepth > rDepth)
return (lDepth + 1);
else
return (rDepth + 1);
}
}
public static void main(String[] args)
{
node root = null;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
System.out.println(" " + height(root));
}
}
|
Python3
import sys
class Node:
def __init__(self, key):
self.key = key
self.left = None
self.right = None
def insert(root, key):
if root is None:
return Node(key)
if key < root.key:
root.left = insert(root.left, key)
elif key > root.key:
root.right = insert(root.right, key)
return root
def height(node):
if node is None:
return 0
else:
lDepth = height(node.left)
rDepth = height(node.right)
if lDepth > rDepth:
return lDepth + 1
else:
return rDepth + 1
if __name__ == '__main__':
root = None
root = insert(root, 50)
insert(root, 30)
insert(root, 20)
insert(root, 40)
insert(root, 70)
insert(root, 60)
insert(root, 80)
print(' ', height(root))
|
Time Complexity: O(N), where N is the number of nodes of the BST
Auxiliary Space: O(1)
- Delete a Node of BST: It is used to delete a node with specific key from the BST and return the new BST.
Different scenarios for deleting the node:
- Node to be deleted is the leaf node : Its simple you can just null it out.
- Node to be deleted has one child : You can just replace the node with the child node.
- Node to be deleted has two child :
- Need to figure out what will be the replacement of the node to be deleted.
- Want minimal disruption to the existing tree structure
- Can table the replacement node from the deleted nodes left or right subtree.
- If taking if from the left subtree, we have to take the largest value in the left subtree.
- If taking if from the right subtree, we have to take the smallest value in the right subtree.
- Choose one approach and stick to it.
C++
#include <bits/stdc++.h>
using namespace std;
struct node {
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp
= (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key) {
node->left = insert(node->left, key);
}
else if (key > node->key) {
node->right = insert(node->right, key);
}
return node;
}
void inorder(struct node* root)
{
if (root != NULL) {
inorder(root->left);
cout <<" "<< root->key;
inorder(root->right);
}
}
struct node* minValueNode(struct node* node)
{
struct node* current = node;
while (current && current->left != NULL)
current = current->left;
return current;
}
struct node* deleteNode(struct node* root,
int key)
{
if (root == NULL)
return root;
if (key < root->key) {
root->left
= deleteNode(root->left, key);
}
else if (key > root->key) {
root->right
= deleteNode(root->right, key);
}
else {
if (root->left == NULL) {
struct node* temp = root->right;
free(root);
return temp;
}
else if (root->right == NULL) {
struct node* temp = root->left;
free(root);
return temp;
}
struct node* temp = minValueNode(root->right);
root->key = temp->key;
root->right
= deleteNode(root->right, temp->key);
}
return root;
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
root = deleteNode(root, 60);
inorder(root);
return 0;
}
|
C
#include <stdio.h>
#include <stdlib.h>
struct node {
int key;
struct node *left, *right;
};
struct node* newNode(int item)
{
struct node* temp
= (struct node*)malloc(
sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
struct node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key) {
node->left = insert(node->left, key);
}
else if (key > node->key) {
node->right = insert(node->right, key);
}
return node;
}
void inorder(struct node* root)
{
if (root != NULL) {
inorder(root->left);
printf("%d ", root->key);
inorder(root->right);
}
}
struct node* minValueNode(struct node* node)
{
struct node* current = node;
while (current && current->left != NULL)
current = current->left;
return current;
}
struct node* deleteNode(struct node* root,
int key)
{
if (root == NULL)
return root;
if (key < root->key) {
root->left
= deleteNode(root->left, key);
}
else if (key > root->key) {
root->right
= deleteNode(root->right, key);
}
else {
if (root->left == NULL) {
struct node* temp = root->right;
free(root);
return temp;
}
else if (root->right == NULL) {
struct node* temp = root->left;
free(root);
return temp;
}
struct node* temp = minValueNode(root->right);
root->key = temp->key;
root->right
= deleteNode(root->right, temp->key);
}
return root;
}
int main()
{
struct node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
root = deleteNode(root, 60);
inorder(root);
return 0;
}
|
Java
import java.io.*;
class GFG {
static class node {
int key;
node left, right;
};
static node newNode(int item)
{
node temp = new node();
temp.key = item;
temp.left = temp.right = null;
return temp;
}
static node insert(node node, int key)
{
if (node == null)
return newNode(key);
if (key < node.key) {
node.left = insert(node.left, key);
}
else if (key > node.key) {
node.right = insert(node.right, key);
}
return node;
}
static void inorder(node root)
{
if (root != null) {
inorder(root.left);
System.out.print(" " + root.key);
inorder(root.right);
}
}
static node minValueNode(node node)
{
node current = node;
while (current != null && current.left != null)
current = current.left;
return current;
}
static node deleteNode(node root, int key)
{
if (root == null)
return root;
if (key < root.key) {
root.left = deleteNode(root.left, key);
}
else if (key > root.key) {
root.right = deleteNode(root.right, key);
}
else {
if (root.left == null) {
node temp = root.right;
return temp;
}
else if (root.right == null) {
node temp = root.left;
return temp;
}
node temp = minValueNode(root.right);
root.key = temp.key;
root.right = deleteNode(root.right, temp.key);
}
return root;
}
public static void main(String[] args)
{
node root = null;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
root = deleteNode(root, 60);
inorder(root);
}
}
|
Python3
class Node:
def __init__(self, key):
self.key = key
self.left = None
self.right = None
def insert(root, key):
if root is None:
return Node(key)
if key < root.key:
root.left = insert(root.left, key)
elif key > root.key:
root.right = insert(root.right, key)
return root
def inorder(root):
if root:
inorder(root.left)
print(root.key, end=" ")
inorder(root.right)
def minValueNode(node):
current = node
while current and current.left is not None:
current = current.left
return current
def deleteNode(root, key):
if root is None:
return root
if key < root.key:
root.left = deleteNode(root.left, key)
elif key > root.key:
root.right = deleteNode(root.right, key)
else:
if root.left is None:
temp = root.right
root = None
return temp
elif root.right is None:
temp = root.left
root = None
return temp
temp = minValueNode(root.right)
root.key = temp.key
root.right = deleteNode(root.right, temp.key)
return root
if __name__ == '__main__':
root = None
|