1019: 顺序存储二叉树

1019: 顺序存储二叉树

Description

​ 顺序存储的二叉树，依次实现二叉树的三种递归遍历：先序、中序、后序；二叉树的先序非递归、层次遍历；计算二叉树的叶子个数、高度。部分代码已知，请勿改动，将其它代码补充完整，达到相应的输出结果。

const int QueueSize = 100; // 循环队列的最大长度
template <class T>         // 定义模板类CirQueue
class CirQueue
{
public:
    CirQueue();        // 构造函数，置空队
    ~CirQueue();       // 析构函数
    void EnQueue(T x); // 将元素x入队
    T DeQueue();       // 将队头元素出队
    T GetQueue();      // 取队头元素（并不删除）
    bool Empty();      // 判断队列是否为空
    bool Full();

private:
    T data[QueueSize]; // 存放队列元素的数组
    int front, rear;   // 队头和队尾指针，分别指向队头元素的前一个位置和队尾元素的位置
};

// 功    能：初始化空队列
template <class T>
CirQueue<T>::CirQueue()
{
    front = rear = 0;
}

// 功    能：销毁队列
template <class T>
CirQueue<T>::~CirQueue()
{
}

// 功    能：元素x入队
template <class T>
void CirQueue<T>::EnQueue(T x)
{
    if (Full())
        throw "Overflow";
    rear = (rear + 1) % QueueSize; // 队尾指针在循环意义下加1
    data[rear] = x;                // 在队尾处插入元素
}

// 功    能：队头元素出队，返回值为出队元素
template <class T>
T CirQueue<T>::DeQueue()
{
    if (Empty())
        throw "Downflow";
    front = (front + 1) % QueueSize; // 队头指针在循环意义下加1
    return data[front];              // 读取并返回出队前的队头元素，注意队头指针
}
// 指向队头元素的前一个位置
// 功    能：获取队头元素
template <class T>
T CirQueue<T>::GetQueue()
{
    int i;
    if (Empty())
        throw "Downflow";
    i = (front + 1) % QueueSize; // 注意不要给队头指针赋值
    return data[i];
}

// 功    能：判断队列是否为空,若空返回true，否则返回false
template <class T>
bool CirQueue<T>::Empty()
{
    return front == rear;
}
// 功   能：判断队列是否满，若满返回true，否则false
template <class T>
bool CirQueue<T>::Full()
{
    return (rear + 1) % QueueSize == front;
}

// 栈类
const int StackSize = 100; // 10只是示例性的数据，可以根据实际问题具体定义
template <class T>         // 定义模板类SeqStack
class SeqStack
{
public:
    SeqStack();     // 构造函数，栈的初始化
    ~SeqStack();    // 析构函数
    void Push(T x); // 将元素x入栈
    T Pop();        // 将栈顶元素弹出
    T GetTop();     // 取栈顶元素（并不删除）
    bool Empty();   // 判断栈是否为空
    bool Full();    // 判断栈是否为满
private:
    T data[StackSize]; // 存放栈元素的数组
    int top;           // 栈顶指针，指示栈顶元素在数组中的下标
};

// 初始化空栈
template <class T>
SeqStack<T>::SeqStack()
{
    top = -1;
}

// 功    能：销毁栈
template <class T>
SeqStack<T>::~SeqStack()
{
}

// 功    能：元素x压栈
template <class T>
void SeqStack<T>::Push(T x)
{
    if (Full())
        throw "Overflow";
    top++;
    data[top] = x;
}
// 功    能：栈顶元素弹栈
template <class T>
T SeqStack<T>::Pop()
{
    T x;
    if (Empty())
        throw "Downflow";
    x = data[top--];
    return x;
}

// 功    能：读取当前的栈顶元素
template <class T>
T SeqStack<T>::GetTop()
{
    if (Empty())
        throw "Downflow";
    return data[top];
}

// 功    能：判断栈是否为空
template <class T>
bool SeqStack<T>::Empty()
{
    if (top == -1)
        return 1;
    else
        return 0;
}

// 功    能：判断栈是否为满
template <class T>
bool SeqStack<T>::Full()
{
    return top == StackSize - 1;
}

// 顺序二叉树类
const int TreeSize = 100; // 最大长度
template <class T>
class BiTree
{
public:
    BiTree(T *);             // 构造函数，初始化一棵二叉树，其前序序列由键盘输入
    void PreOrder(int pos);  // 前序遍历二叉树
    void InOrder(int pos);   // 中序遍历二叉树
    void PostOrder(int pos); // 后序遍历二叉树
    int CountLeaf(int pos);  // 计算叶子结点总数
    int Depth(int pos);      // 计算高度
    void PreOrder();         // 非递归先序遍历
    void LevelOrder();       // 层次遍历
private:
    T data[TreeSize];
    // 存储结点的元素值，根结点存储在1下标，双亲下标为i，则左右孩子依次为2i，2i+1
};

// constructor
template <class T>
BiTree<T>::BiTree(T *str)
{
    strcpy(data + 1, str);
}

int main()
{
    char str[80];
    cin >> str;
    BiTree<char> bt(str);
    bt.PreOrder(1);
    cout << endl;
    bt.InOrder(0);
    cout << endl;
    bt.PostOrder(1);
    cout << endl;
    bt.PreOrder();
    cout << endl;
    bt.LevelOrder();
    cout << endl;
    cout << bt.CountLeaf(1) << " " << bt.Depth(1) << endl;
    return 0;
}

Input

输入数据为ABD#C####EF############，表示数据在数组中的存储次序，#表示该结点为空结点

Output

输出数据各行依次为先序、中序、后序递归遍历，先序非递归（借助栈实现），层次遍历，叶子个数，高度

A B C E F D
B E C F A D
E F C B D A
A B C E F D
A B D C E F
3 4

Sample Input

ABD#C####EF############

Sample Output

A B C E F D 
B E C F A D 
E F C B D A 
A B C E F D 
A B D C E F 
3 4