进击的暑假（六）--二叉树

#include <iostream>
#include <stack>
using namespace std;

template <typename  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 <typename T>
class BinaryTree{
public:
    BinaryTree():RefValue('#'),root(NULL){}
    BinaryTree(T value):RefValue(value), root(NULL){}
    ~BinaryTree(){destroy(root);}
    void CreateBinaryTree( const char * &str){
        CreateBinaryTree(root,str);
    }
    void PreOrderTraverse()const {
        PreOrderTraverse(root);
    }
    void PreOrderTraverse_1()const {
        PreOrderTraverse_1(root);
    }
    void InOrderTraverse()const {
        InOrderTraverse(root);
    }
    void PostOrderTraverse()const {
        PostOrderTraverse(root);
    }
    int Size()const {
        return Size(root);
    }
    int Height()const{
        return Height(root);
    }
    BinTreeNode<T>* Find(const T key){
        return Find(root, key);
    }
    BinTreeNode<T>* Parent(const T key){
        return Parent(root, key);
    }
public:
    void destroy(BinTreeNode<T>* &subTree);
protected:
    void CreateBinaryTree(BinTreeNode<T> *&R,const char *&str);
    void PreOrderTraverse_1(BinTreeNode<T> *R) const ;
    void PreOrderTraverse(BinTreeNode<T> *R) const ;
    void InOrderTraverse(BinTreeNode<T> *R)const ;
    void PostOrderTraverse(BinTreeNode<T> *R)const;
    int Size(BinTreeNode<T> *R)const;
    int Height(BinTreeNode<T> *R)const;
    BinTreeNode<T>* Find(BinTreeNode<T> *R, const T key)const;
    BinTreeNode<T>* Parent(BinTreeNode<T> *R, const T key)const;
protected:
    BinTreeNode<T> *root;
    T RefValue;
};
template <typename T>
void BinaryTree<T>::CreateBinaryTree(BinTreeNode<T> *&R, const char* &str)
{
    cout<<"create"<<endl;
    //char ch;
    if(*str == RefValue || *str == '\0')
        R = NULL;
    else{
        R = new BinTreeNode<T>(*str);
        CreateBinaryTree(R->leftChild, ++str);
        CreateBinaryTree(R->rightChild, ++str);
    }
}
template <typename T>
void BinaryTree<T>::PreOrderTraverse(BinTreeNode<T> *R)const
{
    if(R){
        cout<<R->data<<" ";
        PreOrderTraverse(R->leftChild);
        PreOrderTraverse(R->rightChild);
    }
}
template <typename T>
void BinaryTree<T>::PreOrderTraverse_1(BinTreeNode<T> * R)const
{
    if(R != NULL)
    {
        stack<BinTreeNode<T>* > St;
        BinTreeNode<T> *p = NULL;
        St.push(R);
        while (!St.empty())
        {
            p = St.top();
            St.pop();
            cout<<p->data<<" ";
            if(p->rightChild != NULL)
                St.push(p->rightChild);
            if(p->leftChild != NULL)
                St.push(p->leftChild);
        }
    }
}
template <typename T>
void BinaryTree<T>::InOrderTraverse(BinTreeNode<T> *R) const
{
    if(R)
    {
        InOrderTraverse(R->leftChild);
        cout<<R->data<<" ";
        InOrderTraverse(R->rightChild);
    }
}
template <typename T>
void BinaryTree<T>::PostOrderTraverse(BinTreeNode<T> *R) const
{
    if(R){
        PostOrderTraverse(R->leftChild);
        PostOrderTraverse(R->rightChild);
        cout<<R->data<<" ";
    }
}
template <typename T>
int BinaryTree<T>::Size(BinTreeNode<T> *R) const
{
    if(R == NULL)
        return 0;
    return Size(R->rightChild) + Size(R->leftChild) + 1;
}
template <typename T>
int BinaryTree<T>::Height(BinTreeNode<T> *R) const
{
    if(R == NULL)
        return 0;
    int left_height = Height(R->leftChild);
    int right_height = Height(R->rightChild);
    return left_height > right_height ? (left_height + 1) : (right_height + 1);
}
template <typename T>
BinTreeNode<T>* BinaryTree<T>::Find(BinTreeNode<T> *R, const T key) const
{
    if(R == NULL)
        return NULL;
    if(R->data == key)
        return R;
    BinTreeNode<T> *q = Find(R->leftChild,key);
    if(q != nullptr)
        return q;
    return Find(R->rightChild,key);
}

template <typename T>
BinTreeNode<T>* BinaryTree<T>::Parent(BinTreeNode<T> *R, const T key) const
{
    BinTreeNode<T>* q = Find(R, key);
    if(q == nullptr ||  q == R)
        return nullptr;
    if(R->leftChild == q || R->rightChild == q)
        return  R;
    else{
        BinTreeNode<T>* p = Parent(R->leftChild, key);
        if(p != nullptr)
            return p;
        return Parent(R->rightChild, key);
    }
}
template <typename T>
void BinaryTree<T>::destroy(BinTreeNode<T> *&subTree)
{
    if(subTree != nullptr)
    {
        destroy(subTree->leftChild);
        destroy(subTree->rightChild);
        delete subTree;
    }
    cout<<"destroy"<<endl;
}

int main()
{
    const char  *str ="abc##d##e#f##";
    BinaryTree<char > my_binarytree;
    my_binarytree.CreateBinaryTree(str);
    /*
    my_binarytree.PreOrderTraverse_1();
    cout<<endl;
    my_binarytree.PreOrderTraverse();
    cout<<endl;
    my_binarytree.InOrderTraverse();
    cout<<endl;
    my_binarytree.PostOrderTraverse();
    */
    //cout<<my_binarytree.Size()<<endl;
    //cout<<my_binarytree.Height()<<endl;
    //BinTreeNode<char >*p =  my_binarytree.Find(('a'));
    //BinTreeNode<char >*q = my_binarytree.Parent('f');
    return 0;
}

中序遍历和后续遍历的非递归写法还没有完善，析构函数也还没有写，存在内存泄漏。