非递归遍历二叉树

后续遍历暂时没写，留作后期补充

#include <iostream>
#include <stack>

struct Node {
    int val;
    struct Node *left{nullptr}, *right{nullptr};
    Node (int n = 0): val(n), left(nullptr), right(nullptr) {}
};

inline void visit(Node* &node) {
    std::cout << node->val << " ";
}

// 前序递归创建二叉树
Node* PreOrderCreate() {
    int n;
    std::cin >> n;
    if (n < 0) {
        return nullptr;
    }
    auto node = new Node(n);
    node->left = PreOrderCreate();
    node->right = PreOrderCreate();
    return node;
}

// 前序遍历
void StackPreOrder(Node* root) {
    if (root == nullptr) {
        return;
    }
    std::stack<Node*> st;
    st.push(root);
    auto p = root;
    while (!st.empty()) {  // 外层函数递归栈
        p = st.top();
        st.push(p->right); // 放在栈中，模拟函数压栈
        st.push(p->left);
    }
}

// 中序遍历
void StackInOrder(Node* root) {
    if (root == nullptr) {
        return;
    }
    std::stack<Node*> st;
    auto p = root;
    st.push(p);
    do {
        while (p->left != nullptr) {
            p = p->left;
            st.push(p);
        }
        p = st.top();
        st.pop();
        visit(p);
        if (p->right != nullptr) {
            st.push(p->right);
        } 
    } while (!st.empty());
}

// 后序遍历
void StackPostOrder(Node* root) {
    if (root == nullptr) {
        return;
    }
    std::stack<Node*> st;
    auto p = root;
    st.push(p);
    do {
        while (p->left != nullptr) {
            p = p->left;
            st.push(p);
            if (p->right != nullptr) {
                st.push(p->right);
            }
        }
        p = st.top();
        visit(p);
        st.pop();
    } while (!st.empty());
}

int main() {
    auto root = PreOrderCreate();
    std::cout << "PreOrder:" << std::endl;
    StackPreOrder(root);
    std::cout << "InOrder:" << std::endl;
    StackInOrder(root);
    std::cout << "PostOrder:" << std::endl;
    StackPostOrder(root);
    return 0;
}