二叉树:

二叉树是一棵特殊的树，二叉树每个节点最多有两个孩子结点，分别称为左孩子和右孩子。

实例：

wKioL1cXTQOhO33gAAAYGdz7lKk183.png

节点结构:

template <class T>
struct BinaryTreeNode
{
	BinaryTreeNode(T data)
		:_data(data)
		,_left(NULL)
		,_right(NULL)
	{}
	T _data;
	BinaryTreeNode<T>* _left;
	BinaryTreeNode<T>* _right;
};

二叉树成员变量；

protected:
	BinaryTreeNode<T>* _root;

构造函数：调用_CreateTree

Node* _CreateTree(const T* a,size_t size,size_t& index,const T& invalid)//注意index用引用
	{
		Node* root=NULL;
		if((index<size)&&(a[index]!=invalid))
		{
			root=new Node(a[index]);
			root->_left=_CreateTree(a,size,++index,invalid);
			root->_right=_CreateTree(a,size,++index,invalid);
		}
		return root;
	}

析构函数：调用_Destory

void _Destory(Node* root)
	{
		Node* cur=root;
		Node* del=cur;
		if(cur->_left!=NULL)
		{
			_Destory(cur->_left);
		}
		if(cur->_right!=NULL)
		{
			_Destory(cur->_right);
		}
		delete del;
	}

拷贝构造函数：调用_Copy

Node* _Copy(Node* root)
	{
		if(root==NULL)
			return NULL;
		Node* newroot=new Node(root->_data);
		Node* cur=newroot;
		cur->_left=_Copy(root->_left);
		cur->_right=_Copy(root->_right);
		return newroot;
	}

重载赋值运算符

BinaryTree& operator=(BinaryTree tree)
	{
		swap(_root,tree._root);
		return *this;
	}

前序遍历：调用_PrevOrder

void _PrevOrder(Node* root)
	{
		if(root==NULL)
			return;
		cout<<root->_data<<" ";
		_PrevOrder(root->_left);
		_PrevOrder(root->_right);
	}

中序遍历：调用_InOrder

void _InOrder(Node* root)
	{
		if(root==NULL)
			return;
		_InOrder(root->_left);
		cout<<root->_data<<" ";
		_InOrder(root->_right);
	}

后序遍历：调用_PoseOrder

void _PostOrder(Node* root)
	{
		if(root==NULL)
			return;
		_PostOrder(root->_left);
		_PostOrder(root->_right);
		cout<<root->_data<<" ";
	}

求深度：调用_Depth

size_t _Depth(Node* root)
	{
		Node* cur=root;
		size_t depth=0;
		if(cur==NULL)
			return 0;
		else
		{
			depth=1;
			size_t leftdepth=_Depth(cur->_left);
			size_t rightdepth=_Depth(cur->_right);
			if(leftdepth>=rightdepth)
			{
				return depth+leftdepth;
			}
			else
			{
				return depth+rightdepth;
			}
		}
	}

求size：调用_Size

size_t _Size(Node* root)
	{
		size_t count=0;
		if(root==NULL)
			return 0;
		else
		{
			++count;
		}
		count+=_Size(root->_left);
		count+=_Size(root->_right);
		return count;
	}

求叶子节点的个数：调用_LeafSize

size_t _LeafSize(Node* root)
	{
		size_t size=0;
		if(root==NULL)
			return 0;
		else
		{
			if((root->_left==NULL)&&(root->_right==NULL))
			{
				size=1;
				return size;
			}
			else
			{
				size_t left=_LeafSize(root->_left);
				size_t right=_LeafSize(root->_right);
				return left+right;
			}
		}
	}