数据结构-树的遍历实现

数据结构-树的遍历实现代码

下面是实现代码：

#include<iostream>
#define maxSize 100
using namespace std;
typedef struct BTNode
{
    char data;
    struct BTNode *lchild;
    struct BTNode *rchild;
}BTNode;

void visit(BTNode *p)  //访问并打印节点
{
    cout << p->data <<" ";
}

void creat(BTNode *&bt)//先序遍历递归创建二叉树
{
    char c;
    cin >> c;
    if (c != '#')
    {
        bt = (BTNode*)malloc(sizeof(BTNode));
        bt->data = c;
        creat(bt->lchild);
        creat(bt->rchild);
    }
    else
    {
        bt= NULL;
    }
}

void preorder(BTNode *p)//递归先序遍历二叉树
{
    if (p != NULL)
    {
        visit(p);
        preorder(p->lchild);
        preorder(p->rchild);
    }
 }

void preorder2(BTNode *bt)//先序遍历非递归算法
{
    if (bt != NULL)
    {
        BTNode *stack[maxSize];//初始化栈
        int top = -1;
        BTNode *p;          //定义一个工作指针
        stack[++top] = bt;  //根节点入栈
        while (top != -1)//当栈不空时循环
        {
            p = stack[top--];//根节点出栈
            visit(p);
            if (p->rchild != NULL) //若右孩子不为空则入栈
            {
                stack[++top] = p->rchild;
            }
            if (p->lchild != NULL)   //若左孩子不为空则入栈
            {
                stack[++top] = p->lchild;
            }
        }
    }
}

void inorder(BTNode *p)//递归中序遍历二叉树
{
    if (p != NULL)
    {
        inorder(p->lchild);
        visit(p);
        inorder(p->rchild);
    }
}

void inorder2(BTNode *bt)//中序遍历非递归算法
{
    if (bt != NULL)
    {
        BTNode *stack[maxSize];
        int top = -1;
        BTNode *p;
        p = bt;
        while (p != NULL || stack != NULL)
        {
            while(p->lchild != NULL)
            {
                stack[++top] = p->lchild;
            }
            if (top != -1)
            {
                p = stack[top--];
                visit(p);
                p = p->rchild;
            }
        }
    }
}

void postorder(BTNode *p)//递归后续遍历二叉树
{
    if (p != NULL)
    {
        postorder(p->lchild);
        postorder(p->rchild);
        visit(p);
    }
}

void postorder2(BTNode *bt)//后续遍历非递归算法
{
    if (bt != NULL)
    {
        BTNode *p = bt, *r = NULL; //建立工作指针，标志指针
        BTNode *stack[maxSize];//建立辅助栈
        int top = -1;
        while (p != NULL || top!=-1)//当p不空或者栈不空时循环
        {
            if (p != NULL)//一直向左走走到最左位置
            {
                stack[++top] = p;
                p = p->lchild;

            }
            else
            {
                p = stack[top];//弹栈看结点右孩子是否为空或者是否被访问过
                if (p->rchild != NULL&&p->rchild != r)//右孩子不空且未被访问过，则从右孩子开始向左走到头
                {
                    p = p->rchild;
                    stack[++top] = p;
                    p = p->lchild;
                }
                else//右孩子为空或者已经被访问过
                {
                    p = stack[top--];//出栈
                    visit(p);       //访问节点
                    r = p;          //标志指针指向刚访问过的结点
                    p = NULL;       //防止重复访问其子树
                }
            }
        }
    }
}
void level(BTNode *bt)//层次遍历
{
    if (bt != NULL)
    {
        BTNode *queue[maxSize];//初始化循环队列
        int front, rear;
        front = rear = 0;
        BTNode *p;
        rear = (rear + 1) % maxSize;
        queue[rear] = bt;
        while (front!=rear)//队列不空时，对头结点出队，对头节点左右孩子不空则入队
        {
            front = (front + 1) % maxSize;
            p = queue[front];
            visit(p);
            if (p->lchild != NULL)
            {
                rear = (rear + 1) % maxSize;
                queue[rear] = p->lchild;
            }
            if (p->rchild != NULL)
            {
                rear = (rear + 1) % maxSize;
                queue[rear] = p->rchild;
            }
        }
    }
}
int main()
{
    BTNode *bt;
    char a[17] = { 'A','B','C','#','#','D','E','#','#','F','#','#','G','H','#','#','#' };
    creat(bt);
    preorder(bt);
    cout << endl;
    preorder2(bt);
    cout << endl;
    inorder(bt);
    cout << endl;
    inorder(bt);
    cout << endl;
    postorder(bt);
    cout << endl;
    postorder2(bt);
    cout << endl;
    level(bt);
    cout << endl;
    return 0;
}