📌  相关文章
📜  使用单个堆栈的二叉树的前序、后序和中序遍历

📅  最后修改于: 2021-09-06 06:30:07             🧑  作者: Mango

给定一棵二叉树,任务是仅使用一次堆栈遍历以先序、后序和中序迭代打印二叉树的所有节点。

例子:

方法:这个问题可以只用一个堆栈来解决。这个想法是通过分配一个值来标记二叉树的每个节点,每个节点称为状态码,值1代表当前正在访问的节点是前序遍历,值2代表当前正在访问的节点是中序遍历和值3表示节点在后序遍历中正在访问。

  • 初始化一个 stack < pair < Node*, int>> 说S
  • 将状态为1根节点压入堆栈,即{root, 1}。
  • 初始化三个整数向量,比如preorderinorderpostorder
  • 遍历堆栈直到堆栈为空并检查以下条件:
    • 如果堆栈的顶部节点的状态是1,那么更新堆栈的顶部节点的状态,以2节点向量并插入顶部节点左子,如果它不是的堆栈S。
    • 如果堆栈的顶部节点的状态为2,则更新堆栈的顶部节点的状态,以3和推入向量顶部节点,并插入顶部节点右子,如果它不是的堆栈S
    • 如果栈顶节点的状态为3,则按向量后序压入栈顶节点,然后弹出栈顶元素。
  • 最后,打印向量preorderinorderpostorder

下面是上述方法的实现:

C++
// C++ program for the above approach
 
#include 
using namespace std;
 
// Structure of the
// node of a binary tree
struct Node {
    int data;
    struct Node *left, *right;
 
    Node(int data)
    {
        this->data = data;
        left = right = NULL;
    }
};
 
// Function to print all nodes of a
// binary tree in Preorder, Postorder
// and Inorder using only one stack
void allTraversal(Node* root)
{
    // Stores preorder traversal
    vector pre;
 
    // Stores inorder traversal
    vector post;
 
    // Stores postorder traversal
    vector in;
 
    // Stores the nodes and the order
    // in which they are currently visited
    stack > s;
 
    // Push root node of the tree
    // into the stack
    s.push(make_pair(root, 1));
 
    // Traverse the stack while
    // the stack is not empty
    while (!s.empty()) {
 
        // Stores the top
        // element of the stack
        pair p = s.top();
 
        // If the status of top node
        // of the stack is 1
        if (p.second == 1) {
 
            // Update the status
            // of top node
            s.top().second++;
 
            // Insert the current node
            // into preorder, pre[]
            pre.push_back(p.first->data);
 
            // If left child is not NULL
            if (p.first->left) {
 
                // Insert the left subtree
                // with status code 1
                s.push(make_pair(
                    p.first->left, 1));
            }
        }
 
        // If the status of top node
        // of the stack is 2
        else if (p.second == 2) {
 
            // Update the status
            // of top node
            s.top().second++;
 
            // Insert the current node
            // in inorder, in[]
            in.push_back(p.first->data);
 
            // If right child is not NULL
            if (p.first->right) {
 
                // Insert the right subtree into
                // the stack with status code 1
                s.push(make_pair(
                    p.first->right, 1));
            }
        }
 
        // If the status of top node
        // of the stack is 3
        else {
 
            // Push the current node
            // in post[]
            post.push_back(p.first->data);
 
            // Pop the top node
            s.pop();
        }
    }
 
    cout << "Preorder Traversal: ";
    for (int i = 0; i < pre.size(); i++) {
        cout << pre[i] << " ";
    }
    cout << "\n";
 
    // Printing Inorder
    cout << "Inorder Traversal: ";
 
    for (int i = 0; i < in.size(); i++) {
        cout << in[i] << " ";
    }
    cout << "\n";
 
    // Printing Postorder
    cout << "Postorder Traversal: ";
 
    for (int i = 0; i < post.size(); i++) {
        cout << post[i] << " ";
    }
    cout << "\n";
}
 
// Driver Code
int main()
{
 
    // Creating the root
    struct Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->left->left = new Node(4);
    root->left->right = new Node(5);
    root->right->left = new Node(6);
    root->right->right = new Node(7);
 
    // Function call
    allTraversal(root);
 
    return 0;
}


Java
// Java program for the above approach
import java.util.ArrayList;
import java.util.Stack;
 
class GFG
{
 
    static class Pair
    {
        Node first;
        int second;
 
        public Pair(Node first, int second)
        {
            this.first = first;
            this.second = second;
        }
    }
 
    // Structure of the
    // node of a binary tree
    static class Node
    {
        int data;
        Node left, right;
 
        Node(int data)
        {
            this.data = data;
            left = right = null;
        }
    };
 
    // Function to print all nodes of a
    // binary tree in Preorder, Postorder
    // and Inorder using only one stack
    static void allTraversal(Node root)
    {
       
        // Stores preorder traversal
        ArrayList pre = new ArrayList<>();
 
        // Stores inorder traversal
        ArrayList in = new ArrayList<>();
 
        // Stores postorder traversal
        ArrayList post = new ArrayList<>();
 
        // Stores the nodes and the order
        // in which they are currently visited
        Stack s = new Stack<>();
 
        // Push root node of the tree
        // into the stack
        s.push(new Pair(root, 1));
 
        // Traverse the stack while
        // the stack is not empty
        while (!s.empty())
        {
 
            // Stores the top
            // element of the stack
            Pair p = s.peek();
 
            // If the status of top node
            // of the stack is 1
            if (p.second == 1)
            {
 
                // Update the status
                // of top node
                s.peek().second++;
 
                // Insert the current node
                // into preorder, pre[]
                pre.add(p.first.data);
 
                // If left child is not null
                if (p.first.left != null)
                {
 
                    // Insert the left subtree
                    // with status code 1
                    s.push(new Pair(p.first.left, 1));
                }
            }
 
            // If the status of top node
            // of the stack is 2
            else if (p.second == 2) {
 
                // Update the status
                // of top node
                s.peek().second++;
 
                // Insert the current node
                // in inorder, in[]
                in.add(p.first.data);
 
                // If right child is not null
                if (p.first.right != null) {
 
                    // Insert the right subtree into
                    // the stack with status code 1
                    s.push(new Pair(p.first.right, 1));
                }
            }
 
            // If the status of top node
            // of the stack is 3
            else {
 
                // Push the current node
                // in post[]
                post.add(p.first.data);
 
                // Pop the top node
                s.pop();
            }
        }
 
        System.out.print("Preorder Traversal: ");
        for (int i : pre) {
            System.out.print(i + " ");
        }
        System.out.println();
 
        // Printing Inorder
        System.out.print("Inorder Traversal: ");
        for (int i : in) {
            System.out.print(i + " ");
        }
        System.out.println();
 
        // Printing Postorder
        System.out.print("Postorder Traversal: ");
        for (int i : post) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
 
    // Driver Code
    public static void main(String[] args) {
 
        // Creating the root
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.right.left = new Node(6);
        root.right.right = new Node(7);
 
        // Function call
        allTraversal(root);
 
    }
}
 
    // This code is contributed by sanjeev255


Python3
# Python3 program for the above approach
 
# Structure of the
# node of a binary tree
class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None
 
# Function to print all nodes of a
# binary tree in Preorder, Postorder
# and Inorder using only one stack
def allTraversal(root):
   
    # Stores preorder traversal
    pre = []
 
    # Stores inorder traversal
    post = []
 
    # Stores postorder traversal
    inn = []
 
    # Stores the nodes and the order
    # in which they are currently visited
    s = []
 
    # Push root node of the tree
    # into the stack
    s.append([root, 1])
 
    # Traverse the stack while
    # the stack is not empty
    while (len(s) > 0):
 
        # Stores the top
        # element of the stack
        p = s[-1]
        #del s[-1]
 
        # If the status of top node
        # of the stack is 1
        if (p[1] == 1):
 
            # Update the status
            # of top node
            s[-1][1] += 1
 
            # Insert the current node
            # into preorder, pre[]
            pre.append(p[0].data)
 
            # If left child is not NULL
            if (p[0].left):
 
                # Insert the left subtree
                # with status code 1
                s.append([p[0].left, 1])
 
        # If the status of top node
        # of the stack is 2
        elif (p[1] == 2):
 
            # Update the status
            # of top node
            s[-1][1] += 1
 
            # Insert the current node
            # in inorder, in[]
            inn.append(p[0].data);
 
            # If right child is not NULL
            if (p[0].right):
 
                # Insert the right subtree into
                # the stack with status code 1
                s.append([p[0].right, 1])
 
        # If the status of top node
        # of the stack is 3
        else:
 
            # Push the current node
            # in post[]
            post.append(p[0].data);
 
            # Pop the top node
            del s[-1]
 
    print("Preorder Traversal: ",end=" ")
    for i in pre:
        print(i,end=" ")
    print()
 
    # Printing Inorder
    print("Inorder Traversal: ",end=" ")
 
    for i in inn:
        print(i,end=" ")
    print()
 
    # Printing Postorder
    print("Postorder Traversal: ",end=" ")
 
    for i in post:
        print(i,end=" ")
    print()
 
 
# Driver Code
if __name__ == '__main__':
 
    # Creating the root
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.left = Node(4)
    root.left.right = Node(5)
    root.right.left = Node(6)
    root.right.right = Node(7)
 
    # Function call
    allTraversal(root)
 
    # This code is contributed by mohit kumar 29.


输出:
Preorder Traversal: 1 2 4 5 3 6 7 
Inorder Traversal: 4 2 5 1 6 3 7 
Postorder Traversal: 4 5 2 6 7 3 1

时间复杂度: O(N)
辅助空间: O(N)

如果您想与行业专家一起参加直播课程,请参阅Geeks Classes Live