数据结构——二叉树

代码参考清华大学出版社的数据结构第二版，吐了

#include <iostream>
#include <cstdlib>
#include <stack>
#include <deque>
using namespace std;
template<class T>
struct BinTreeNode {  //广义表
    T data;
    BinTreeNode<T>* leftChild, * rightChild;
    BinTreeNode() :leftChild(NULL), rightChild(NULL) {}
    BinTreeNode(T x, BinTreeNode<T>* l = NULL, BinTreeNode<T>* r = NULL) :data(x), leftChild(l), rightChild(r) {}
};
template<class T>
class BinaryTree {
public:
    BinaryTree() :root(NULL) {}
    BinaryTree(char x) :root(NULL), RefValue(x) {}
    BinaryTree(const BinaryTree<T>& Tree) { root = copy(Tree.root); }//构造函数
    BinaryTree<T>& operator=(const BinaryTree<T>& Tree);//赋值运算符
    ~BinaryTree() { destroy(root); }//析构函数
    bool isEmpty()const { return root != NULL ? false : true; }
    BinTreeNode<T>* leftChild(BinTreeNode<T>* current)const { return current != NULL ? current->leftChild : NULL; }
    BinTreeNode<T>* rightChild(BinTreeNode<T>* current)const { return current != NULL ? current->rightChild : NULL; }
    BinTreeNode<T>* parent(BinTreeNode<T>* current)const { return (root == NULL || current == root) ? NULL : parent(root, current); }//寻找其父节点
    BinTreeNode<T>* getRoot()const { return root; }
    void inOrder(void (*visit)(BinTreeNode<T>* p)) { inOrder(root, visit); }//中序递归
    void preOrder(void (*visit)(BinTreeNode<T>* p)) { preOrder(root, visit); }//前序递归
    void postOrder(void (*visit)(BinTreeNode<T>* p)) { postOrder(root, visit); }//后序递归
    void levelOrder(void (*visit)(BinTreeNode<T>* p));//使用队列的层次遍历
    int size()const { return size(root); }//使用后序递归遍历求节点个数
    int height()const { return height(root); }//使用后序递归遍历求高度
protected:
    BinTreeNode<T>* root;
    char RefValue;//数据输入停止标志
    void destroy(BinTreeNode<T>* subTree);//递归删除二叉树节点。后序遍历删除
    BinTreeNode<T>* copy(const BinTreeNode<T>* orignode);//构造 //前序
    BinTreeNode<T>* parent(BinTreeNode<T>* subTree, BinTreeNode<T>* current)const;//返回父节点
    void traverse(BinTreeNode<T>* subTree, ostream& out)const;//按前序遍历输出
    void createBinTree(istream& in, BinTreeNode<T>*& subTree);//二叉树创建
    void inOrder(BinTreeNode<T>* subTree, void (*visit)(BinTreeNode<T>* p));//中序
    void preOrder(BinTreeNode<T>* subTree, void (*visit)(BinTreeNode<T>* p));//前序
    void postOrder(BinTreeNode<T>* subTree, void (*visit)(BinTreeNode<T>* p));//后序
    int size(BinTreeNode<T>* subTree)const;//使用后序递归遍历求节点个数
    int height(BinTreeNode<T>* subTree)const;//使用后序递归遍历求二叉树的高度
    friend ostream& operator<< <T> (ostream& out, const BinaryTree<T>& Tree);//前出
    friend istream& operator>> <T> (istream& in, BinaryTree<T>& Tree);      //广义表创建
};
template<class T>
void BinaryTree<T>::destroy(BinTreeNode<T>* subTree) {
    if (subTree != NULL) {
        destroy(subTree->leftChild);
        destroy(subTree->rightChild);
        delete subTree;
    }
}

template<class T>
BinTreeNode<T>* BinaryTree<T>::parent(BinTreeNode<T>* subTree, BinTreeNode<T>* current)const {
    if (subTree == NULL) 
        return NULL;
    if (subTree->leftChild == current || subTree->rightChild == current) 
        return subTree;
    BinTreeNode<T>* p;
    if ((p = parent(subTree->leftChild, current)) != NULL) 
        return p;
    else 
        return parent(subTree->rightChild, current);
}

template<class T>
void BinaryTree<T>::traverse(BinTreeNode<T>* subTree, ostream& out)const {
    if (subTree != NULL) {
        out << subTree->data << " ";
        traverse(subTree->leftChild, cout);
        traverse(subTree->rightChild, out);
    }
}
template<class T>
void BinaryTree<T>::createBinTree(istream& in, BinTreeNode<T>*& subTree) {
    stack<BinTreeNode<T>* > s;
    subTree = NULL;
    BinTreeNode<T>* p, * t;
    int k;
    T ch;
    in >> ch;//一定要是字符型，不然会报错
    while (ch != RefValue) {
        switch (ch) {
        case '(': s.push(p); k = 1; break;
        case ')': s.pop(); break;//tag
        case ',': k = 2; break;
        default:
            p = new BinTreeNode<T>(ch);
            if (subTree == NULL)
                subTree = p;
            else if (k == 1) {
                t = s.top(); t->leftChild = p;
            }
            else {
                t = s.top(); t->rightChild = p;
            }
        }
        in >> ch;
    }
}

template<class T>
ostream& operator << (ostream& out, const BinaryTree<T>& Tree) {
    out << "输出前序遍历：";
    Tree.traverse(Tree.root, out);
    out << endl;
    return out;
}

template<class T>
istream& operator>>(istream& in, BinaryTree<T>& Tree) {
    Tree.createBinTree(in, Tree.root);
    return in;
}

template<class T>
void BinaryTree<T>::inOrder(BinTreeNode<T>* subTree, void (*visit)(BinTreeNode<T>* p)) {
    if (subTree != NULL) {
        inOrder(subTree->leftChild, visit);
        visit(subTree);
        inOrder(subTree->rightChild, visit);
    }
}

template<class T>
void BinaryTree<T>::preOrder(BinTreeNode<T>* subTree, void (*visit)(BinTreeNode<T>* p)) {
    if (subTree != NULL) {
        visit(subTree);
        inOrder(subTree->leftChild, visit);
        inOrder(subTree->rightChild, visit);
    }
}

template<class T>
void BinaryTree<T>::postOrder(BinTreeNode<T>* subTree, void (*visit)(BinTreeNode<T>* p)) {
    if (subTree != NULL) {
        inOrder(subTree->leftChild, visit);
        inOrder(subTree->rightChild, visit);
        visit(subTree);
    }
}

template<class T>
int BinaryTree<T>::size(BinTreeNode<T>* subTree)const {
    if (subTree == NULL)  return 0;
    else return 1 + size(subTree->leftChild) + size(subTree->rightChild);
}

template<class T>
int BinaryTree<T>::height(BinTreeNode<T>* subTree)const {
    if (subTree == NULL) return 0;
    else {
        int i = height(subTree->leftChild);
        int j = height(subTree->rightChild);
        return (i > j) ? i + 1 : j + 1;
    }
}
template<class T>
BinTreeNode<T>* BinaryTree<T>::copy(const BinTreeNode<T>* orignode) {
    if (orignode == NULL) return NULL;
    BinTreeNode<T>* temp = new BinTreeNode<T>;
    temp->data = orignode->data;
    temp->leftChild = copy(orignode->leftChild);
    temp->rightChild = copy(orignode->rightChild);
    return temp;
}

template<class T>
BinaryTree<T>& BinaryTree<T>::operator=(const BinaryTree<T>& Tree) {
    this->destroy(this->root);
    this->root = copy(Tree.root);
    return *this;
}

template<class T>
void BinaryTree<T>::levelOrder(void (*visit)(BinTreeNode<T>* p)) {
    deque<BinTreeNode<T>*> dq;
    BinTreeNode<T>* p = root;
    dq.push_back(p);
    while (!dq.empty()) {
        p = dq.front();
        visit(p);
        dq.pop_front();
        if (p->leftChild != NULL) dq.push_back(p->leftChild);
        if (p->rightChild != NULL) dq.push_back(p->rightChild);
    }
}

int main() {
    BinaryTree<char> b('#');
    cin >> b;
    cout << b << endl;
    b.levelOrder(NULL);
    return 0;

}