Tree Binary Tree Arrays and Linked List ARRAYS

• Tree • Binary Tree

Arrays and Linked List ARRAYS 1. Good Data structure for Searching algorithms. 2. Disadvantage : Insertion and Deletion of Elements require Data movements(Time Consuming) LINKED LIST 1. It allows quick insertion and deletion of elements. 2. Searching is difficult. A Sequential traversal from the beginning of the list is required to search for an element until it is found or up to the end of the list

What is a Tree? · A tree combines the advantages of an array and a linked list. · (Ie ) We can search quickly as well as Insert and Delete Elements quickly Trees are Non Linear Data Structures ( They are not Sequential as an array, stack etc…. ) Definition A Tree is a data structure that represents hierarchical relationships between individual data items

Level 0 DAD Tree Root SON DAUGHTER SON Level 1 GS 2 GS 3 Level 2 Tree with n nodes will have n-1 edges Path : Sequence of Consecutive Edges Height : One More than the Last Level (Which has no parents) Branch/ edge ( Connectors between nodes) Siblings / children ( which has parents) Leaf Node / External ( No children)

Binary Tree Definition: It is a tree in which every node has two children ( left child and right child) A B D C E F G H I

Node is defined as follows: struct node { int data; node *left; node *right; } Binary Tree //Data field //A reference to the node’s left child. //A reference to the node’s right child. Traversing : Means visiting all the nodes of the tree, in some specific order for processing. There are THREE ways of Traversing a Tree 1. PREODER TRAVERSAL 2. INORDER TRAVERSAL 3. POSTORDER TRAVERSAL

Traversing Pre. Order Traversal : (VLR) + - * • Visit the current node. / C A B · Traverse the left sub-tree of the current node. E · Traverse the right sub-tree of the current node. F +-AB*C/EF void pre. Order(node *n) { if (n != NULL){ cout<<n->data<<endl; pre. Order(n->left); pre. Order(n->right); }} //Display the current node //Traverse left sub-tree //Traverse right sub-tree pre. Order(root);

Traversing In. Order Traversal : (LVR) + - * · Traverse the left sub-tree of the current. Anode. / C B · Visit the current node. E · Traverse the right sub-tree of the current node. F A - B + C* E / F void pre. Order(node *n) { if (n != NULL){ In. Order(n->left); cout<<n->data<<endl; In. Order(n->right); }} //Traverse left sub-tree //Display the current node //Traverse right sub-tree pre. Order(root);

Traversing Post. Order Traversal : (LRV) + - * · Traverse the left sub-tree of the current. Anode. / C B · Traverse the right sub-tree of the current node. E · Visit the current node. F AB-CEF/*+ void post. Order(node *n) { if (n != NULL){ post. Order(n->left); post. Order(n->right); cout<<n->data<<endl; }} //Traverse left sub-tree //Traverse right sub-tree //Display the current node pre. Order(root);

Application • A binary tree can be used to represent an expression – that involves only binary arithmetic operators +, -, /, and *. – The root node holds an operator, and each of its sub-trees represents either a variable (operand), or another expression. A*(B+C) Traversing : inorder : preorder : postorder : * A*B+C *A+BC ( prefix ) ABC+*, (postfix). A + B C

BINARY SEARCH TREE A binary search tree is a 1) binary tree, 2) with the additional condition that if a node contains a value k, then every node in its left sub-tree contains a value less than k, and every node in its right sub-tree contains a value greater than or equal to k.

Definition INORDER SUCCESSOR: If a node has a right sub-tree, its inorder successor is the last left node on this right sub-tree. The node containing the value 40 is called the inorder successor of the node containing the value 35. 60 It is useful when deleting a node 85 35 27 15 30 42 40 51

SEARCHING in Binary Tree · Start from ROOT NODE. · Compare the Search Value with the data in the NODE. Possibilities: a. If “=“ Value has been Found/ Search is terminated. b. If search key “>” than the data of the current node, the search proceeds with the right child as the new current node. c. If the search key is”<“ than the data of the current node, the search proceeds with the left child as the new current node. d. If the current node is NULL, the search is terminated as unsuccessful.

Algorithm void search(int val, node *root) { node *s = root; int flag=1; while ((s->data != val)&&(flag)){ if(val < s->data) s = s->left; else s = s->right; if(s == NULL) flag=0; } if (flag) cout<<"found!"; else cout<<"not found"; } //start search at root //examine current data //go to left child //go to right child //no node! 60 35 27 15 30 85 42 40 51

INSERTING A NEW NODE 35 27 60 85 42 · Search Until “NULL” is encountered. 15 40 30 · Insert the NEW NODE and connected to its parent. void Insert(int val, node *root) { node *n, *parent, *s; n = new node; //create a new node; n->data = val; //store value. n->left=NULL; n->right=NULL; s = root; //start search at root int flag=1; while(flag){ //tree traversal parent = s; if(val < s->data){ //go to left child s = s->left; 51 if(s == NULL){ //if null, insert new node parent->left = n; flag=0; } // end 2 nd if } // end 1 st if else { //go to right child s = s->right; if(s == NULL){ //if null, insert new node parent->right = n; flag=0; } } //end else } //end while } //end insert

DELETING A NODE Deleting a node is the most complicated operation required for binary search tree. There are three cases to consider: a. b. c. The node to be deleted is a leaf (has no children). The node to be deleted has one child. The node to be deleted has two children. 5 null 4 null 3 6

To delete a node with two children 60 40 35 27 15 85 42 30 70 40 41 51 41 65 92 80

Algorithm void Remove(int val, node *root) { node *s=root, *temp=s, *n, *pn; while((s->data!=val)&&(s!=NULL)) { temp=s; if (val<s->data) s=s->left; else s=s->right; } if (s!=NULL) {if ((s->left==NULL)&&(s-> right== NULL )) {if (temp->left->data==val) temp->left=NULL; else temp->right=NULL; delete s; } //LOCATE THE NODE //AFTER LOCATING //LEAF NODE //TEMP - PARENT

Algorithm if ((s->left==NULL) || (s->right==NULL)) //the node to be deleted has //only one child { if (temp->left->data==val) { if (s->right!=NULL) temp->left=s->right; 5 else temp->left=s->left; } 4 null 6 else 3 { if (s->right!=NULL) temp->right=s->right; else temp->right=s->left; } } if ((s->left!=NULL)&&(s->right!=NULL)) {// find the inorder successor of node s

60 Algorithm n=s->right; while(n->left!=NULL) // FIND THE INORDER SUCCESSOR { pn=n; n=n->left; } 40 27 42 15 30 41 51 s->data=n->data; // replace the data of the node to be deleted with the data of its in-order successor if (n->right!=NULL) //PUT THE RIGHT CHILD VALUE IN INORDER PLACE { n->data=n->right->data; delete n->right; n->right=NULL; } else { pn->left=NULL; delete n; } // IF NO RIGHT CHILD THEN PARENT LINK IS NULL } }else cout<<"element doesn't exist"<<endl; // COULD NOT FIND THE NODE }

COMPUTING THE MINIMUM AND MAXIMUM VALUES 60 35 27 15 85 42 30 70 40 51 65 92 80 41 int Minimum (node *root) { node *s = root; node * last; while (s != NULL) { last = s; s = s->left; } return last->data; } int Maximum(node *root) { node *s = root; node * last; while (s != NULL) { last = s; s = s->right; } return last->data; }