《数据结构》二叉树的遍历（先序、中序、后序、层次）（递归+非递归）

前序遍历（递归版）

void BinTree::p_dfs(treeNode* u, int& inf, int* path) const{
    if(u == NULL) return;
    if(inf == total) return;

    path[inf ++] = u->data;
    p_dfs(u->left, inf, path);
    p_dfs(u->right, inf, path);
}

int* BinTree::p_recursion() const{
    if(root == NULL) return NULL;
    int* path = new int[total];
    int inf = 0;
    p_dfs(root, inf, path);
    for (int i = 0; i < total; i ++) printf("%d ", path[i]);
    puts("");
    return path;
}

前序遍历（非递归版）

int* BinTree::my_pre_traversal() const{
    if(root == NULL) return NULL;
    treeNode* now = root;
    stack<treeNode*> st;
    int* path = new int[total];
    int inf = 0;
    while(true)
    {
        while(now) // 走完左分支，在遍历了当前结点之后，将控制权直接交给左儿子
        {
            path[inf ++] = now->data;
            st.push(now);
            now = now->left;
        }

        if(st.size()) // 检查栈
        {
            treeNode* u = st.top();
            st.pop();
            now = u->right; // 将控制权交给右儿子
        }
        else break; // 如果栈已经空了，直接退出循环
    }
    for (int i = 0; i < total; i ++)
        printf("%d ", path[i]);
    puts("");
    return path;
}

中序遍历（递归版）

void BinTree::m_dfs(treeNode* u, int& inf, int* path) const{
    if(u == NULL) return;
    if(inf == total) return;

    m_dfs(u->left, inf, path);
    path[inf ++] = u->data;
    m_dfs(u->right, inf, path);
}

int* BinTree::m_recursion() const{
    if(root == NULL) return NULL;
    int* path = new int[total];
    int inf = 0;
    m_dfs(root, inf, path);
    for (int i = 0; i < total; i ++) printf("%d ", path[i]);
    puts("");
    return path;
}

中序遍历（非递归版）

int* BinTree::my_mid_traversal() const{
    if(root == NULL) return NULL;
    stack<treeNode*> st;
    treeNode* now = root;
    int* path = new int[total];
    int inf = 0;
    while(true)
    {
        while(now)
        {
            st.push(now);
            now = now->left;
        }

        if(st.size())
        {
            treeNode* u = st.top();
            st.pop();
            path[inf ++] = u->data;
            now = u->right;
        }
        else break;
    }

    for (int i = 0; i < total; i ++)
        printf("%d ", path[i]);
    puts("");
    return path;
}

后序遍历（递归版）

int* BinTree::po_recursion() const{
    if(root == NULL) return NULL;
    int* path = new int[total];
    int inf = 0;
    po_dfs(root, inf, path);
    for (int i = 0; i < total; i ++)
        printf("%d ", path[i]);
    puts("");
    return path;
}

void BinTree::po_dfs(treeNode* u, int& inf, int* path) const{
    if(u == NULL) return;
    if(inf == total) return;

    po_dfs(u->left, inf, path);
    po_dfs(u->right, inf, path);
    path[inf ++] = u->data;
}

后序遍历（非递归版）

int* BinTree::post_traversal() const{
    if(root == NULL) return NULL;
    treeNode* now = root;
    stack<treeNode*> st;
    int* path = new int[total];
    int inf = 0;
    treeNode* last = NULL; // 记录上次遍历结果
    while(true)
    {
        while(now)
        {
            st.push(now);
            now = now->left;
        }
        if(st.size())
        {
            treeNode* u = st.top();
            st.pop();
            if((!u->right) || last == u->right) // 当该节点没有右子树或者已经遍历过了右子树
                path[inf ++] = u->data, last = u;
            else{
                st.push(u); // 如果右子树还没有遍历过，就将这个节点重新再push进栈
                now = u->right;
            }
        }
        else break;
    }
    for (int i = 0; i < total; i ++) printf("%d ", path[i]);
        puts("");
    return path;
}

层次遍历

int* BinTree::floor_traversal() const{
    if(root == NULL) return NULL;
    queue<treeNode*> que;
    int* path = new int[total];
    int inf = 0;
    que.push(root);
    while(que.size())
    {
        treeNode* u = que.front();
        que.pop();
        path[inf ++] = u->data;
        if(u->left) que.push(u->left);
        if(u->right) que.push(u->right);
    }
    for (int i = 0; i < total; i ++) printf("%d ", path[i]);
    puts("");
    return path;
}