Question

C++, data structure

using :binarySearchTree

Deleting an element from a binary search tree is far more complicated than inserting an element in a binary search tree. An analysis of binary search tree deletion finds 4 cases:

Case 1: The node to be deleted has no left and right subtrees

Case 2: The node to be deleted has no left subtree but does have a right subtree.

Case 3: The node to be deleted has no right subtee but does have a left subtree

Case 4: The node to be deleted has non empty left and right subtrees.

The implementation of case 4 - see the file binarySearchTree.h in the zipped file - swaps the info in the largest node in the node to be deleted's left subtree with the info in the node to be deleted. The choice of the largest node in the node to be deleted's left subtree is arbitrary. It is just as easy to swap with the node in the node to be deleted's right subtree. Rewrite the function to swap info with the smallest element in the node to be deleted's right subtree.

Answer 1

PROGRAM:

#include<iostream>
#include<stdlib.h>
using namespace std;  

class BST{
private:
   struct node
   {
int key;
struct node *left, *right;
   };
  
   struct node*root;

   struct node* insert(struct node* Node , struct node*newNode)
   {
if (Node == NULL) return newNode;

if (newNode->key < Node->key)
Node->left = insert(Node->left, newNode);
else if (newNode->key > Node->key)
Node->right = insert(Node->right, newNode);   

return Node;
   }

struct node * minValueNode(struct node* node)
{
struct node* current = node;
  
/* loop down to find the leftmost leaf */
while (current->left != NULL)
current = current->left;
  
return current;
}

struct node* deleteNode(struct node* root, int key)
{
// base case
if (root == NULL) return root;
  
// If the key to be deleted is smaller than the root's key,
// then it lies in left subtree
if (key < root->key)
root->left = deleteNode(root->left, key);
  
// If the key to be deleted is greater than the root's key,
// then it lies in right subtree
else if (key > root->key)
root->right = deleteNode(root->right, key);
  
// if key is same as root's key, then This is the node
// to be deleted
else
{
// node with only one child or no child
if (root->left == NULL)
{
struct node *temp = root->right;
delete(root);
return temp;
}
else if (root->right == NULL)
{
struct node *temp = root->left;
delete(root);
return temp;
}
  
// node with two children: Get the inorder successor (smallest
// in the right subtree)
struct node* temp = minValueNode(root->right);
  
// Copy the inorder successor's content to this node
root->key = temp->key;
  
// Delete the inorder successor
root->right = deleteNode(root->right, temp->key);
}
return root;
}  

int size(struct node*Node){
   if(!Node)return 0;
   return 1+size(Node->left)+size(Node->right);
}

void inorder(struct node*Node )

{
   if(!Node)return;
   inorder(Node->left );
   cout<<Node->key<<" ";
   inorder(Node->right );
}

void Postorder(struct node*Node )

{
   if(!Node)return;
   Postorder(Node->left );
  
   Postorder(Node->right );
   cout<<Node->key<<" ";
}
public:
   BST(){
   root=NULL;
}
  void Insert(int item)
   {
struct node *temp = new struct node;
temp->key = item;
temp->left =NULL;
   temp->right = NULL;
root= insert(root,temp);
   }
  
   void Delete(int item){
       root= deleteNode(root,item);
   }
int Size(){
       return size(root);
   }
void PrintInorder(){
   inorder(root);
   }
void PrintPostorder()

{
   Postorder(root);
   }

};

int main(){
   int arr[]={20,5,8,3,12,9,2,16};
   BST bst;
   int n = sizeof(arr)/sizeof(int);
   cout<<"Inserting nodes with ";
   for(int i=0;i<n;i++){
       cout<<arr[i]<<" ";
       bst.Insert(arr[i]);
   }
   cout<<"\n\n";
   cout<<"The number of nodes in the tree is now "<<bst.Size()<<"\n\n";
   cout<<"Here are the values in the tree in order:\n";
   bst.PrintInorder();
   cout<<"\n\n";
   cout<<"Now deleting 8 from tree.......\n";
   bst.Delete(8);
   cout<<"Now deleting 12 from tree.......\n";
   bst.Delete(12);
   cout<<"The number of nodes in the tree is now "<<bst.Size()<<"\n\n";
   cout<<"Here are the values in the tree in order:\n";
   bst.PrintInorder();
   cout<<"\n\n";
   cout<<"Here are the values in the tree POST order:\n";
   bst.PrintPostorder();
   cout<<"\n\n";

}