23 October 2017
Study Anytime Any Where
23 October 2017
We Will Open The Knowledge For You
23 October 2017
Anish Sir 24x7 Learning solution
23 October 2017
"I am delighted once again to pen the welcome note to the Tosh!Yas Technologies ."
Call +91 74 88 34 7779 | Email : anishsingh@live.com
To delete a tree we must traverse all the nodes of the tree and delete them one by one. So which traversal we should use – Inorder or Preorder or Postorder. Answer is simple – Postorder, because before deleting the parent node we should delete its children nodes first
We can delete tree with other traversals also with extra space complexity but why should we go for other traversals if we have Postorder available which does the work without storing anything in same time complexity.
For the following tree nodes are deleted in order – 4, 5, 2, 3, 1
#include<stdio.h>#include<stdlib.h>/* A binary tree node has data, pointer to left child and a pointer to right child */struct node { int data; struct node* left; struct node* right;};/* Helper function that allocates a new node with the given data and NULL left and right pointers. */struct node* newNode(int data) { struct node* node = (struct node*) malloc(sizeof(struct node)); node->data = data; node->left = NULL; node->right = NULL; return(node);}/* This function traverses tree in post order to to delete each and every node of the tree */void deleteTree(struct node* node) { if (node == NULL) return; /* first delete both subtrees */ deleteTree(node->left); deleteTree(node->right); /* then delete the node */ printf("\n Deleting node: %d", node->data); free(node);} /* Driver program to test deleteTree function*/ int main(){ struct node *root = newNode(1); root->left = newNode(2); root->right = newNode(3); root->left->left = newNode(4); root->left->right = newNode(5); deleteTree(root); root = NULL; printf("\n Tree deleted "); getchar(); return 0;}Output:
Deleting node: 4 Deleting node: 5 Deleting node: 2 Deleting node: 3 Deleting node: 1 Tree deleted
The above deleteTree() function deletes the tree, but doesn’t change root to NULL which may cause problems if the user of deleteTree() doesn’t change root to NULL and tires to access values using root pointer. We can modify the deleteTree() function to take reference to the root node so that this problem doesn’t occur. See the following code.
#include<stdio.h>#include<stdlib.h>/* A binary tree node has data, pointer to left child and a pointer to right child */struct node{ int data; struct node* left; struct node* right;};/* Helper function that allocates a new node with the given data and NULL left and right pointers. */struct node* newNode(int data){ struct node* node = (struct node*) malloc(sizeof(struct node)); node->data = data; node->left = NULL; node->right = NULL; return(node);}/* This function is same as deleteTree() in the previous program */void _deleteTree(struct node* node){ if (node == NULL) return; /* first delete both subtrees */ _deleteTree(node->left); _deleteTree(node->right); /* then delete the node */ printf("\n Deleting node: %d", node->data); free(node);}/* Deletes a tree and sets the root as NULL */void deleteTree(struct node** node_ref){ _deleteTree(*node_ref); *node_ref = NULL;}/* Driver program to test deleteTree function*/int main(){ struct node *root = newNode(1); root->left = newNode(2); root->right = newNode(3); root->left->left = newNode(4); root->left->right = newNode(5); // Note that we pass the address of root here deleteTree(&root); printf("\n Tree deleted "); getchar(); return 0;}Deleting node: 4 Deleting node: 5 Deleting node: 2 Deleting node: 3 Deleting node: 1 Tree deleted
Time Complexity: O(n)
Space Complexity: If we don’t consider size of stack for function calls then O(1) otherwise O(n)
Recursively calculate height of left and right subtrees of a node and assign height to the node as max of the heights of two children plus 1. See below pseudo code and program for details.
Algorithm:
maxDepth()
1. If tree is empty then return 0
2. Else
(a) Get the max depth of left subtree recursively i.e.,
call maxDepth( tree->left-subtree)
(a) Get the max depth of right subtree recursively i.e.,
call maxDepth( tree->right-subtree)
(c) Get the max of max depths of left and right
subtrees and add 1 to it for the current node.
max_depth = max(max dept of left subtree,
max depth of right subtree)
+ 1
(d) Return max_depth
See the below diagram for more clarity about execution of the recursive function maxDepth() for above example tree.
maxDepth('1') = max(maxDepth('2'), maxDepth('3')) + 1
= 2 + 1
/ \
/ \
/ \
/ \
/ \
maxDepth('1') maxDepth('3') = 1
= max(maxDepth('4'), maxDepth('5')) + 1
= 1 + 1 = 2
/ \
/ \
/ \
/ \
/ \
maxDepth('4') = 1 maxDepth('5') = 1
#include<stdio.h>#include<stdlib.h>/* A binary tree node has data, pointer to left child and a pointer to right child */struct node { int data; struct node* left; struct node* right;};/* Compute the "maxDepth" of a tree -- the number of nodes along the longest path from the root node down to the farthest leaf node.*/int maxDepth(struct node* node) { if (node==NULL) return 0; else { /* compute the depth of each subtree */ int lDepth = maxDepth(node->left); int rDepth = maxDepth(node->right); /* use the larger one */ if (lDepth > rDepth) return(lDepth+1); else return(rDepth+1); }} /* Helper function that allocates a new node with the given data and NULL left and right pointers. */struct node* newNode(int data) { struct node* node = (struct node*) malloc(sizeof(struct node)); node->data = data; node->left = NULL; node->right = NULL; return(node);} int main(){ struct node *root = newNode(1); root->left = newNode(2); root->right = newNode(3); root->left->left = newNode(4); root->left->right = newNode(5); printf("Hight of tree is %d", maxDepth(root)); getchar(); return 0;}Size of a tree is the number of elements present in the tree. Size of the below tree is 5.
Example Tree
Size() function recursively calculates the size of a tree. It works as follows:
Size of a tree = Size of left subtree + 1 + Size of right subtree.
Algorithm:
size(tree)
1. If tree is empty then return 0
2. Else
(a) Get the size of left subtree recursively i.e., call
size( tree->left-subtree)
(a) Get the size of right subtree recursively i.e., call
size( tree->right-subtree)
(c) Calculate size of the tree as following:
tree_size = size(left-subtree) + size(right-
subtree) + 1
(d) Return tree_size
#include <stdio.h>#include <stdlib.h>/* A binary tree node has data, pointer to left child and a pointer to right child */struct node { int data; struct node* left; struct node* right;};/* Helper function that allocates a new node with the given data and NULL left and right pointers. */struct node* newNode(int data) { struct node* node = (struct node*) malloc(sizeof(struct node)); node->data = data; node->left = NULL; node->right = NULL; return(node);}/* Computes the number of nodes in a tree. */int size(struct node* node) { if (node==NULL) return 0; else return(size(node->left) + 1 + size(node->right)); }/* Driver program to test size function*/ int main(){ struct node *root = newNode(1); root->left = newNode(2); root->right = newNode(3); root->left->left = newNode(4); root->left->right = newNode(5); printf("Size of the tree is %d", size(root)); getchar(); return 0;}Output:
Size of the tree is 5
Using Stack is the obvious way to traverse tree without recursion. Below is an algorithm for traversing binary tree using stack. See this for step wise step execution of the algorithm.
1) Create an empty stack S.
2) Initialize current node as root
3) Push the current node to S and set current = current->left until current is NULL
4) If current is NULL and stack is not empty then
a) Pop the top item from stack.
b) Print the popped item, set current = popped_item->right
c) Go to step 3.
5) If current is NULL and stack is empty then we are done.
Let us consider the below tree for example
1
/ \
2 3
/ \
4 5
Step 1 Creates an empty stack: S = NULL
Step 2 sets current as address of root: current -> 1
Step 3 Pushes the current node and set current = current->left until current is NULL
current -> 1
push 1: Stack S -> 1
current -> 2
push 2: Stack S -> 2, 1
current -> 4
push 4: Stack S -> 4, 2, 1
current = NULL
Step 4 pops from S
a) Pop 4: Stack S -> 2, 1
b) print "4"
c) current = NULL /*right of 4 */ and go to step 3
Since current is NULL step 3 doesn't do anything.
Step 4 pops again.
a) Pop 2: Stack S -> 1
b) print "2"
c) current -> 5/*right of 2 */ and go to step 3
Step 3 pushes 5 to stack and makes current NULL
Stack S -> 5, 1
current = NULL
Step 4 pops from S
a) Pop 5: Stack S -> 1
b) print "5"
c) current = NULL /*right of 5 */ and go to step 3
Since current is NULL step 3 doesn't do anything
Step 4 pops again.
a) Pop 1: Stack S -> NULL
b) print "1"
c) current -> 3 /*right of 5 */
Step 3 pushes 3 to stack and makes current NULL
Stack S -> 3
current = NULL
Step 4 pops from S
a) Pop 3: Stack S -> NULL
b) print "3"
c) current = NULL /*right of 3 */
Traversal is done now as stack S is empty and current is NULL.
#include<stdio.h>#include<stdlib.h>#define bool int/* A binary tree tNode has data, pointer to left child and a pointer to right child */struct tNode{ int data; struct tNode* left; struct tNode* right;};/* Structure of a stack node. Linked List implementation is used for stack. A stack node contains a pointer to tree node and a pointer to next stack node */struct sNode{ struct tNode *t; struct sNode *next;};/* Stack related functions */void push(struct sNode** top_ref, struct tNode *t);struct tNode *pop(struct sNode** top_ref);bool isEmpty(struct sNode *top);/* Iterative function for inorder tree traversal */void inOrder(struct tNode *root){ /* set current to root of binary tree */ struct tNode *current = root; struct sNode *s = NULL; /* Initialize stack s */ bool done = 0; while (!done) { /* Reach the left most tNode of the current tNode */ if(current != NULL) { /* place pointer to a tree node on the stack before traversing the node's left subtree */ push(&s, current); current = current->left; } /* backtrack from the empty subtree and visit the tNode at the top of the stack; however, if the stack is empty, you are done */ else { if (!isEmpty(s)) { current = pop(&s); printf("%d ", current->data); /* we have visited the node and its left subtree. Now, it's right subtree's turn */ current = current->right; } else done = 1; } } /* end of while */ } /* UTILITY FUNCTIONS *//* Function to push an item to sNode*/void push(struct sNode** top_ref, struct tNode *t){ /* allocate tNode */ struct sNode* new_tNode = (struct sNode*) malloc(sizeof(struct sNode)); if(new_tNode == NULL) { printf("Stack Overflow \n"); getchar(); exit(0); } /* put in the data */ new_tNode->t = t; /* link the old list off the new tNode */ new_tNode->next = (*top_ref); /* move the head to point to the new tNode */ (*top_ref) = new_tNode;}/* The function returns true if stack is empty, otherwise false */bool isEmpty(struct sNode *top){ return (top == NULL)? 1 : 0;} /* Function to pop an item from stack*/struct tNode *pop(struct sNode** top_ref){ struct tNode *res; struct sNode *top; /*If sNode is empty then error */ if(isEmpty(*top_ref)) { printf("Stack Underflow \n"); getchar(); exit(0); } else { top = *top_ref; res = top->t; *top_ref = top->next; free(top); return res; }}/* Helper function that allocates a new tNode with the given data and NULL left and right pointers. */struct tNode* newtNode(int data){ struct tNode* tNode = (struct tNode*) malloc(sizeof(struct tNode)); tNode->data = data; tNode->left = NULL; tNode->right = NULL; return(tNode);}/* Driver program to test above functions*/int main(){ /* Constructed binary tree is 1 / \ 2 3 / \ 4 5 */ struct tNode *root = newtNode(1); root->left = newtNode(2); root->right = newtNode(3); root->left->left = newtNode(4); root->left->right = newtNode(5); inOrder(root); getchar(); return 0;}Time Complexity: O(n)
Output:
4 2 5 1 3
Given a binary tree, print level order traversal in a way that nodes of all levels are printed in separate lines.
For example consider the following tree
1
/ \
2 3
/ \ \
4 5 6
/ \ /
7 8 9
Output for above tree should be
1
2 3
4 5 6
7 8 9
/* Function to line by line print level order traversal a tree*/void printLevelOrder(struct node* root){ int h = height(root); int i; for (i=1; i<=h; i++) { printGivenLevel(root, i); printf("\n"); }}/* Print nodes at a given level */void printGivenLevel(struct node* root, int