{"id":27689,"date":"2018-04-09T20:22:43","date_gmt":"2018-04-09T14:52:43","guid":{"rendered":"https:\/\/www.wikitechy.com\/technology\/?p=27689"},"modified":"2018-09-11T19:38:46","modified_gmt":"2018-09-11T14:08:46","slug":"c-algorithm-iterative-postorder-traversal-set-1-using-two-stacks","status":"publish","type":"post","link":"https:\/\/www.wikitechy.com\/technology\/c-algorithm-iterative-postorder-traversal-set-1-using-two-stacks\/","title":{"rendered":"C Algorithm – Iterative Postorder Traversal | Set 1 (Using Two Stacks)"},"content":{"rendered":"

We have discussed iterative inorder and iterative preorder traversals. In this post, iterative postorder traversal is discussed which is more complex than the other two traversals (due to its nature of non-tail recursion, there is an extra statement after the final recursive call to itself). <\/span>The postorder traversal can easily be done using two stacks though. The idea is to push reverse postorder traversal to a stack. Once we have reverse postorder traversal in a stack, we can just pop all items one by one from the stack and print them, this order of printing will be in postorder because of LIFO property of stacks. Now the question is, how to get reverse post order elements in a stack \u2013 the other stack is used for this purpose. For example, in the following tree, we need to get 1, 3, 7, 6, 2, 5, 4 in a stack. If take a closer look at this sequence, we can observe that this sequence is very similar to preorder traversal. The only difference is right child is visited before left child and therefore sequence is \u201croot right left\u201d instead of \u201croot left right\u201d. So we can do something like iterative preorder traversal with following differences.
\na) Instead of printing an item, we push it to a stack.
\nb) We push left subtree before right subtree.<\/p>\n

Following is the complete algorithm. After step 2, we get reverse postorder traversal in second stack. We use first stack to get this order.<\/p>\n

1. Push root to first stack.\r\n2. Loop while first stack is not empty\r\n   2.1 Pop a node from first stack and push it to second stack\r\n   2.2 Push left and right children of the popped node to first stack\r\n3. Print contents of second stack<\/pre>\n
Let us consider the following tree<\/p>\n
Following are the steps to print postorder traversal of the above tree using two stacks.<\/p>\n
1. Push 1 to first stack.\r\n      First stack: 1\r\n      Second stack: Empty\r\n\r\n2. Pop 1 from first stack and push it to second stack. \r\n   Push left and right children of 1 to first stack\r\n      First stack: 2, 3\r\n      Second stack: 1\r\n\r\n3. Pop 3 from first stack and push it to second stack. \r\n   Push left and right children of 3 to first stack\r\n      First stack: 2, 6, 7\r\n      Second stack:1, 3\r\n\r\n4. Pop 7 from first stack and push it to second stack.\r\n      First stack: 2, 6\r\n      Second stack:1, 3, 7\r\n\r\n5. Pop 6 from first stack and push it to second stack.\r\n      First stack: 2\r\n      Second stack:1, 3, 7, 6\r\n\r\n6. Pop 2 from first stack and push it to second stack. \r\n   Push left and right children of 2 to first stack\r\n      First stack: 4, 5\r\n      Second stack:1, 3, 7, 6, 2\r\n\r\n7. Pop 5 from first stack and push it to second stack.\r\n      First stack: 4\r\n      Second stack: 1, 3, 7, 6, 2, 5\r\n\r\n8. Pop 4 from first stack and push it to second stack.\r\n      First stack: Empty\r\n      Second stack: 1, 3, 7, 6, 2, 5, 4\r\n\r\nThe algorithm stops since there is no more item in first stack. \r\nObserve that content of second stack is in postorder fashion. Print them.<\/pre>\n
Following is C implementation of iterative postorder traversal using two stacks.<\/p>\n
C Programming:<\/strong><\/p>\n
 
 <\/div> 
#include <stdio.h>#include <stdlib.h> \/\/ Maximum stack size#define MAX_SIZE 100 \/\/ A tree nodestruct Node{    int data;    struct Node *left, *right;}; \/\/ Stack typestruct Stack{    int size;    int top;    struct Node* *array;}; \/\/ A utility function to create a new tree nodestruct Node* newNode(int data){    struct Node* node = (struct Node*) malloc(sizeof(struct Node));    node->data = data;    node->left = node->right = NULL;    return node;} \/\/ A utility function to create a stack of given sizestruct Stack* createStack(int size){    struct Stack* stack =            (struct Stack*) malloc(sizeof(struct Stack));    stack->size = size;    stack->top = -1;    stack->array =           (struct Node**) malloc(stack->size * sizeof(struct Node*));    return stack;} \/\/ BASIC OPERATIONS OF STACKint isFull(struct Stack* stack){  return stack->top - 1 == stack->size; } int isEmpty(struct Stack* stack){  return stack->top == -1;  } void push(struct Stack* stack, struct Node* node){    if (isFull(stack))        return;    stack->array[++stack->top] = node;} struct Node* pop(struct Stack* stack){    if (isEmpty(stack))        return NULL;    return stack->array[stack->top--];} \/\/ An iterative function to do post order traversal of a given binary treevoid postOrderIterative(struct Node* root){    if (root == NULL)         return;     \/\/ Create two stacks    struct Stack* s1 = createStack(MAX_SIZE);    struct Stack* s2 = createStack(MAX_SIZE);     \/\/ push root to first stack    push(s1, root);    struct Node* node;     \/\/ Run while first stack is not empty    while (!isEmpty(s1))    {        \/\/ Pop an item from s1 and push it to s2        node = pop(s1);        push(s2, node);         \/\/ Push left and right children of removed item to s1        if (node->left)            push(s1, node->left);        if (node->right)            push(s1, node->right);    }     \/\/ Print all elements of second stack    while (!isEmpty(s2))    {        node = pop(s2);        printf("%d ", node->data);    }} \/\/ Driver program to test above functionsint main(){    \/\/ Let us construct the tree shown in above figure    struct Node* root = NULL;    root = newNode(1);    root->left = newNode(2);    root->right = newNode(3);    root->left->left = newNode(4);    root->left->right = newNode(5);    root->right->left = newNode(6);    root->right->right = newNode(7);     postOrderIterative(root);     return 0;}<\/code><\/pre> <\/div>\n
Output:<\/strong><\/p>\n
4 5 2 6 7 3 1<\/pre>\n
Following is overview of the above post.
\nIterative preorder traversal can be easily implemented using two stacks. The first stack is used to get the reverse postorder traversal in second stack. The steps to get reverse postorder are similar to iterative preorder<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"
C Algorithm – Iterative Postorder Traversal | Set 1 (Using Two Stacks)  – Stack – We have discussed iterative inorder and iterative preorder traversals<\/p>\n","protected":false},"author":1,"featured_media":31265,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[73012,79607],"tags":[81965,81802,81938,81937,81953,81964,81940,81804],"class_list":["post-27689","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-data-structures","category-stack","tag-binary-tree-postorder-traversal-leetcode","tag-inorder-preorder-postorder-traversal-without-recursion-in-c","tag-iterative-inorder-traversal","tag-iterative-preorder-traversal","tag-non-recursive-postorder-traversal-algorithm","tag-postorder-traversal-algorithm-of-a-binary-tree","tag-postorder-traversal-algorithm-using-stack","tag-postorder-traversal-without-recursion-and-stack"],"_links":{"self":[{"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/posts\/27689","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/comments?post=27689"}],"version-history":[{"count":0,"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/posts\/27689\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/media\/31265"}],"wp:attachment":[{"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/media?parent=27689"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/categories?post=27689"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/tags?post=27689"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}