Breaking News: Grepper is joining You.com. Read the official announcement!

Tree: Postorder Traversal

Add Answer

Grieving Gazelle answered on June 18, 2022 Popularity 10/10 Helpfulness 1/10

answer Tree: Postorder Traversal

related preorder traversal

related Tree traversal

related inorder traversal of tree

related traversal tree

Tree: Postorder Traversal

Comment

def postOrder(root):
    if root:
        postOrder(root.left)
        postOrder(root.right)
        print(root, end = " ")

Popularity 10/10 Helpfulness 1/10 Language python

Source: Grepper

Tags: postorder python traversal

Link to this answer
Share Copy Link

Contributed on Jun 18 2022

Grieving Gazelle

0 Answers Avg Quality 2/10

Closely Related Answers

preorder traversal

Comments(1)

<> Preorder		Root -> Left -> Right 
<> Inorder		Left -> Root -> Right
<> Postorder	Left -> Right -> Root

Popularity 10/10 Helpfulness 4/10 Language javascript

Source: Grepper

Tags: depth-first-search depth-first-searc

Link to this answer
Share Copy Link

Contributed on Jan 09 2023

correctYourPosture

0 Answers Avg Quality 2/10

Tree traversal

Comment

A tree is a graph whose degree of node== # of it's children & is acyclic 
Binary tree is a tree with each node having atmost 2 children.
2 ways to traverse each node once:
BFS - level wise
DFS - BY RECURSIVELY TRAVERSING ROOT,LEFT SUBTREE (L) & RIGHT SUBTREE (R)
NOTE: THERE ARE 3! WAYS OF DOING A DFS, BASED ON ORDER OF Root,L,R.     
but only 3 are useful :
Root,L,R- preorder traversal 
L,Root,R- inorder traversal 
L,R,Root- postorder traversal

Popularity 10/10 Helpfulness 2/10 Language whatever

Source: Grepper

Tags: inorder

Link to this answer
Share Copy Link

Contributed on Aug 03 2022

ap_Cooperative_dev

0 Answers Avg Quality 2/10

inorder traversal of tree

Comment

//*******this is a C program for implementation and searching in A BT*******
#include<stdlib.h>
#include <stdio.h>

struct BinaryTree{
    int data;
    struct BinaryTree*right;
    struct BinaryTree*left;
};

struct BinaryTree*createnode(int val){
    struct BinaryTree*root=(struct BinaryTree*)malloc(sizeof(struct BinaryTree));
    root->data=val;
    root->left=NULL;
    root->right=NULL;
    
}

void inorder(struct BinaryTree*root){
    if(root==NULL){
    return;
    }
    else {inorder(root->left);
    printf("%d->",root->data);
    inorder(root->right);
}

}
 
void preorder(struct BinaryTree*root){
    if(root==NULL){
        return;
    }
    else {
        printf("%d->",root->data);
        preorder(root->left);
        preorder(root->right);
    }
}

void postorder(struct BinaryTree*root){
    if(root==NULL){
        return;
    }
    else{
        postorder(root->left);
        postorder(root->right);
        printf("%d->",root->data);
    }
}
int main()
{
    printf("Lets grow the tree\n");
    struct BinaryTree*root=createnode(1);
    root->left=createnode(2);
    root->right=createnode(3);
    root->left->left=createnode(4);
    root->left->right=createnode(5);
    
    printf("tree has grown up\n");
    
    printf("Inorder traversal ");
    inorder(root);printf("NULL");

    printf("\npreorder traversal ");
    preorder(root);printf("NULL");
    
    printf("\nPostorder  traversal");
    postorder(root);printf("NULL");
    
    return 0 ;
}

Popularity 10/10 Helpfulness 2/10 Language c

Source: Grepper

Tags: c

Link to this answer
Share Copy Link

Contributed on Aug 17 2022

Unusual Unicorn

0 Answers Avg Quality 2/10

traversal tree

Comment

class Node:
     def __init__(self,data):
          self.data = data
          self.parent = None
          self.left = None
          self.right = None

     def __repr__(self):
          return repr(self.data)

     def add_left(self,node):
         self.left = node
         if node is not None:
             node.parent = self

     def add_right(self,node):
         self.right = node
         if node is not None:
             node.parent = self
'''
Example:
          _2_
        /       \
       7         9
      / \         \
     1   6         8
         / \       / \
       5   10   3   4
'''
def create_tree():
    two = Node(2)
    seven = Node(7)
    nine = Node(9)
    two.add_left(seven)
    two.add_right(nine)
    one = Node(1)
    six = Node(6)
    seven.add_left(one)
    seven.add_right(six)
    five = Node(5)
    ten = Node(10)
    six.add_left(five)
    six.add_right(ten)
    eight = Node(8)
    three = Node(3)
    four = Node(4)
    nine.add_right(eight)
    eight.add_left(three)
    eight.add_right(four)

    # now return the root node
    return two

def pre_order(node):
    print(node)
    if node.left:
        pre_order(node.left)
    if node.right:
        pre_order(node.right)

def in_order(node):
    if node.left:
        in_order(node.left)
    print(node)
    if node.right:
        in_order(node.right)

def post_order(node):
    if node.left:
        post_order(node.left)
    if node.right:
        post_order(node.right)
    print(node)

if __name__ == "__main__":
    root = create_tree()
    print("\nPre-order traversal:")
    pre_order(root)
    print("\nIn-order traversal:")
    in_order(root)
    print("\nPost-order traversal:")
    post_order(root)

Popularity 10/10 Helpfulness 2/10 Language python

Source: github.com

Tags: binary-tree bina

Link to this answer
Share Copy Link

Contributed on Jul 06 2022

Murad_9288

0 Answers Avg Quality 2/10

Postorder Traversal

Comment

# Assuming valid Binary Tree Node
def post_order(node: BinaryTreeNode):
    if node.left:
        post_order(node.left)
    if node.right:
        post_order(node.right)
    print(node.val)

Popularity 10/10 Helpfulness 1/10 Language python

Source: Grepper

Tags: postorder post

Link to this answer
Share Copy Link

Contributed on Jul 24 2023

Hassan

0 Answers Avg Quality 2/10

Postorder traversal

Comment

class Solution {
    List<Integer> list = new ArrayList<>();
    public List<Integer> postorderTraversal(TreeNode root) {
        dfs(root);
        return list;
        
    }
     public void dfs(TreeNode root)
    {
        if(root!=null)
        {
            
            dfs(root.left);
            
            dfs(root.right);
            list.add(root.val);
        }
    }
}

Popularity 10/10 Helpfulness 1/10 Language whatever

Source: Grepper

Tags: postorder post

Link to this answer
Share Copy Link

Contributed on Jun 22 2023

Zealous Zebra

0 Answers Avg Quality 2/10

postorder traversal using stack

Comment

1. Right child of 1 exists. 
   Push 3 to stack. Push 1 to stack. Move to left child.
        Stack: 3, 1
2. Right child of 2 exists. 
   Push 5 to stack. Push 2 to stack. Move to left child.
        Stack: 3, 1, 5, 2
3. Right child of 4 doesn't exist. '
   Push 4 to stack. Move to left child.
        Stack: 3, 1, 5, 2, 4
4. Current node is NULL. 
   Pop 4 from stack. Right child of 4 doesn't exist. 
   Print 4. Set current node to NULL.
        Stack: 3, 1, 5, 2
5. Current node is NULL. 
    Pop 2 from stack. Since right child of 2 equals stack top element, 
    pop 5 from stack. Now push 2 to stack.     
    Move current node to right child of 2 i.e. 5
        Stack: 3, 1, 2
6. Right child of 5 doesn't exist. Push 5 to stack. Move to left child.
        Stack: 3, 1, 2, 5
7. Current node is NULL. Pop 5 from stack. Right child of 5 doesn't exist. 
   Print 5. Set current node to NULL.
        Stack: 3, 1, 2
8. Current node is NULL. Pop 2 from stack. 
   Right child of 2 is not equal to stack top element. 
   Print 2. Set current node to NULL.
        Stack: 3, 1
9. Current node is NULL. Pop 1 from stack. 
   Since right child of 1 equals stack top element, pop 3 from stack. 
   Now push 1 to stack. Move current node to right child of 1 i.e. 3
        Stack: 1
10. Repeat the same as above steps and Print 6, 7 and 3. 
    Pop 1 and Print 1.

Popularity 3/10 Helpfulness 1/10 Language whatever

Source: www.geeksforgeeks.org

Tags: postorder stack traversal using whatever

Link to this answer
Share Copy Link

Contributed on Sep 06 2024

Amjad Saeed

0 Answers Avg Quality 2/10

Inorder Traversal using Stack:

Comment

Inorder Traversal using Stack:
As we already know, recursion can also be implemented using stack. Here also we can use a stack to perform inorder traversal of a Binary Tree. Below is the algorithm for traversing a binary tree using stack.

Create an empty stack (say S).
Initialize the current node as root.
Push the current node to S and set current = current->left until current is NULL
If current is NULL and the stack is not empty then:
Pop the top item from the stack.
Print the popped item and set current = popped_item->right 
Go to step 3.

Popularity 4/10 Helpfulness 1/10 Language whatever

Source: Grepper

Tags: inorder traversal using whatever

Link to this answer
Share Copy Link

Contributed on Sep 06 2024

Amjad Saeed

0 Answers Avg Quality 2/10

Preorder traversal

Comment

Following is a simple stack based iterative process to print Preorder traversal. 

Create an empty stack nodeStack and push root node to stack. 
Do the following while nodeStack is not empty. 
Pop an item from the stack and print it. 
Push right child of a popped item to stack 
Push left child of a popped item to stack
The right child is pushed before the left child to make sure that the left subtree is processed first.

Popularity 3/10 Helpfulness 1/10 Language whatever

Source: Grepper

Tags: preorder traversal whatever

Link to this answer
Share Copy Link

Contributed on Sep 06 2024

Amjad Saeed

0 Answers Avg Quality 2/10

Tree: Postorder Traversal

Contents

More Related Answers

Tree: Postorder Traversal

Closely Related Answers

preorder traversal

Tree traversal

inorder traversal of tree

traversal tree

Postorder Traversal

Postorder traversal

postorder traversal using stack

Inorder Traversal using Stack:

Preorder traversal

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.