二叉树

 前序输入：A、B、C、#、#、#、D、#、#

二叉树的实现以及四种遍历：

#include <iostream>
#include <string>
#include <queue>
using namespace std;

template<class T>
struct BiNode {
    T data;
    BiNode<T> *lchild, *rchild;//左子树、右子树
};

template<class T>
class BiTree
{
public:
    BiTree();//构造函数，初始化二叉树，前序序列由键盘输入
    ~BiTree();//析构函数，释放二叉链表中的各结点的存储空间
    BiNode<T>* Getroot();//获得指向根节点的指针
    void PreOrder(BiNode<T>* root);//前序遍历二叉树
    void InOrder(BiNode<T>* root);//中序遍历二叉树
    void PostOrder(BiNode<T>* root);//后序遍历二叉树
    void LeverOrder(BiNode<T>* root);//层序遍历二叉树
private:
    BiNode<T> *root;//指向根节点的头指针
    BiNode<T> *Great();//有参构造函数调用
    void ReLease(BiNode<T> *root);//析构函数调用
};
template<class T>
BiTree<T>::BiTree() {
    this->root = Great();//创建对象时，构造函数被调用后，调用Great函数进行初始化
}

template<class T>
BiTree<T>::~BiTree() {
    ReLease(root);//调用ReLease释放二叉树链表
}

template<class T>
BiNode<T>* BiTree<T>::Getroot() {
    return root;//返回根节点地址
}

template<class T>
void BiTree<T>::PreOrder(BiNode<T>* root) {
    if (root == NULL)
        return;
    cout << root->data << " ";
    PreOrder(root->lchild);//前序遍历二叉树（根，左，右）
    PreOrder(root->rchild);
}

template<class T>
void BiTree<T>::InOrder(BiNode<T> *root) {
    if (root == NULL)
        return;
    InOrder(root->lchild);//中序遍历二叉树（左，根，右）
    cout << root->data << " ";
    InOrder(root->rchild);
}

template<class T>
void BiTree<T>::PostOrder(BiNode<T>* root) {
    if (root == NULL)
        return;
    PostOrder(root->lchild);//后序遍历二叉树（左，右，根）
    PostOrder(root->rchild);
    cout << root->data << " ";
}

template<class T>
void BiTree<T>::LeverOrder(BiNode<T>* root) {
    BiNode<T> *p;
    if (root == NULL)
        return;
    queue<BiNode<T>*> q;//include<queue>库，queue类型为BiNode<T>*，函数push，empty，pop，front
    q.push(root);
    while (!q.empty()) {
        p = q.front();
        cout << p->data << " ";
        q.pop();
        if (p->lchild != NULL) {
            q.push(p->lchild);
        }
        if (p->rchild != NULL) {
            q.push(p->rchild);
        }
    }
}

template<class T>
BiNode<T>* BiTree<T>::Great() {
    BiNode<T>* root;
    T ch;
    cout << "请输入创建的一颗二叉树的结点数据：" << endl;
    cin >> ch;
    if (ch == "#")
        root = NULL;
    else {
        root = new BiNode<T>;
        root->data = ch;
        root->lchild = Great();
        root->rchild = Great();
    }
    return root;
}

template<class T>
void BiTree<T>::ReLease(BiNode<T>* root) {
    if (root != NULL) {
        ReLease(root->lchild);
        ReLease(root->rchild);
        delete root;
    }
}


int main()
{
    BiTree<string> bt;//创建一棵树
    BiNode<string>* root = bt.Getroot();
    
    cout << "------前序遍历------" << endl;
    bt.PreOrder(root);
    cout << endl;
    cout << "------后序遍历------" << endl;
    bt.PostOrder(root);
    cout << endl;
    cout << "------中序遍历------" << endl;
    bt.InOrder(root);
    cout << endl;
    cout << "------层序遍历------" << endl;
    bt.LeverOrder(root);
    cout << endl;

    system("pause");
    return 0;
}

新增功能

1）复制二叉树

template<class T>
BiNode<T>* BiTree<T>::Copy(BiNode<T>* extN, BiNode<T>* newN)
{
    if (extN == NULL)
    {
        return NULL;
    }
    else
    {
        newN = new BiNode<T>;
        newN->data = extN->data;
        newN->lchild = Copy(extN->lchild, newN->lchild);
        newN->rchild = Copy(extN->rchild, newN->rchild);
        return newN;
    }
}

//...
    BiNode<string>* root2 = NULL;
    root2 = bt.Copy(root, root2);
    cout << "前序输出" << endl;
    bt.PreOrder(root2);

2）统计结点总数

template<class T>
int BiTree<T>::get_count(BiNode<T>* root) {
    if (root == NULL)
        return 0;
    else
        return get_count(root->lchild) + get_count(root->rchild) + 1;
}

3）统计叶子结点数目

template<class T>
int BiTree<T>::get_leafNum(BiNode<T>* root) {
    if (root == NULL)
        return 0;
    if (root->lchild == NULL&&root->rchild == NULL)
        return 1;
    else
        return get_leafNum(root->lchild) + get_leafNum(root->rchild);
}

 4）求树的深度

template<class T>
int BiTree<T>::get_height(BiNode<T>* root) {
    if (root == NULL)
        return 0;
    else
    {
        int h_left  = get_height(root->lchild);
        int h_right = get_height(root->rchild);
        int max = h_left;
        if (max < h_right) { max = h_right; }
        return max + 1;
    }
}