二叉樹

二叉樹是重要的資料結構，在學習中以及考試、面試中不可避免的考點，現在我就把有關二叉樹的操作用C++總結 一下，可能有些同學使用的是C語言，但是無論C語言還是c++，對於二叉樹的操作方法都是一樣的，之後，我也會抽空給出C語言的實現。

本次實現是在vs2008的一個整合開發環境，為了增強程式碼的複用性，此次編寫使用了模版，關於模版可以參考的我的另外一篇部落格：http://blog.csdn.net/dy_1024/article/details/78643644，如果大家在使用的時候，不實用模版，只需把程式碼中的模版型別T，換成你需要的型別即可。

首先我們用結構體給出二叉樹結點的結構：

template<class T>//如果大家不使用模版的話，把這行程式碼去掉，將結構體中的T該成你需要的型別即可
struct BinTreeNode{
	BinTreeNode(const T& data):_left(NULL),_right(NULL),_data(data){}//二叉樹結點的建構函式，方便之後給出新結點
	BinTreeNode* _right;//右子樹
	BinTreeNode* _left;//左子樹
	T _data;//資料域
};
 

template<class T>
class  BinTree
{
	typedef BinTreeNode<T> Node;//將之前的類此重定義，方便以後的使用
	typedef Node* PNode;
public:
	BinTree():_pRoot(NULL){}
	//建構函式裡面使用的建立二叉樹的函式，
	void _CreatBinTree(PNode& pRoot,const T* array,size_t size,size_t& index,const T& invalid)
	{
		if(index<size && array[index] != invalid)
		{
			pRoot = new Node(array[index]);
			_CreatBinTree(pRoot->_left,array,size,++index,invalid);
			_CreatBinTree(pRoot->_right,array,size,++index,invalid);
		}
	}
	
 
//建構函式，在給建構函式傳參的時候，我們定義：char *array ="ABD###CE##F"，這是二叉樹前序遍歷的結果，"#"代表無效值，也就是空子樹
	BinTree(const T* array,size_t size,const T& invalid)
	{
		size_t index = 0;
		_CreatBinTree(_pRoot,array,size,index,invalid);//我們將二叉樹的構造封裝成函式，這樣結構比較明確
	}
	//前序遍歷
	void _PreOrder(PNode pRoot)
	{
		if(pRoot)
		{
			cout<<pRoot->_data<<" ";
			_PreOrder(pRoot->_left);
			_PreOrder(pRoot->_right);
		}
	}
	
 
//中序遍歷
	void _InOrder(PNode pRoot)
	{
		if(pRoot)
		{
			_InOrder(pRoot->_left);
			cout<<pRoot->_data<<" ";
			_InOrder(pRoot->_right);
		}
	}
	//後續遍歷
	void _PostOrder(PNode pRoot)
	{
		if(pRoot)
		{
			_PostOrder(pRoot->_left);
			_PostOrder(pRoot->_right);
			cout<<pRoot->_data<<" ";
		}
	}
	//拷貝建構函式裡面需要的拷貝函式
	PNode _CopyBinTree(PNode pRoot)
	{
		PNode pNewNode = NULL;
		if(pRoot)
		{
			pNewNode = new Node(pRoot->_data);
			pNewNode->_left = _CopyBinTree(pRoot->_left);
			pNewNode->_right = _CopyBinTree(pRoot->_right);
		}
		return pNewNode;
	}
	BinTree(const BinTree<T>& bt)//拷貝建構函式
	{
		_pRoot = _CopyBinTree(bt._pRoot);
	}
	//銷燬函式
	void _DestoryBinTree(PNode& pRoot)
	{
		if(pRoot)
		{
			_DestoryBinTree(pRoot->_left);
			_DestoryBinTree(pRoot->_right);
		}
		delete pRoot;
		pRoot = NULL;
	}
	//賦值運算子過載
	BinTree<T>& operator=(const BinTree<T>& bt)
	{
		//把原有的樹銷燬掉，在用拷貝函式，拷貝一個新樹
		_DestoryBinTree(_pRoot);
		_pRoot = _CopyBinTree(bt._pRoot);
		return *this;
	}
	//求樹的高度
	size_t _Height(PNode pRoot)
	{
		if(NULL == pRoot)
			return 0;
		if(pRoot->_left == NULL && pRoot->_right == NULL)
		{
			return 1;
		}
		size_t left = _Height(pRoot->_left);//將左子樹的高度賦值給left
		size_t right = _Height(pRoot->_right);//將右子樹的高度賦值給right
		return left>right?(left+1):(right+1);比較左右子樹的大小，大的再加上1，就是樹的大小
	}
	//求按層遍歷的個數，思路：當你要求第3層的時候，如果以第二層為根，那麼就是求第二層的結點，依次遍歷
	size_t _GetKLevelNodeCount(PNode pRoot,size_t k)
	{
		if(k == 0 || NULL == pRoot)return 0;
		if(k == 1)return 1;
		return _GetKLevelNodeCount(pRoot->_left,k-1)+_GetKLevelNodeCount(pRoot->_right,k-1);
	}
	//按層遍歷，我們使用佇列結構儲存每次收集的結點，運用佇列隊頭出隊尾進的特點，輸出每一層的結點
	void _LevelOrder(PNode pRoot)
	{
		PNode pCur = NULL;
		queue<PNode> q;
		q.push(pRoot);
		while (!q.empty())
		{
			pCur = q.front();
			cout<<pCur->_data<<" ";
			if(pCur->_left)
				q.push(pCur->_left);
			if(pCur->_right)
				q.push(pCur->_right);
			q.pop();
		}
	}
	//判斷結點是否在樹中
	bool _IsNodeInBinTree(PNode pRoot,PNode pNode)
	{
		if(NULL == pRoot || pNode == NULL)
			return false;
		if(pRoot == pNode)
			return true;
		bool Isflag = _IsNodeInBinTree(pRoot->_left,pNode);
		if(Isflag)
			return true;
		return _IsNodeInBinTree(pRoot->_right,pNode);
	}
	//在樹種找到一個結點
	PNode _Find(PNode pRoot,const T& data)
	{
		if(NULL == pRoot)
			return NULL;
		if(pRoot->_data == data)
			return pRoot;
		PNode pCur = NULL;
		if(pCur = _Find(pRoot->_left,data))
			return pCur;
		return _Find(pRoot->_right,data);
	}
	//求樹的映象—遞迴
	void _Mirror(PNode pRoot)
	{
		swap(pRoot->_left, pRoot->_right);//直接交換左右子樹裡面的地址，那麼他的左右子樹就交換成功了
		if(pRoot->_left)
			_Mirror(pRoot->_left);
		if(pRoot->_right)
			_Mirror(pRoot->_right);
	}
	//求樹得映象-非遞迴
	void _Mirror_nor(PNode pRoot)
	{
		if(NULL == pRoot)
			return;
		queue<PNode> q;
		q.push(pRoot);
		while (!q.empty())
		{
			PNode pCur = q.front();
			swap(pCur->_left,pCur->_right);
			if(pCur->_left)
				q.push(pCur->_left);
			if(pCur->_right)
				q.push(pCur->_right);
			q.pop();
		}
	}
	//判斷一棵二叉樹是不是一顆完全二叉樹，當我們發現一個結點只有左子樹，沒有右子樹的時候，就要開始判斷

//下一個結點有沒有子樹，如果有就不是，如果沒有就繼續，和層序遍歷一樣，使用佇列結構

限於編者水平，本文文章難免有缺漏之處，歡迎指正

Tip:如需轉載，請註明出處