二叉树的递归实现（前序，中序，后序，层序，高度，叶子节点数，第k层节点数）

一：二叉树是我们学过最常用也是最基础的数据结构，要想学好二叉树

①首先要学会利用含有非法值得数组前序遍历★建立一颗二叉树；

②然后我们要会用递归的方式对这颗二叉树进行★前序，★中序，★后序的遍历打印，也要学会利用队列的先进先出的原则对着棵树进行★层序访问；

③然后我们还要知道这颗二叉树的基本信息；比如，★二叉树的总节点个数，★二叉树的叶子节点个数，★二叉树的第k层的节点个数，★二叉树的高度（深度）；

二：完整代码

#include<iostream>
using namespace std;
#include<assert.h>
#include<queue>

template<class T>
struct TreeNode
{
TreeNode( const T& data=T())
:_data(data)
,_left(NULL)
,_right(NULL)
{}
int _data;
TreeNode<T>* _left;
TreeNode<T>* _right;
};

template<class T>
class BinaryTree
{
typedef  TreeNode<T>  Node;
public:
BinaryTree()//无参构造函数
:_root(NULL)
{}
BinaryTree(const T* arr,int sz,const T invalid)//有参构造函数
{
assert(arr);
int index=0;//数组中的位置
_root=BuildTree(arr,sz,invalid,index);
}
BinaryTree(const BinaryTree<T>& bt)//拷贝构造
{
_root=Copy(bt._root);
}
BinaryTree<T>&  operator=(const BinaryTree<T>& bt)//赋值运算符重载1
{
if (this!=&bt)
{
Node* tmp=Copy(bt._root);//拷贝源对象给中间变量
Free(_root);//释放本对象
_root=tmp;//将中间变量给本对象
}
return  *this;
}
//BinaryTree<T>&  operator=(const BinaryTree<T>& bt)//赋值运算符重载2（现代写法）
//{
//       std::swap(_root,bt._root);
//  return *this;
//}
void PreOrder()//前序遍历打印（递归）
{
cout<<"前序打印:";
_PreOrder(_root);
}
void InOrder()//中序遍历打印（递归）
{
cout<<"中序打印:";
_InOrder(_root);
}
void EndOrder()//后序遍历打印（递归）
{
cout<<"后序打印:";
_EndOrder(_root);
}
void SeqOrder()//层序遍历打印
{
cout<<"层序打印:";
_SeqOrder(_root);
}
int Szie()//二叉树节点数
{
return _Szie(_root);

}
int Hight()//二叉树的高度
{
return _Hight(_root);
}
int  GetLeafNodeNumber()//求叶子节点数
{
return _GetLeafNodeNumber(_root);
}
int Get_K_NodeNumber(int k)//求第k层节点数
{
return _Get_K_NodeNumber(_root,k);
}
protected:
Node* BuildTree(const T*arr,int sz,const T& invalid, int& index)//前序遍历建树
{
assert(arr);
if (index<sz && arr[index]!=invalid)
{
Node* root=new Node(arr[index]);
root->_left=BuildTree(arr,sz,invalid,++index);
root->_right=BuildTree(arr,sz,invalid,++index);
return root;
}
return NULL;
}
Node* Copy(Node* root)//先序遍历拷贝(递归)
{
Node* tmp=NULL;
if (root)
{
tmp=new Node(root->_data);
tmp->_left=Copy(root->_left);
tmp->_right=Copy(root->_right);
}
return tmp;
}
void Free(Node*& root)//后序遍历的方式释放树
{
if (root)
{
Free(root->_left);
Free(root->_right);
delete  root;
root=NULL;
}

}
void _PreOrder(Node* root)//前序遍历打印
{
if (root)
{
cout<<root->_data<<"->";
_PreOrder(root->_left);
_PreOrder(root->_right);
}

}
void _InOrder(Node* root)//中序遍历打印
{
if (root)
{
_InOrder(root->_left);
cout<<root->_data<<"->";
_InOrder(root->_right);
}

}
void _EndOrder(Node* root)//后续遍历打印
{
if (root)
{
_EndOrder(root->_left);
_EndOrder(root->_right);
cout<<root->_data<<"->";
}

}
void _SeqOrder(Node* root)//层序遍历打印
{
//利用队列先进先出的特点层序的打印二叉树的节点
queue<Node*> q;
if (root)//首先判断树的跟目录不为空
{
q.push(root);//将根目录入队列
}
while (!q.empty())//当队列不为空时，此时队列中一直有元素，则继续进入循环打印
{
Node* tmp=q.front();
cout<<tmp->_data<<"->";
q.pop();
if (tmp->_left)
{
q.push(tmp->_left);
}
if (tmp->_right)
{
q.push(tmp->_right);
}
}

}
int _Szie( Node* root)//二叉树节点数
{
int count=0;//定义一个count计数器
if (NULL==root)//情况一：如果root为空，则节点数为0
{
count=0;
}
else//情况二：root不为空
{
//树的节点=左子树的节点数+右子树的节点数+1（根）；
count=_Szie(root->_left)+_Szie(root->_right)+1;
}
return count;
}
int _Hight(Node* root)//二叉树的高度
{

if (NULL==root)//情况一：root为空
{
return 0;
}
//情况二：root不为空,此时该树高度为左右子树中大的树高度+1（根）
return _Hight(root->_left)>_Hight(root->_right)?
(_Hight(root->_left)+1):(_Hight(root->_right)+1);

}
int _GetLeafNodeNumber(const Node* root)//二叉树的叶子节点数
{
if (NULL==root)//情况一：root为空
{
return 0;
}
if (NULL==root->_left && NULL==root->_right)//情况二：该节点左右子树都为空
{
return 1;
}
//情况三：左右子树都不为空

return _GetLeafNodeNumber(root->_left)+_GetLeafNodeNumber(root->_right);
}
int _Get_K_NodeNumber(Node* root,int k)//求二叉树的第k层的
{
assert(k>0);
if (NULL==root)
{
return 0;
}
if (k==1)
{
return 1;
}
return _Get_K_NodeNumber(root->_left,k-1)+_Get_K_NodeNumber(root->_right,k-1);
}
protected:
Node*  _root;
};

测试代码：

void Test()
{
/*int arr[]={1,2,'#',3,'#','#',4,5,'#',6,'#',7,'#','#',8};*/
int arr[] = {1, 2, 3, '#', '#', 4, '#' , '#', 5, 6,'#','#','#'};
int sz=sizeof(arr)/sizeof(arr[0]);
BinaryTree<int>  bt2(arr,sz,'#');//调用带有参数的构造函数
BinaryTree<int>  bt1(bt2);//调用拷贝构造函数
BinaryTree<int>  bt;//调用默认构造函数
bt=bt1;//调用赋值运算符重载
bt.PreOrder();
cout<<endl;
bt.InOrder();
cout<<endl;
bt.EndOrder();
cout<<endl;
bt.SeqOrder();
cout<<endl;
cout<<"二叉树的节点数："<<bt.Szie()<<endl;
cout<<"二叉树的叶子节点个数:"<<bt.GetLeafNodeNumber()<<endl;
cout<<"二叉树的高度:"<<bt.Hight()<<endl;
cout<<"二叉树第1层节点数："<<bt.Get_K_NodeNumber(1)<<endl;
cout<<"二叉树第2层节点数："<<bt.Get_K_NodeNumber(2)<<endl;
cout<<"二叉树第3层节点数："<<bt.Get_K_NodeNumber(3)<<endl;
cout<<"二叉树第4层节点数："<<bt.Get_K_NodeNumber(4)<<endl;
cout<<"二叉树第5层节点数："<<bt.Get_K_NodeNumber(5)<<endl;

}
int main()
{
Test();
return 0;
}

三：运行结果



后面还有二叉树的非递归实现。。。敬请关注 ——-O(∩_∩)O哈哈~