Delete nodes which are greater than or equal to given value in BST

Delete nodes which are greater than or equal to value

Here given code implementation process.

//C Program 
//Delete nodes which are greater than or equal to given value in BST
#include<stdio.h>
#include<stdlib.h>
//structure of Binary Search Tree node
struct Node
{
  int data;
  struct Node *left,*right; 
};

//Adding a new node in binary search tree
void add( struct Node **root, int data)
{
  //Create a dynamic node of binary search tree 
  struct Node *new_node = (struct Node *)malloc(sizeof(struct Node ));

  if(new_node!=NULL)
  {
    //Set data and pointer values
    new_node->data = data;
    new_node->left = NULL; //Initially node left-pointer is NULL
    new_node->right = NULL;//Initially node right-pointer is NULL

    if(*root == NULL)
    {
      //When adds a first node in binary tree
      *root = new_node;
    }
    else
    {
      struct Node *find = *root;
      //Iterate binary tree and add new node to proper position
      while(find != NULL)
      {
        if(find -> data > data)
        { 
          if(find->left==NULL)
          {
            find->left = new_node;
            break;
          }
          else
          { //visit left sub-tree
            find = find->left;
          }
        }
        else
        {
          if(find->right == NULL)
          {
            find->right = new_node;
            break;
          }
          else
          {
            //visit right sub-tree
            find = find->right;
          }
        }
      }
    }
  }else
  {
    printf("Memory Overflow\n");
    exit(0); //Terminate program execution
  }

}

void swap_data(struct Node*root1,struct Node*root2)
{
  int temp=root2->data;
  root2->data=root1->data;
  root1->data=temp;
}

struct Node* remove_node(struct Node*root,int key)
{
  if(root != NULL)
  {
   
      root->right = remove_node(root->right,key);

      root->left = remove_node(root->left,key);
    
          
 
    
    struct Node*temp=NULL,*back=NULL;
    if(root->data >= key)
    {
      if(root->left==NULL)
      {
        temp=root;
        root=root->right;
      }
      else if(root->right==NULL)
      {
        temp=root;
        root=root->left;
      }
      else
      {
        temp=root->left;
        back=root;
        while(temp->right!=NULL)
        {
          back=temp;
          temp=temp->right;
        }
        if(root->left==temp)
        {
          swap_data(root,temp);
          root->left=temp->left;
        }
        else{
          swap_data(root,temp);
          back->right=temp->left;
        }
      }

      if(temp!=NULL)
      {
        free(temp);
        temp=NULL;
      }
    }

  }
  return root;
}

struct Node* delete_node(struct Node*root,int key)
{
  if(root!=NULL)
  {

    
    root=remove_node(root,key);

  }
  else
  {
    printf("\n  Empty BST\n");
  }
  printf("\n");
  return root;
}
void inorder(struct Node*root)
{
  if(root!=NULL)
  {

    inorder(root->left);
    printf("%3d ",root->data );
    inorder(root->right);
  }
}
int main(){

  struct Node*root = NULL;

  //Add nodes in binary search tree
  /*
              5
            /   \ 
           /     \
          3       19
         / \     /  \
        2   4   8    31
       /       / \    /
      1       7   15  25   


  */                

  add(&root,5); 
  add(&root,3); 
  add(&root,19); 
  add(&root,2); 
  add(&root,4); 
  add(&root,8); 
  add(&root,31); 
  add(&root,1); 
  add(&root,7); 
  add(&root,25); 
  add(&root,15); 


  inorder(root);

  root=delete_node(root,8);

  /*
    After delete nodes 
    -----------------
              5
            /   \ 
           /     \
          3       7
         / \    
        2   4  
       /           
      1             
  */
  inorder(root);
  return 0;
}

Output

  1   2   3   4   5   7   8  15  19  25  31 
  1   2   3   4   5   7
/*
 C++ Program
 Delete nodes which are greater than or equal to given value in BST
*/

#include <iostream>

using namespace std;
class Node {
public:
  int data;
  Node *left;
  Node *right;
  Node(int value) {
    this->data = value;
    this->left = NULL;
    this->right = NULL;
  }
};
class BinarySearchTree {
public:
  Node *root;
  BinarySearchTree() {
    this->root = NULL;
  }
  void add(int value) {
    Node *new_node = new Node(value);
    if (new_node != NULL) {
      if (this->root == NULL) {
        this->root = new_node;
      } else {
        Node *find = this->root;
        while (find != NULL) {
          if (find->data >= value) {
            if (find->left == NULL) {
              find->left = new_node;
              break;
            } else {
              find = find->left;
            }
          } else {
            if (find->right == NULL) {
              find->right = new_node;
              break;
            } else {
              find = find->right;
            }
          }
        }
      }
    } else {
      cout << "\nMemory Overflow\n";
    }
  }
  void inorder(Node *head) {
    if (head != NULL) {
      this->inorder(head->left);
      cout << head->data << "  ";
      this->inorder(head->right);
    }
  }
  void swap_data(Node *root1, Node *root2) {
    int temp = root2->data;
    root2->data = root1->data;
    root1->data = temp;
  }
  Node *remove_node(Node *head, int key) {
    if (head != NULL) {
      head->right = this->remove_node(head->right, key);
      head->left = this->remove_node(head->left, key);
      Node *temp = NULL, *back = NULL;
      if (head->data >= key) {
        if (head->left == NULL) {
          temp = head;
          head = head->right;
        } else
        if (head->right == NULL) {
          temp = head;
          head = head->left;
        } else {
          temp = head->left;
          back = head;
          while (temp->right != NULL) {
            back = temp;
            temp = temp->right;
          }
          if (head->left == temp) {
            this->swap_data(head, temp);
            head->left = temp->left;
          } else {
            this->swap_data(head, temp);
            back->right = temp->left;
          }
        }
        temp = NULL;
      }
    }
    return head;
  }
  void delete_keys(int key) {
    if (this->root != NULL) {
      this->root = this->remove_node(this->root, key);
    } else {
      cout << "\n  Empty BST\n";
    }
    cout << "\n";
  }
};

int main() {
  BinarySearchTree obj ;
  /*
              5
            /   \ 
           /     \
          3       19
         / \     /  \
        2   4   8    31
       /       / \    /
      1       7   15  25   


  */   
  obj.add(5);
  obj.add(3);
  obj.add(19);
  obj.add(2);
  obj.add(4);
  obj.add(8);
  obj.add(31);
  obj.add(1);
  obj.add(7);
  obj.add(25);
  obj.add(15);
  obj.inorder(obj.root);
  obj.delete_keys(8);
    /*
    After delete nodes 
    -----------------
              5
            /   \ 
           /     \
          3       7
         / \    
        2   4  
       /           
      1             
  */
  obj.inorder(obj.root);
  return 0;
}

Output

  1   2   3   4   5   7   8  15  19  25  31 
  1   2   3   4   5   7
//Java program
//Delete nodes which are greater than or equal to given value in BST

//BST node
class Node {

  public int data;
  public Node left;
  public Node right;

  public Node(int value) {
    data = value;
    left = null;
    right = null;
  }
}
public class BinarySearchTree {


  public Node root;


  public BinarySearchTree() {
    root = null;

  }
  //insert a node in BST
  public void add(int value) {
    //Create a dynamic node of binary search tree 
    Node new_node = new Node(value);

    if (new_node != null) {
      if (root == null) {
        //When adds a first node in binary tree
        root = new_node;
      } else {
        Node find = root;

        //add new node to proper position
        while (find != null) {
          if (find.data >= value) {
            if (find.left == null) {
              find.left = new_node;
              break;
            } else {
              //visit left sub-tree
              find = find.left;
            }
          } else {
            if (find.right == null) {
              find.right = new_node;
              break;
            } else {
              //visit right sub-tree
              find = find.right;
            }
          }
        }
      }
    } else {
      System.out.print("\nMemory Overflow\n");
    }
  }

  public void inorder(Node head) {
    if (head != null) {

      inorder(head.left);
      System.out.print(head.data + "  ");
      inorder(head.right);
    }
  }

  public void swap_data(Node root1, Node root2) {
    int temp = root2.data;
    root2.data = root1.data;
    root1.data = temp;
  }
  public Node  remove_node(Node head,int key)
{
  if(head != null)
  {
   
      head.right = remove_node(head.right,key);

      head.left = remove_node(head.left,key);
    
          
 
    
    Node temp=null, back=null;
    if(head.data >= key)
    {
      if(head.left==null)
      {
        temp=head;
        head=head.right;
      }
      else if(head.right==null)
      {
        temp=head;
        head=head.left;
      }
      else
      {
        temp=head.left;
        back=head;
        while(temp.right!=null)
        {
          back=temp;
          temp=temp.right;
        }
        if(head.left==temp)
        {
          swap_data(head,temp);
          head.left=temp.left;
        }
        else{
          swap_data(head,temp);
          back.right=temp.left;
        }
      }

      temp=null;
      
    }

  }
  return head;
}

  public void delete_keys(int key) {
    if (root != null) {

     
        root = remove_node(root, key);

    } else {
      System.out.print("\n  Empty BST\n");
    }
    System.out.print("\n");

  }

  public static void main(String[] args) {

    BinarySearchTree obj = new BinarySearchTree();
   //Add nodes in binary search tree
    /*
                5
              /   \ 
             /     \
            3       19
           / \     /   \
          2   4   8     31
         /       / \    /
        1       7   15  25   


    */                

    obj.add(5); 
    obj.add(3); 
    obj.add(19); 
    obj.add(2); 
    obj.add(4); 
    obj.add(8); 
    obj.add(31); 
    obj.add(1); 
    obj.add(7); 
    obj.add(25); 
    obj.add(15); 


    obj.inorder(obj.root);

    obj.delete_keys(8);

     /*
      After delete nodes 
      -----------------
                5
              /   \ 
             /     \
            3       7
           / \    
          2   4  
         /           
        1             
    */

    obj.inorder(obj.root);

  }
}

Output

  1   2   3   4   5   7   8  15  19  25  31 
  1   2   3   4   5   7
//C# program
//Delete nodes which are greater than or equal to given value in BST

using System;
//BST node
public class Node {

  public int data;
  public Node left;
  public Node right;

  public Node(int value) {
    data = value;
    left = null;
    right = null;
  }
}
public class BinarySearchTree {


  public Node root;


  public BinarySearchTree() {
    root = null;

  }
  //insert a node in BST
  public void add(int value) {
    //Create a dynamic node of binary search tree 
    Node new_node = new Node(value);

    if (new_node != null) {
      if (root == null) {
        //When adds a first node in binary tree
        root = new_node;
      } else {
        Node find = root;

        //add new node to proper position
        while (find != null) {
          if (find.data >= value) {
            if (find.left == null) {
              find.left = new_node;
              break;
            } else {
              //visit left sub-tree
              find = find.left;
            }
          } else {
            if (find.right == null) {
              find.right = new_node;
              break;
            } else {
              //visit right sub-tree
              find = find.right;
            }
          }
        }
      }
    } else {
      Console.Write("\nMemory Overflow\n");
    }
  }

  public void inorder(Node head) {
    if (head != null) {

      inorder(head.left);
      Console.Write(head.data + "  ");
      inorder(head.right);
    }
  }

  public void swap_data(Node root1, Node root2) {
    int temp = root2.data;
    root2.data = root1.data;
    root1.data = temp;
  }
  public Node  remove_node(Node head,int key)
  {
    if(head != null)
    {

      head.right = remove_node(head.right,key);

      head.left = remove_node(head.left,key);




      Node temp=null, back=null;
      if(head.data >= key)
      {
        if(head.left==null)
        {
          temp=head;
          head=head.right;
        }
        else if(head.right==null)
        {
          temp=head;
          head=head.left;
        }
        else
        {
          temp=head.left;
          back=head;
          while(temp.right!=null)
          {
            back=temp;
            temp=temp.right;
          }
          if(head.left==temp)
          {
            swap_data(head,temp);
            head.left=temp.left;
          }
          else{
            swap_data(head,temp);
            back.right=temp.left;
          }
        }

        temp=null;

      }

    }
    return head;
  }

  public void delete_keys(int key) {
    if (root != null) {


      root = remove_node(root, key);

    } else {
      Console.Write("\n  Empty BST\n");
    }
    Console.Write("\n");

  }

  public static void Main(String[] args) {

    BinarySearchTree obj = new BinarySearchTree();
    //Add nodes in binary search tree
    /*
                5
              /   \ 
             /     \
            3       19
           / \     /   \
          2   4   8     31
         /       / \    /
        1       7   15  25   


    */                

    obj.add(5); 
    obj.add(3); 
    obj.add(19); 
    obj.add(2); 
    obj.add(4); 
    obj.add(8); 
    obj.add(31); 
    obj.add(1); 
    obj.add(7); 
    obj.add(25); 
    obj.add(15); 


    obj.inorder(obj.root);

    obj.delete_keys(8);

    /*
      After delete nodes 
      -----------------
                5
              /   \ 
             /     \
            3       7
           / \    
          2   4  
         /           
        1             
    */

    obj.inorder(obj.root);

  }
}

Output

  1   2   3   4   5   7   8  15  19  25  31 
  1   2   3   4   5   7
# Python 3 Program
# Delete nodes which are greater than or equal to given value in BST

class Node :

  def __init__(self, value) :
    self.data = value
    self.left = None
    self.right = None
  

class BinarySearchTree :
  
  def __init__(self) :
    self.root = None
  
  def add(self, value) :
    new_node = Node(value)
    if (new_node != None) :
      if (self.root == None) :
        self.root = new_node
      else :
        find = self.root
        while (find != None) :
          if (find.data >= value) :
            if (find.left == None) :
              find.left = new_node
              break
            else :
              find = find.left
            
          else :
            if (find.right == None) :
              find.right = new_node
              break
            else :
              find = find.right
            
          
        
      
    else :
      print("\nMemory Overflow\n")
    
  
  def inorder(self, head) :
    if (head != None) :
      self.inorder(head.left)
      print(head.data ,end="  ")
      self.inorder(head.right)
    
  
  def swap_data(self, root1, root2) :
    temp = root2.data
    root2.data = root1.data
    root1.data = temp
  
  def remove_node(self, head, key) :
    if (head != None) :
      head.right = self.remove_node(head.right, key)
      head.left = self.remove_node(head.left, key)
      temp = None
      back = None
      if (head.data >= key) :
        if (head.left == None) :
          temp = head
          head = head.right
        elif (head.right == None) :
          temp = head
          head = head.left
        else :
          temp = head.left
          back = head
          while (temp.right != None) :
            back = temp
            temp = temp.right
          
          if (head.left == temp) :
            self.swap_data(head, temp)
            head.left = temp.left
          else :
            self.swap_data(head, temp)
            back.right = temp.left
          
        
        temp = None
      
    
    return head
  
  def delete_keys(self, key) :
    if (self.root != None) :
      self.root = self.remove_node(self.root, key)
    else :
      print("\n  Empty BST\n")
    
    print()
  
def main() :
  obj = BinarySearchTree()
  #
  #              5
  #            /   \
  #           /     \
  #          3       19
  #         / \     /  \
  #        2   4   8    31
  #       /       / \    /
  #      1       7   15  25
  #  
  obj.add(5)
  obj.add(3)
  obj.add(19)
  obj.add(2)
  obj.add(4)
  obj.add(8)
  obj.add(31)
  obj.add(1)
  obj.add(7)
  obj.add(25)
  obj.add(15)
  obj.inorder(obj.root)
  obj.delete_keys(8)
    
  #    After delete nodes
  #              5
  #            /   \
  #           /     \
  #          3       7
  #         / \
  #        2   4
  #       /
  #      1
  #  
  obj.inorder(obj.root)
  

if __name__ == "__main__":
  main()

Output

  1   2   3   4   5   7   8  15  19  25  31 
  1   2   3   4   5   7
# Ruby Program
# Delete nodes which are greater than or equal to given value in BST

class Node 
  attr_reader :data, :left, :right
  attr_accessor :data, :left, :right
  def initialize(value) 
    @data = value
    @left = nil
    @right = nil
  end
end

class BinarySearchTree 
  attr_reader :root
  attr_accessor :root
  def initialize() 
    @root = nil
  end
  def add(value) 
    new_node = Node.new(value)
    if (new_node != nil) 
      if (@root == nil) 
        @root = new_node
      else 
        find = @root
        while (find != nil) 
          if (find.data >= value) 
            if (find.left == nil) 
              find.left = new_node
              break
            else 
              find = find.left
            end
          else 
            if (find.right == nil) 
              find.right = new_node
              break
            else 
              find = find.right
            end
          end
        end
      end
    else 
      print("\nMemory Overflow\n")
    end
  end
  def inorder(head) 
    if (head != nil) 
      self.inorder(head.left)
      print(head.data ,"  ")
      self.inorder(head.right)
    end
  end
  def swap_data(root1, root2) 
    temp = root2.data
    root2.data = root1.data
    root1.data = temp
  end
  def remove_node(head, key) 
    if (head != nil) 
      head.right = self.remove_node(head.right, key)
      head.left = self.remove_node(head.left, key)
      temp = nil
      back = nil
      if (head.data >= key) 
        if (head.left == nil) 
          temp = head
          head = head.right
        elsif (head.right == nil) 
          temp = head
          head = head.left
        else 
          temp = head.left
          back = head
          while (temp.right != nil) 
            back = temp
            temp = temp.right
          end
          if (head.left == temp) 
            self.swap_data(head, temp)
            head.left = temp.left
          else 
            self.swap_data(head, temp)
            back.right = temp.left
          end
        end
        temp = nil
      end
    end
    return head
  end
  def delete_keys(key) 
    if (@root != nil) 
      @root = self.remove_node(@root, key)
    else 
      print("\n  Empty BST\n")
    end
    print("\n")
  end
end
def main() 
  obj = BinarySearchTree.new()
  #
  #              5
  #            /   \
  #           /     \
  #          3       19
  #         / \     /  \
  #        2   4   8    31
  #       /       / \    /
  #      1       7   15  25
  #  
  obj.add(5)
  obj.add(3)
  obj.add(19)
  obj.add(2)
  obj.add(4)
  obj.add(8)
  obj.add(31)
  obj.add(1)
  obj.add(7)
  obj.add(25)
  obj.add(15)
  obj.inorder(obj.root)
  obj.delete_keys(8)
    
  #    After delete nodes
  #              5
  #            /   \
  #           /     \
  #          3       7
  #         / \
  #        2   4
  #       /
  #      1
  #  
  obj.inorder(obj.root)
end

main()

Output

  1   2   3   4   5   7   8  15  19  25  31 
  1   2   3   4   5   7
<?php
/*
 Php Program
 Delete nodes which are greater than or equal to given value in BST
*/

class Node {
  public $data;
  public $left;
  public $right;

  function __construct($value) {
    $this->data = $value;
    $this->left = null;
    $this->right = null;
  }
}
class BinarySearchTree {
  public $root;

  function __construct() {
    $this->root = null;
  }
  public  function add($value) {
    $new_node = new Node($value);
    if ($new_node != null) {
      if ($this->root == null) {
        $this->root = $new_node;
      } else {
        $find = $this->root;
        while ($find != null) {
          if ($find->data >= $value) {
            if ($find->left == null) {
              $find->left = $new_node;
              break;;
            } else {
              $find = $find->left;
            }
          } else {
            if ($find->right == null) {
              $find->right = $new_node;
              break;;
            } else {
              $find = $find->right;
            }
          }
        }
      }
    } else {
      echo("\nMemory Overflow\n");
    }
  }
  public  function inorder($head) {
    if ($head != null) {
      $this->inorder($head->left);
      echo($head->data ."  ");
      $this->inorder($head->right);
    }
  }
  public  function swap_data($root1, $root2) {
    $temp = $root2->data;
    $root2->data = $root1->data;
    $root1->data = $temp;
  }
  public  function remove_node($head, $key) {
    if ($head != null) {
      $head->right = $this->remove_node($head->right, $key);
      $head->left = $this->remove_node($head->left, $key);
      $temp = null;
      $back = null;
      if ($head->data >= $key) {
        if ($head->left == null) {
          $temp = $head;
          $head = $head->right;
        } else
        if ($head->right == null) {
          $temp = $head;
          $head = $head->left;
        } else {
          $temp = $head->left;
          $back = $head;
          while ($temp->right != null) {
            $back = $temp;
            $temp = $temp->right;
          }
          if ($head->left == $temp) {
            $this->swap_data($head, $temp);
            $head->left = $temp->left;
          } else {
            $this->swap_data($head, $temp);
            $back->right = $temp->left;
          }
        }
        $temp = null;
      }
    }
    return $head;
  }
  public  function delete_keys($key) {
    if ($this->root != null) {
      $this->root = $this->remove_node($this->root, $key);
    } else {
      echo("\n  Empty BST\n");
    }
    echo("\n");
  }
}
function main() {
  $obj = new BinarySearchTree();
    /*
              5
            /   \ 
           /     \
          3       19
         / \     /  \
        2   4   8    31
       /       / \    /
      1       7   15  25   


  */   
  $obj->add(5);
  $obj->add(3);
  $obj->add(19);
  $obj->add(2);
  $obj->add(4);
  $obj->add(8);
  $obj->add(31);
  $obj->add(1);
  $obj->add(7);
  $obj->add(25);
  $obj->add(15);
  $obj->inorder($obj->root);
  $obj->delete_keys(8);
  /*
    After delete nodes 
    -----------------
              5
            /   \ 
           /     \
          3       7
         / \    
        2   4  
       /           
      1             
  */
  $obj->inorder($obj->root);
}
main();

Output

  1   2   3   4   5   7   8  15  19  25  31 
  1   2   3   4   5   7
/*
 Node Js Program
 Delete nodes which are greater than or equal to given value in BST
*/

class Node {
  
  constructor(value) {
    this.data = value;
    this.left = null;
    this.right = null;
  }
}
class BinarySearchTree {

  constructor() {
    this.root = null;
  }
  add(value) {
    var new_node = new Node(value);
    if (new_node != null) {
      if (this.root == null) {
        this.root = new_node;
      } else {
        var find = this.root;
        while (find != null) {
          if (find.data >= value) {
            if (find.left == null) {
              find.left = new_node;
              break;;
            } else {
              find = find.left;
            }
          } else {
            if (find.right == null) {
              find.right = new_node;
              break;;
            } else {
              find = find.right;
            }
          }
        }
      }
    } else {
      process.stdout.write("\nMemory Overflow\n");
    }
  }
  inorder(head) {
    if (head != null) {
      this.inorder(head.left);
      process.stdout.write(head.data + "  ");
      this.inorder(head.right);
    }
  }
  swap_data(root1, root2) {
    var temp = root2.data;
    root2.data = root1.data;
    root1.data = temp;
  }
  remove_node(head, key) {
    if (head != null) {
      head.right = this.remove_node(head.right, key);
      head.left = this.remove_node(head.left, key);
      var temp = null;
      var back = null;
      if (head.data >= key) {
        if (head.left == null) {
          temp = head;
          head = head.right;
        } else
        if (head.right == null) {
          temp = head;
          head = head.left;
        } else {
          temp = head.left;
          back = head;
          while (temp.right != null) {
            back = temp;
            temp = temp.right;
          }
          if (head.left == temp) {
            this.swap_data(head, temp);
            head.left = temp.left;
          } else {
            this.swap_data(head, temp);
            back.right = temp.left;
          }
        }
        temp = null;
      }
    }
    return head;
  }
  delete_keys(key) {
    if (this.root != null) {
      this.root = this.remove_node(this.root, key);
    } else {
      process.stdout.write("\n  Empty BST\n");
    }
    process.stdout.write("\n");
  }
}

function main() {
  var obj = new BinarySearchTree();
    /*
              5
            /   \ 
           /     \
          3       19
         / \     /  \
        2   4   8    31
       /       / \    /
      1       7   15  25   


  */   
  obj.add(5);
  obj.add(3);
  obj.add(19);
  obj.add(2);
  obj.add(4);
  obj.add(8);
  obj.add(31);
  obj.add(1);
  obj.add(7);
  obj.add(25);
  obj.add(15);
  obj.inorder(obj.root);
  obj.delete_keys(8);
  /*
  After delete nodes 
  -----------------
            5
          /   \ 
         /     \
        3       7
       / \    
      2   4  
     /           
    1             
  */
  obj.inorder(obj.root);
}


main();

Output

  1   2   3   4   5   7   8  15  19  25  31 
  1   2   3   4   5   7
/*
 Swift 4 Program
 Delete nodes which are greater than or equal to given value in BST
*/

class Node {
  var data: Int;
  var left: Node? ;
  var right: Node? ;
  init(_ value: Int) {
    self.data = value;
    self.left = nil;
    self.right = nil;
  }
}
class BinarySearchTree {
  var root: Node? ;
  init() {
    self.root = nil;
  }
  func add(_ value: Int) {
    let new_node: Node? = Node(value);
    if (new_node != nil) {
      if (self.root == nil) {
        self.root = new_node;
      } else {
        var find: Node? = self.root;
        while (find != nil) {
          if (find!.data >= value) {
            if (find!.left == nil) {
              find!.left = new_node;
              break;
            } else {
              find = find!.left;
            }
          } else {
            if (find!.right == nil) {
              find!.right = new_node;
              break;
            } else {
              find = find!.right;
            }
          }
        }
      }
    } else {
      print("\nMemory Overflow\n");
    }
  }
  func inorder(_ head: Node? ) {
    if (head != nil) {
      self.inorder(head!.left);
      print(head!.data, terminator:"  ");
      self.inorder(head!.right);
    }
  }
  func swap_data(_ root1: Node? , _ root2 : Node? ) {
    let temp: Int = root2!.data;
    root2!.data = root1!.data;
    root1!.data = temp;
  }
  func remove_node(_ element: Node? , _ key : Int) -> Node? {
    var head: Node? = element;
    if (head != nil) {
      head!.right = self.remove_node(head!.right, key);
      head!.left = self.remove_node(head!.left, key);
      var temp: Node? = nil;
      var back: Node? = nil;
      if (head!.data >= key) {
        if (head!.left == nil) {
          temp = head;
          head = head!.right;
        } else
        if (head!.right == nil) {
          temp = head;
          head = head!.left;
        } else {
          temp = head!.left;
          back = head;
          while (temp!.right != nil) {
            back = temp;
            temp = temp!.right;
          }
          if (head!.left === temp) {
            self.swap_data(head, temp);
            head!.left = temp!.left;
          } else {
            self.swap_data(head, temp);
            back!.right = temp!.left;
          }
        }
        temp = nil;
      }
    }
    return head;
  }
  func delete_keys(_ key: Int) {
    if (self.root != nil) {
      self.root = self.remove_node(self.root, key);
    } else {
      print("\n  Empty BST\n");
    }
    print();
  }
}

func main() {
  let obj: BinarySearchTree = BinarySearchTree();
    /*
              5
            /   \ 
           /     \
          3       19
         / \     /  \
        2   4   8    31
       /       / \    /
      1       7   15  25   


  */   
  obj.add(5);
  obj.add(3);
  obj.add(19);
  obj.add(2);
  obj.add(4);
  obj.add(8);
  obj.add(31);
  obj.add(1);
  obj.add(7);
  obj.add(25);
  obj.add(15);
  obj.inorder(obj.root);
  obj.delete_keys(8);
  /*
    After delete nodes 
    -----------------
              5
            /   \ 
           /     \
          3       7
         / \    
        2   4  
       /           
      1             
  */
  obj.inorder(obj.root);
}
main();

Output

  1   2   3   4   5   7   8  15  19  25  31 
  1   2   3   4   5   7


Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment







© 2021, kalkicode.com, All rights reserved