二叉树的基本操作-数据结构C++

问题描述

基于二叉链表存储结构实现二叉树的基本运算，要求：

①建立非空二叉树。

②二叉树的先、中、后序遍历。

③实现二叉树的非递归的中序遍历算法或层序遍历算法。

问题描述：

①从键盘输入结点编号及对应的结点值，可以分别以0和$作为结束标志。

②分别调用先序、中序和后序遍历递归算法对建立好的二叉链表树进行遍历。要求分别显示遍历后的结点序列。（程序1）

③调用非递归中序遍历算法对建立好的二叉链表树进行遍历。要求显示遍历后的结点序列。非递归中序遍历算法需要用栈操作的函数。

④调用层次遍历算法对建立好的二叉链表树进行遍历。要求显示遍历后的结点序列。层次遍历算法需要用队列操作的函数。（程序2）

程序清单：

（1）

#include<iostream>

#include <stdio.h>

#include <stdlib.h>

using namespace std;

typedef char ElemType;

typedef struct BiTNode

{

    ElemType data;

    struct BiTNode* lchild, * rchild;

} BiTNode, * BiTree; //二叉链表

BiTNode* Creat()//初始化树

{

    BiTNode* q, * s[30];

    int i, j;

    ElemType x;

    cout << "i x=";

    cin >> i >> x;

    while (i != 0 && x != '$')

    {

        q = (BiTree)malloc(sizeof(BiTNode));

        q->data = x;

        q->lchild = NULL;

        q->rchild = NULL;

        s[i] = q;

        if (i != 1)

        {

            j = i / 2;

            if (i % 2 == 0)s[j]->lchild = q;

            else s[j]->rchild = q;

        }

        cout << "i x=";

        cin >> i >> x;

    }

    return s[1];

}

void PreOrder(BiTree T)//先序遍历

{

    if (T)

    {

        cout << T->data;

        PreOrder(T->lchild);

        PreOrder(T->rchild);

    }

}

void InOrder(BiTree T)//中序遍历

{

    if (T)

    {

        InOrder(T->lchild);

        cout << T->data;

        InOrder(T->rchild);

    }

}

void PostOrder(BiTree T)//后序遍历

{

    if (T)

    {

        PostOrder(T->lchild);

        PostOrder(T->rchild);

        cout << T->data;

    }

}

int main()

{

    BiTNode* T;

    T = Creat();

    cout << "先序遍历序列：";

    PreOrder(T);

    cout << endl << "中序遍历序列：";

    InOrder(T);

    cout << endl << "后序遍历序列：";

    PostOrder(T);

    return 0;

}

（2）

#include<iostream>

#include<stdio.h>

#include<stdlib.h>

using namespace std;

#define TRUE 1

#define FALSE 0

#define ERROR 0

#define OK 1

#define OVERFLOW -2

#define STACK_INIT_SIZE 100

#define STACKINCREMENT 10



typedef int Status;

typedef char ElemType;

typedef struct BiTNode

{

    ElemType data;

    struct BiTNode* lchild, * rchild;

}BiTNode, * BiTree;//二叉链表

typedef BiTNode* SElemType;

typedef struct

{

    SElemType* base;

    SElemType* top;

    int stacksize;

} SqStack;

BiTNode* Creat()//初始化树

{

    BiTNode* q, * s[30];

    int i, j;

    ElemType x;

    cout << "i x=";

    cin >> i >> x;

    while (i != 0 && x != '$')

    {

        q = (BiTree)malloc(sizeof(BiTNode));

        q->data = x;

        q->lchild = NULL;

        q->rchild = NULL;

        s[i] = q;

        if (i != 1)

        {

            j = i / 2;

            if (i % 2 == 0)s[j]->lchild = q;

            else s[j]->rchild = q;

        }

        cout << "i x=";

        cin >> i >> x;

    }

    return s[1];

}

Status InitStack(SqStack& S)//初始化

{

    S.base = (SElemType*)malloc(STACK_INIT_SIZE * sizeof(STACK_INIT_SIZE));

    if (!S.base)

        exit(OVERFLOW);

    S.top = S.base;   //栈顶栈底指向底部

    S.stacksize = STACK_INIT_SIZE;

    return OK;

}

Status Push(SqStack& S, SElemType e)//入栈

{

    if (S.top - S.base >= S.stacksize)  //空间已用完

    {

        S.base = (SElemType*)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));

        if (!S.base)

        {

            exit(OVERFLOW);

        }

        S.top = S.base + S.stacksize;//栈顶重新指向栈顶

        S.stacksize += STACKINCREMENT;

    }

    *(S.top++) = e;

    return OK;

}

Status Pop(SqStack& S, SElemType& e)//出栈

{

    if (S.top == S.base)

        return ERROR;

    e = *--S.top;

    return OK;

}

Status StackEmpty(SqStack S)//判断栈空

{

    if (S.base == S.top)

        return TRUE;

    else

        return FALSE;

}

void FInOrder(BiTree T)//中序遍历非递归算法

{

    BiTNode* p;

    SqStack S;

    InitStack(S);

    p = T;

    while (p || !StackEmpty(S))

    {

        if (p)

        {

            Push(S, p);

            p = p->lchild;

        }

        else

        {

            Pop(S, p);

            cout << p->data;

            p = p->rchild;

        }

    }

}

int main()

{

    BiTNode* p;

    p = Creat();

    cout << "非递归中序遍历序列：";

    FInOrder(p);

    return 0;

}

实验结果：

（1）

（2）