Data Structures Lab II. Binary Search Tree implementation

Transcription

1 Data Structures Lab II Binary Search Tree implementation Objectives: Making students able to understand basic concepts relating to Binary Search Tree (BST). Making students able to implement Binary Search Tree practically using c++. Linear data structure: The data structures in which connected nodes can be represented in the form of a straight line are known as linear data structures shown below, Node 1 Node 2 Node 3 Node n Node 1 Node 2 Node n Node 3 Arrays, Single and Double link lists are linear data structures because nodes are connected to other nodes in linear way in these data structures. Non linear data structure: The arrangement of nodes that can not be represented in the form of straight line are called non linear data structures like shown below,

2 Node 2 Node 1 Node 4 Node n Node 3 Node 2 Node 1 Node 4 Node n Node 3 Tree Tree is a non linear data structure. A Tree consists of nodes (data Items) connected by edges. Node 1 Node 2 Node 3 Node 4 Node 5 Node 6 Node 7 Node 8 Node 9 Node 10 Binary Tree: A Tree in which each node has maximum order equal to two (has maximum two children)

3 Node 1 Node 2 Node 3 Node 4 Node 5 Node 6 Node 7 Binary Search Tree: A Binary Tree in which each node s right child has value greater than it and left child has value less than it as shown below, a b c If a is parent node and b and c are its child nodes then in Binary Search tree, b < a < c a is less than c (right child node) and greater than b (left child node) For example see the tree given below, In this tree every parent has value less than right node and greater than left node as shown on next page,

4 7 4 < 7 < 10 3 < 4 < < 10 < Advantages of using Binary Search Tree: We use binary search trees because they give us, The efficient way of insertion and deletion of nodes like in linear data structures. Efficient searching of nodes to find whether a data item is present in the tree or not, it is possible due to the sorted nature of binary search tree (which is not possible in linear data structures because in linear data structure we have to go through complete list to search a value) but in binary we have to make less comparisons because we move from tree to branches. We see how these things are possible, Addition in Binary Search Tree Suppose we have to add values 10,, 15, 7, 12 in an empty binary search tree the procedure will be given below,

5 Adding 10 Values to add 10,, 15, 7, 8, Description: Tree is empty so simply adding 10 as root. Adding 10 Adding Adding Description: is greater than 10 so moving right of. As there are no more nodes, so adding to the right of 10 Description: 15 is greater than 10 moving right of is less than so moving left of As there are no more nodes, so adding 15 to right of Description: 7 is less than 10 moving left of 10 As there are no more nodes, so adding 7 to the right of Adding Description: 8 is less than 10 moving left of 10 8 is greater than 7 moving left of 7 As there are no more nodes, so adding 8 to the right of Adding Description: 12 is greater than 10 moving right of is less than so moving left of 12 is less than 15 so moving left of 15 As there are no more nodes, so adding 12 to left of 15 12

6 Suppose we want to search value 12 in this tree it will be done as shown below, Searching Description: 12 is greater than 10 moving to right of 10 to search is less than so moving left of to search is less than 15 so moving left of 15 to search is found In this way if we reach the leaf of the tree no more child nodes are present and our required value is absent we can simply say that value is not present in the tree.

7 Deletion from Binary Tree: Suppose we have to delete a node containing some value in this tree first thing is that we will search the node in the tree using the search method we discussed above after it we will delete the node but the thing to consider in this regard is that we can not simply delete the node we have to keep the binary search tree structure, there are three cases in this regard, 1. First if node is simply the leaf node we can simply remove it. Searching Simply deleting 12 and setting 15 left Child pointer value to NULL to indicate now 15 has no left children If node has only one child node then we can simply keep the pointer of child node in the parent node of the node to be deleted as shown below,

8 Deleting Deleting 15 and setting 15 parent () left Child pointer value to 12 as shown If node to be deleted has both children than we have to take care that we keep the structure of binary search tree as well, we can use two approaches for it a. First way is we place the value of the left-most child of the right subtree of this node in its place and then delete the left-most child of the right subtree. This is because that value is least of the right subtree and hence should be placed instead of the node value. Suppose we want to delete 40, note that 40 right subtree left most child is 43 so we will replace 40 by 43 and delete 43 and in this way our tree will remain as binary search tree.

9 Right sub tree of 40. Its left most element is 43 the least element in this sub tree. Replacing 40 by 43 and deleting Replacing 40 by 43 and deleting 43. Note that tree is still Binary Search Tree.

10 b. Second way is we place the value of the right -most child of the left subtree of this node in its place and then delete the right -most child of the left subtree. This is because that value is greatest of the left subtree and hence should be placed instead of the node value. Suppose we want to delete 40, note that 40 left subtree right most child is 37 so we will replace 40 by 37 and will delete 37 and in this way our tree will remain as binary search tree.

11 Left sub tree of 40. Its right most element is 37 the greatest element in this sub tree. Replacing 40 by 37 and deleting Replacing 40 by 37 and deleting 37. Note that tree is still Binary Search Tree.

12 C++ Implementation of Binary Search Tree Basic Concepts relating to Nodes: First we see basic concepts relating to pointers, nodes and their manipulation. A Node class has general structure as given below, int Object Node * leftchild Node * rightchild The corresponding c++ code is shown below, class Node private: int object; /* Data value to be stored in the tree*/ Node * leftchild; /* Pointer to left node*/ Node * rightchild; /* Pointer to right node*/ public: void set(int value) object = value; /* function to set int value*/ int get() return object; /* function to get int value*/ void setleftchild( Node * left) leftchild = left; /* function to set left node pointer*/ Node * getleftchild() return leftchild; /* function to get left node pointer*/ void setrightchild(node * right) rightchild = right; /* function to set right node pointer*/ Node * getrightchild() return rightchild; /* function to get right node pointer*/ ;

13 The correspondence between Node class and its methods is shown below, class Node private: int Object Node * leftchild Node * rightchild int object; /* Data value to be stored in the tree*/ Node * leftchild; /* Pointer to left node*/ Node * rightchild; /* Pointer to right node*/ public: void set(int value) object = value; /* function to set int value*/ int get() return object; /* function to get int value*/ void setleftchild( Node * left) leftchild = left; /* function to set left node pointer*/ Node * getleftchild() return leftchild; /* function to get left node pointer*/ void setrightchild(node * right) rightchild = right; /* function to set right node pointer*/ Node * getrightchild() return rightchild; /* function to get right node pointer*/ ; You can see each of the node class member variables has two corresponding functions one is getter and second is setter. Suppose we have a pointer p to the node shown below,

14 int object Node * leftchild Node * rightchild We can get and set this node members as follows, p-> set(10); /* storing 10 in this node*/ int value = p-> get(); /*getting integer value stored in this node*/ p -> setleftchild( pointer); /*setting left child pointer*/ Node * leftchild = p -> getleftchild(); /*getting left child pointer*/ p -> setrightchild( pointer); /*setting left child pointer*/ Node * leftchild = p -> getrightchild(); /*getting left child pointer*/ Also note that although we have given the implementation of functions in the same file however when we will write code we will write declaration of members and functions in Node.h and implementation in Node.cpp as shown below, /*Node.cpp file*/ #include Node.h Node::Node() object = 0; leftchild = NULL; rightchild = NULL; /* function to set int value*/ void Node :: set(int value) object = value; /* function to get int value*/ int Node :: get() return object; /* function to set left node pointer*/ void Node :: setleftchild( Node * left) leftchild = left; /* function to get left node pointer*/

15 Node * Node :: getleftchild() return leftchild; /* function to set right node pointer*/ void Node :: setrightchild(node * right) rightchild = right; /* function to get right node pointer*/ Node * Node :: getrightchild() return rightchild; ; Now we implement our binary Search tree using this node class as shown below, Binary Search Tree Implementation: /*binarysearchtree.h*/ #include "Node.h" class binarysearchtree private: Node * root; public: binarysearchtree(); // constructor void insert (int ); void search( int ); void delusingrightsubtree( int ); void traverse(); void traversepreorder( Node *); void traverseinorder(node *); void traversepostorder(node *); ;

16 Its implementation is shown below, /*binarysearchtree.cpp*/ #include "binarysearchtree.h" binarysearchtree :: binarysearchtree() // constructor root = NULL; void binarysearchtree :: insert (int value ) Node * node = new Node(); node->set(value); if(root == NULL) root = node; else Node * p; Node * q; p = q = root; while( value!= p->get() && q!= NULL ) p = q; if( value < p->get()) q = p->getleftchild(); else q = p->getrightchild();

17 if( value == p->get() ) cout << "attempt to insert duplicate: " << value << endl; delete node; else if( value < p->get() ) p->setleftchild( node ); else p->setrightchild( node ); void binarysearchtree:: search(int value) Node * p = root; while(p!= NULL) if (p->get() == value) cout<<"the BST has "<<value<<endl; break; if (p -> get() < value ) p = p ->getrightchild(); else p = p ->getleftchild(); if (p == NULL) cout <<"The value not found"<<endl;

18 void binarysearchtree :: delusingrightsubtree(int value) Node * p; Node * q; p = q = root; while(p!= NULL) if (p->get() == value) break; if (p -> get() < value ) q = p; p = p ->getrightchild(); else q = p; p = p ->getleftchild(); if( p -> getleftchild()!= NULL && p -> getrightchild()!= NULL) Node * temp = p; q = p; p = p -> getrightchild(); while(p->getleftchild()!= NULL) q = p; p = p->getleftchild(); temp->set( p->get() );

19 if( p -> getleftchild() == NULL && p -> getrightchild() == NULL) if(q ->getrightchild() == p) q->setrightchild(null); else q->setleftchild(null); delete p; if( p -> getleftchild() == NULL && p -> getrightchild()!= NULL) if ( q ->getrightchild() == p) q->setrightchild(p->getrightchild()); else q->setleftchild(p->getrightchild()); delete p; if( p -> getleftchild()!= NULL && p -> getrightchild() == NULL) if(q ->getrightchild() == p) q->setrightchild(p->getleftchild()); else q->setleftchild(p->getleftchild()); delete p; void binarysearchtree:: traversepreorder(node * temp) if( temp!= NULL ) cout << "\t"<<temp->get(); traversepreorder(temp->getleftchild());

20 traversepreorder(temp->getrightchild()); void binarysearchtree:: traverseinorder(node * temp) if( temp!= NULL ) traverseinorder(temp->getleftchild()); cout << "\t"<<temp->get(); traverseinorder(temp->getrightchild()); void binarysearchtree:: traversepostorder(node * temp) if( temp!= NULL ) traversepostorder(temp->getleftchild()); traversepostorder(temp->getrightchild()); cout << "\t"<<temp->get(); void binarysearchtree::traverse() Node * temp = root; cout<<"\npreorder traversal is...\n"; traversepreorder(temp); cout<<"\ninorder traversal is...\n"; traverseinorder(temp); cout<<"\npostorder traversal is...\n"; traversepostorder(temp); cout<<endl;

21 Main function is shown below, #include <cstdlib> #include <iostream> #include "binarysearchtree.h" using namespace std; int main(int argc, char *argv[]) binarysearchtree obj1; cout<<"adding 10,14,7,17\n"; obj1.insert(10); obj1.insert(14); obj1.insert(7); obj1.insert(17); cout<<"traversing tree...\n"; obj1.traverse(); cout<<"\n\nnow Searching 17...\n"; obj1.search(17); cout<<"\n\n\nnow Deleting 14 and 7\n"; obj1.delusingrightsubtree(14); obj1.delusingrightsubtree(7); cout<<"traversing tree again...\n"; obj1.traverse();

22 system("pause"); return EXIT_SUCCESS; End of LAB