Question

A collection of nodes is arranged as a binary search tree ordered on the field INFO which contains distinct positive integers for each of the nodes. In addition to INFO, LLINK and RLINK, each node has three other fields CLASS SUCC and PRED CLASS is an information field containing a single letter that denotes the class to which the node belongs (there being up to 26 classes). The nodes in each class are arranged as a doubly-linked circular list with a list head, by using the pointer fields SUCC and PRED to point to the successor and predecessor of a node in the list, respectively. The format of the nodes is: SUCC PRED CLASS INFO The following diagram shows an example in which there are 5 nodes in the binary search tree. HEAD-A Write an algorithm that, given a pointer ROOT to the root node of the binary search tree and an integer k occurring in the INFO field of some node in the tree, will search the tree for the node N containing the value k. It should then move the node V to the front of its class list, so that N will become the successor of the head node of the class list containing N You should assume that a head node is recognisable by the value 9999 in the INFO field.

Answer 1

Algorithm for search operation'

• The left subtree of a node is having  only nodes with keys less than the node’s .
• The right subtree of a node contains only nodes with keys greater than the node’s key.
• The left and right subtree each must also be a binary search tree.
  There must be no duplicate nodes.

struct node* search(int info){
   struct node *currentnode = root;
   printf("Search elements: ");
        
   while(currentnode->info != info){
        
      if(currentnode != NULL) {
         printf("%d ",currentnode->info);
                        
         
         if(currentnode->info > info){
            currentnode = currentnode->leftChild;
         }  
         else {                
            currentnode = currentnode->rightChild;
         }
                        
         
         if(currentnode == NULL){
            return NULL;
         }

/* java implementation of Binary search Tree*/

import java.util.Scanner;

class Succ

{

Succ llink, rlink;

int info

public Succ()

{

llink = null;

rlink = null;

data = 0;

}

public Succ(int n)

{

llink = null;

rlink = null;

data = n;

}

public void placellink(Succ n)

{

llink = n;

}

public void placerlink(Succ n)

{

rlink = n;

}

public Succ getllink()

{

return llink;

}

public Succ getrlink()

{

return rlink;

}

/* Function to place data to node */

public void placeData(int d)

{

data = d;

}

public int getData()

{

return info

}

}

class Pred

{

private Succ root;

public Pred()

{

root = null;

}

public boolean isEmpty()

{

return root == null;

}

public void add(int data)

{

root = add(root, data);

}

private Succ add(Succ node, int data)

{

if (node == null)

node = new Succ(data);

else

{

if (node.getrlink() == null)

node.rlink = add(node.rlink, data);

else

node.llink = add(node.llink, data);

}

return node;

}

public int countNodes()

{

return countNodes(root);

}

private int countNodes(Succ r)

{

if (r == null)

return 0;

else

{

int l = 1;

l += countNodes(r.getllink());

l += countNodes(r.getrlink());

return l;

}

}

/* Function to search for an element */

public boolean search(int val)

{

return search(root, val);

}

private boolean search(Succ r, int val)

{

if (r.getData() == val)

return true;

if (r.getllink() != null)

if (search(r.getllink(), val))

return true;

if (r.getrlink() != null)

if (search(r.getrlink(), val))

return true;

return false;

}

public void inorderT()

{

inorderT(root);

}

private void inorderT(Succ r)

{

if (r != null)

{

inorderT(r.getllink());

System.out.print(r.getData() +" ");

inorderT(r.getrlink());

}

}

public void preorderT()

{

preorderT(root);

}

private void preorderT(Succ r)

{

if (r != null)

{

System.out.print(r.getData() +" ");

preorderT(r.getllink());

preorderT(r.getrlink());

}

}

public void postorderT()

{

postorderT(root);

}

private void postorderT(Succ r)

{

if (r != null)

{

postorderT(r.getllink());

postorderT(r.getrlink());

System.out.print(r.getData() +" ");

}

}

}

private Node remove(Succ current, int data) {

    if (current == null) {

        return null;

    }

    if (value == current.value) {

     

    }

    if (value < current.value) {

        current.llink = remove(current.llink, data);

        return current;

    }

    current.rightchild = remove(current.rightchild, data);

    return current;

}

/* Class BinaryTree */

public class BinaryTree

{

public static void main(String[] args)

{

Scanner scan = new Scanner(System.in);

Pred Pred = new Pred();

System.out.println("Binary Tree Test\n");

char ch;

do

{

System.out.println("\nBinary Tree Operations\n");

System.out.println("1. add ");

System.out.println("2. search");

System.out.println("3. count nodes");

System.out.println("4. check empty");

System.out.println("5. remove");

int choice = scan.nextInt();

switch (choice)

{

case 1 :

System.out.println("Enter integer element to add");

Pred.add( scan.nextInt() );

break;

case 2 :

System.out.println("Enter integer element to search");

System.out.println("Search result : "+ Pred.search( scan.nextInt() ));

break;

case 3 :

System.out.println("Nodes = "+ Pred.countNodes());

break;

case 4 :

System.out.println("Empty status = "+ Pred.isEmpty());

break;

case 5 :

System.out.println("remove nodes= "+ Pred.remove());

break;

default :

System.out.println("Wrong Entry \n ");

break;

}

/* Display tree */

System.out.print("\nPost order : ");

Pred.postorderT();

System.out.print("\nPre order : ");

Pred.preorderT();

System.out.print("\nIn order : ");

Pred.inorderT();

System.out.println("\n\nDo you want to continue (Type y or n) \n");

ch = scan.next().charAt(0);

} while (ch == 'Y'|| ch == 'y');

}

}

      }                 
   }
   
   return current;
}