C++模板实现二叉树基本操作

#ifndef BINARYTREE_H
#define BINARYTREE_H
#include <iostream>
#include <stack>
#include <queue>
using namespace std;


template <typename T>
struct btNode
{
    T _data;
    struct btNode *lchild;
    struct btNode *rchild;
};


template <typename T>
class binarytree
{
public:
    binarytree();
    binarytree(const T &data);
    ~binarytree();

    void clearBiTree(btNode<T> *r);

    void creatBiTree(const T &data);

	//前序遍历
    void preOrderTraverse_recursion(btNode<T> *r, vector<T> &array);
    void preOrderTraverse_iteration(vector<T> &array);

	//中序遍历
    void inOrderTraverse_recursion(btNode<T> *r, vector<T> &array);
    void inOrderTraverse_iteration(vector<T> &array);

	//后续遍历

    void postOrderTraverse_recursion(btNode<T> *r, vector<T> &array);
    void postOrderTraverse_iteration(vector<T> &array);

    btNode<T> *get_root();  //返回根节点
    btNode<T> *parent(const T &e); //返回当前节点的父节点，未找到则返回NULL。

	void invertBiTree(btNode<T> *r);        //面试毒瘤，翻转二叉树，递归版
	void invertBiTree_iteration(btNode<T> *r);  //迭代版

private:
    btNode<T> *_root;
};

template<typename T>
binarytree<T>::binarytree()
{
    _root = NULL;
}

template<typename T>
binarytree<T>::binarytree(const T &data)
{
    _root = new btNode<T>;
    _root->_data = data;
    _root->lchild = _root->rchild = NULL;
}

template<typename T>
binarytree<T>::~binarytree()
{
	if (_root)
	{
		clearBiTree(_root);
		_root = NULL;
	}
}

template<typename T>
void binarytree<T>::clearBiTree(btNode<T> *r)
{
   if(r)
   {
       clearBiTree(r->lchild);
       clearBiTree(r->rchild);
       delete r;
   }
}


//创建二叉树
template<typename T>
void binarytree<T>::creatBiTree(const T &data)
{
    if(_root == NULL)
    {
        _root = new btNode<T>;
        _root->_data = data;
        _root->lchild = _root->rchild = NULL;
    }
    else
    {
        btNode<T> *t = new btNode<T>;
        btNode<T> *r = _root;
        while(1)
        {
            if(data < r->_data)
            {
                if(r->lchild == NULL)
                {
                    t->_data = data;
                    t->lchild = t->rchild = NULL;
                    r->lchild = t;
                    break;
                }
                else {
                    r = r->lchild;
                }
            }
            else {
                if(r->rchild == NULL)
                {
                    t->_data = data;
                    t->lchild = t->rchild = NULL;
                    r->rchild = t;
                    break;
                }
                else {
                    r = r->rchild;
                }
            }

        }
    }
}


//先序遍历
template<typename T>
void binarytree<T>::preOrderTraverse_recursion(btNode<T> *r, vector<T> &array)
{
    if(r)
    {
        array.push_back(r->_data);
        preOrderTraverse_recursion(r->lchild, array);
        preOrderTraverse_recursion(r->rchild, array);
    }
}

template<typename T>
void binarytree<T>::preOrderTraverse_iteration(vector<T> &array)
{
    btNode<T> *r = _root;
    stack<btNode<T>*> s;
    while(r || !s.empty())
    {
        while(r)
        {
            array.push_back(r->_data);
            s.push(r);
            r = r->lchild;
        }

        if(!s.empty())
        {
            r = s.top();
            s.pop();
            r = r->rchild;
        }
    }

}


//中序遍历
template<typename T>
void binarytree<T>::inOrderTraverse_recursion(btNode<T> *r, vector<T> &array)
{
    if(r)
    {
        inOrderTraverse_recursion(r->lchild, array);
        array.push_back(r->_data);
        inOrderTraverse_recursion(r->rchild, array);
    }
}

template<typename T>
void binarytree<T>::inOrderTraverse_iteration(vector<T> &array)
{
    btNode<T> *r = _root;
    stack<btNode<T>*> s;
    while(r || !s.empty())
    {
        while(r)
        {
            s.push(r);
            r = r->lchild;
        }

        if(!s.empty())
        {
            r = s.top();
            s.pop();
            array.push_back(r->_data);
            r = r->rchild;
        }
    }
}


//后序遍历递归版
template<typename T>
void binarytree<T>::postOrderTraverse_recursion(btNode<T>* r, vector<T>& array)
{
	if (r)
	{
		postOrderTraverse_recursion(r->lchild, array);
		postOrderTraverse_recursion(r->rchild, array);
		array.push_back(r->_data);
	}
}

//后序遍历迭代版
template<typename T>
void binarytree<T>::postOrderTraverse_iteration(vector<T>& array)
{
	btNode<T> *pre = _root;
	stack<btNode<T>*> stk;
	stk.push(pre);
	while (!stk.empty())
	{
		btNode<T> *cur = stk.top();
		if ((cur->lchild == NULL && cur->rchild == NULL) || (cur->lchild == pre && cur->rchild == NULL) || cur->rchild == pre)
		{
			array.push_back(cur->_data);
			pre = cur;
			stk.pop();
		}
		else
		{			
			if (cur->rchild)
				stk.push(cur->rchild);
			if (cur->lchild)
				stk.push(cur->lchild);
		}
	}
}


//返回二叉树的根结点
template<typename T>
btNode<T> *binarytree<T>::get_root()
{
    return _root;
}

//查找当前节点的父节点
template<typename T>
btNode<T>* binarytree<T>::parent(const T & e)
{
	queue<btNode<T>*> q;
	btNode<T> *r = _root;
	if (r)
	{
		q.push(r);
		while (!q.empty())
		{
			btNode<T> *pa = q.front();
			q.pop();
			if ((pa->lchild && pa->lchild->_data == e) || (pa->rchild && pa->rchild->_data == e))
				return pa;
			else
			{
				if (pa->lchild)
					q.push(pa->lchild);
				if (pa->rchild)
					q.push(pa->rchild);
			}
		}
	}
	return NULL;
}


//返回树的高度
template<typename T>
int binarytree<T>::height(btNode<T> *r)
{
    int lH, rH, maxH;
	if (r)
	{
		lH = height(r->lchild);
		rH = height(r->rchild);
		maxH = lH > rH ? lH : rH;
		return maxH + 1;
	}
	else
		return 0;
}


//翻转二叉树递归版
template<typename T>
void binarytree<T>::invertBiTree(btNode<T>* r)
{
	if (r)
	{
		btNode<T> *t = r->lchild;
		r->lchild = r->rchild;
		r->rchild = t;

		invertBiTree(r->lchild);
		invertBiTree(r->rchild);
	}
}


//翻转二叉树迭代版
template<typename T>
void binarytree<T>::invertBiTree_iteration(btNode<T>* r)
{
	if (r)
	{
		stack<btNode<T>*> s;
		s.push(r);
		while (!s.empty())
		{
			r = s.top();
			s.pop();
			btNode<T> *t = r->lchild;
			r->lchild = r->rchild;
			r->rchild = t;

			if (r->lchild)
				s.push(r->lchild);
			if (r->rchild)
				s.push(r->rchild);
		}
	}
}





#endif // BINARYTREE_H