二叉树的链式存储——深入了解数据结构代码篇（二）

一、关键

• 需要一个左指针和右指针
• 层序遍历需要队列辅助。每访问一个队头元素，将该元素的左指针和右指针加入其中（如果有的话）。
• 寻找前驱，其实和普通遍历方式一致，不过visit函数修改，变为判断是否找到当前元素，是则返回前驱；否则继续寻找。这里采用全局变量的方式，返回final，pre是前驱，p是需要找的元素。

二、代码

2.1 结构体定义

typedef int ElemType;
typedef struct BitNode
{
    ElemType data;
    struct BitNode* lchild, * rchild;
}BitNode, *BiTree;

2.2 先序、中序、后序、层序遍历——递归

void visit(BitNode* node)
{
    cout << node->data << endl;
}

void PreOrder(BiTree T)//先序遍历
{
    if (T)
    {
        visit(T);
        PreOrder(T->lchild);
        PreOrder(T->rchild);
    }
}

void InOrder(BiTree T)//中序遍历
{
    if (T)
    { 
        PreOrder(T->lchild);
        visit(T);
        PreOrder(T->rchild);
    }
}

void PostOrder(BiTree T)//后序遍历
{
    if (T)
    {
        PreOrder(T->lchild);
        PreOrder(T->rchild);
        visit(T);
    }
}

queue<BitNode*> que;
void LevelOrder(BiTree T)//层序遍历，使用队列辅助
{
    if (T)
        que.push(T);
    while (!que.empty())
    {
        T = que.front();
        visit(que.front());
        que.pop();
        if (T->lchild)
            que.push(T->lchild);
        if (T->rchild)
            que.push(T->rchild);
    }
}

2.3 先序、中序、后序——非递归实现

void preOrder(BiTree T)//二叉树的先序遍历，非递归
{
    if (!T)
        return;

    stack<BitNode*> stk;
    BitNode* p;
    stk.push(T);
    while (!stk.empty())
    {
        p = stk.top();
        stk.pop();
        visit(p);

        if (p->rchild)   stk.push(p->rchild);
        if (p->lchild)   stk.push(p->lchild);
    }
}

void inOrder(BiTree T)//二叉树的中序遍历，非递归
{
    if (!T) return;

    stack<BitNode*> stk;
    BitNode* p = T;

    while (!stk.empty() || p)
    {
        if (p)
        {
            stk.push(p);
            p = p->lchild;//寻找最左边的元素
        }
        else
        {
            p = stk.top();
            stk.pop();
            visit(p);
            p = p->rchild;
        }
    }
}

void postOrder(BiTree T)//二叉树的后序遍历，非递归
{
    if (!T) return;

    stack<BitNode*> stk;
    BitNode* p = T;
    BitNode* q;

    do
    {
        while (p)
        {
            stk.push(p);
            p = p->lchild;
        }

        q = nullptr;
        while (!stk.empty())
        {
            p = stk.top();
            stk.pop();
            if (p->rchild == q)//右孩子不存在或已被访问
            {
                visit(p);
                q = p;
            }
            else
            {
                /* 当前结点不能访问，需第二次进栈 */
                stk.push(p);
                p = p->rchild;
                break;
            }
        }
    } while (!stk.empty());
}

2.4 土方法寻找前驱

//辅助全局变量，查找节点的前驱
BitNode* p; //寻找的节点
BitNode* pre = NULL;
BitNode* final = NULL;  //返回的节点

void visitPre(BitNode* q)
{
    if (q == p) //找到了，p是需要找的节点
        final = pre;
    else
        pre = q;

}

void findPre(BiTree T)//找中序前驱
{
    if (T)
    {
        findPre(T->lchild);
        visitPre(T);
        findPre(T->rchild);
    }
}

在下的数据结构和算法刷题笔记：github仓库，欢迎访问，如果能给个star就不胜感激啦！