二叉树如何实现双亲结点及求树的高度

求二叉树的高度，可以用递归的思想去求解，也可以用非递归的思想去求解，只不过，递归的代码简单明了，但是总的来说，递归有递归的好处，非递归当然也有非递归的好处。

求树的高度的递归思想和递归建树的思想差不多：

                                                                从最底层的子树（结点）开始，求每颗子树（个结点）的左子树和右子树的高度，返回最大的那颗子树的高度，即每递归一次便加1

                                                                          具体核心代码如下：

                                                                             int getHight(BiNode<T>*t)   //递归寻找高度
                                                                        {
                                                                          int deep=0;
                                                                     if(t!=NULL)
                                                                  {
                                                             int lchild_hight=getHight(t->lchild);   //树的左子树的高度
                                                             int rchild_hight=getHight(t->rchild);   //树的右子树的高度
                                                            deep=(lchild>=rchild)?(lchild_hight+1):(rchild_hight+1); //deep取最大值
                                                                  }
                                                                    return deep;  //返回deep
                                                                          }

                                                                        如果递归思想不太明白的，建议去看看盗梦空间哟！

                                                       关于非递归的思想，通过遍历整棵二叉树，找出叶子结点，然后在从叶子结点回溯到树的根结点，通过结算结点个数，加1便是树高了

                                                      具体代码如下：

   void TreeHight(BiNode<T>* &t)     //中序遍历改造为寻找树高

{
using std::stack;
t->father=NULL;
stack<BiNode<T>*>leafstack;//存储叶子结点的栈
stack<BiNode<T>*>nodeStack;//存储待访问的结点
BiNode<T>*pointer=t;
while(!nodeStack.empty()||pointer)  //栈为空时结束遍历
{
if(pointer){
nodeStack.push(pointer);           //当前结点入栈
pointer=pointer->lchild;         //转向访问左子树
}
else{
pointer=nodeStack.top();    //读取栈顶元素
    if(pointer->lchild==NULL&&pointer->rchild==NULL) //判断是否为叶子结点
 leafstack.push(pointer);                      //若为叶子结点，存储到相应的栈中
pointer=pointer->rchild;              //转向访问右子树
nodeStack.pop();                      //栈顶元素退栈
}
}
//叶子结点的地址在leafstack栈中呈线性排列
int Hight=0;//第n个叶子结点的高度
int hight=0;//第n+1个叶子结点的高度
       while(!leafstack.empty())
  {
  hight=0;     //初始化为0
  pointer=leafstack.top(); //读取栈顶的叶子结点
           while(pointer->father!=NULL)   //当叶子栈为空时结束
  { 
     hight++;     
 pointer=pointer->father;//回溯到其双亲结点
 
  }
  leafstack.pop();   //栈顶元素退栈
  if(Hight<hight)    //当前叶子结点的高度若比之前一个的叶子高度大，则赋值给前一个高度
  Hight=hight;
  }
  cout<<"树高为："<<hight+1<<endl;
}

                                                 当然，如果是用非递归思想，那我们在遍历的时候就该用层次遍历咯

                                                不过过程中有一个father指针的标记倒是用到了递归的思想

 完全代码如下：

#include<string>
#include<iostream>
#include<stack>
using namespace std; 
//二叉链表表示二叉树   
template<class T>
class BiNode  
{  
public:
     T data;//节点数据  
     BiNode * lchild;//左孩子  
     BiNode * rchild;//右孩子
BiNode *father;//双亲
     BiNode();
BiNode(T d){ data=d; }        //new一个结点的时候就给其数据域赋值
~BiNode(){}
void createTree(BiNode<T>* &t, string pre,string in) //后序，中序
{
if(pre.length()==0)
{
   t=NULL;
}
if(pre.length()!=0)
{
    t=new BiNode<T>(pre[0]);
   int index=in.find(pre[0]);
            string  in_left_str=in.substr(0, index);
            string  in_right_str=in.substr(index+1);
            string  pre_left_str=pre.substr(1, index);
            string  pre_right_str=pre.substr(index+1); 
if(t!=NULL)
            {
createTree(t->lchild,pre_left_str,in_left_str);
                createTree(t->rchild,pre_right_str,in_right_str);
}
}
}
     void preOrder(BiNode<T> *t)
{
if(t==NULL)
{
  return ;
}
  if(t!=NULL)
  {
   cout<<t->data;
preOrder(t->lchild);
preOrder(t->rchild);
  }
}
void inOrder(BiNode<T> *t)
{
   if(t==NULL)
{
 return ;
}
if(t!=NULL)
{
  inOrder(t->lchild);
  cout<<t->data;
  inOrder(t->rchild);
}
}
void TreeHight(BiNode<T>* &t)     //中序遍历改造为寻找树高
{
using std::stack;
t->father=NULL;
stack<BiNode<T>*>leafstack;//存储叶子结点的栈
stack<BiNode<T>*>nodeStack;//存储待访问的结点
BiNode<T>*pointer=t;
while(!nodeStack.empty()||pointer)  //栈为空时结束遍历
{
if(pointer){
nodeStack.push(pointer);           //当前结点入栈
pointer=pointer->lchild;         //转向访问左子树
}
else{
pointer=nodeStack.top();    //读取栈顶元素
    if(pointer->lchild==NULL&&pointer->rchild==NULL) //判断是否为叶子结点
 leafstack.push(pointer);                      //若为叶子结点，存储到相应的栈中
pointer=pointer->rchild;              //转向访问右子树
nodeStack.pop();                      //栈顶元素退栈
}
}
//叶子结点的地址在leafstack栈中呈线性排列
int Hight=0;//第n个叶子结点的高度
int hight=0;//第n+1个叶子结点的高度
       while(!leafstack.empty())
  {
  hight=0;     //初始化为0
  pointer=leafstack.top(); //读取栈顶的叶子结点
           while(pointer->father!=NULL)   //当叶子栈为空时结束
  { 
     hight++;     
 pointer=pointer->father;//回溯到其双亲结点
 
  }
  leafstack.pop();   //栈顶元素退栈
  if(Hight<hight)    //当前叶子结点的高度若比之前一个的叶子高度大，则赋值给前一个高度
  Hight=hight;
  }
  cout<<"树高为："<<hight+1<<endl;
}
int getHight(BiNode<T>*t)   //递归寻找高度
{
 int deep=0;
if(t!=NULL)
{
int lchild_hight=getHight(t->lchild);   //树的左子树的高度
int rchild_hight=getHight(t->rchild);   //树的右子树的高度
deep=(lchild>=rchild)?(lchild_hight+1):(rchild_hight+1); //deep取最大值
}
return deep;  //返回deep
}
void DeFineFather(BiNode *t)//递归标记结点的双亲
 {
    if(t!=NULL)
{
  if(t->lchild!=NULL)
  t->lchild->father=t;
  if(t->rchild!=NULL)
  t->rchild->father=t;

DeFineFather(t->lchild);
DeFineFather(t->rchild);
}
 }
};
int main()
{
   BiNode<char>*t=NULL;
   string pre="ABDFGCEH";
   string  in="BFDGACEH";
   t->createTree(t,pre,in);
   /*
   cout<<"前序遍历"<<endl;
   t->preOrder(t);
   cout<<endl;
   cout<<"中序遍历"<<endl;
   t->inOrder(t);
   cout<<endl;*/
   t->DeFineFather(t);
   t->TreeHight(t);
   cout<<endl;
cout<<"递归寻求树的高度："<<t->getHight(t)<<endl;
   return 0;
}