二叉树的操作--递归与非递归

由于此前已对二叉树介绍过，在此便不多做解释；全是递归操作，先左后右；

创建一个变量：

 BinaryTreeNode<T>* _pRoot;

以下是操作是创建树

 void _CreateTree(Node*& pRoot, const T array[], size_t size, size_t& index, const T& invalid)  //创建一个树 {  if(index<size&&invalid!=array[index])  {   pRoot=new Node(array[index]);   _CreateTree(pRoot->_pLeft,array,size,++index,invalid);   _CreateTree(pRoot->_pRight,array,size,++index,invalid);  } }

销毁树

 void _DestroyTree(Node* &pRoot)  //销毁树 {  Node* temp=pRoot;  if(pRoot==NULL)  {   return;  }  _DestroyTree(temp->_pLeft);  _DestroyTree(temp->_pRight);  delete temp;  temp=NULL; }

前序遍历树

 void _PreOrder(Node* pRoot) //前序遍历 {  Node* temp=pRoot;  if(temp==NULL)  {   return;  }  cout<<temp->_data<<"  ";//访问跟结点  _PreOrder(temp->_pLeft);//递归算法访问左结点  _PreOrder(temp->_pRight);//递归算法访问右结点 }

中序遍历树

 void _InOrder(Node* pRoot) //中序遍历 {  Node* temp=pRoot;  if(temp==NULL)  {   return;  }  _InOrder(temp->_pLeft);//递归算法访问左结点  cout<<temp->_data<<"  ";//访问跟结点  _InOrder(temp->_pRight);//递归算法访问右结点 }

后序遍历结点

 void _PostOrder(Node* pRoot)  //后序遍历 {  Node* temp=pRoot;  if(temp==NULL)  {   return;  }  _PostOrder(temp->_pLeft);//递归算法访问左结点  _PostOrder(temp->_pRight);//递归算法访问右结点  cout<<temp->_data<<"  ";//访问跟结点 }

某结点的双亲结点

  Node* _GetParent(Node* pRoot, Node* x)  {    if(x==pRoot||x==NULL||NULL==pRoot)  {   return NULL;  }  if(x==pRoot->_pLeft||x==pRoot->_pRight)  {   return pRoot;  }  if(x!=pRoot)  {   _GetParent(pRoot->_pLeft,x);   _GetParent(pRoot->_pRight,x);  }     }

求树的高度

 size_t _Height(Node* pRoot) {  if(pRoot==NULL)   return 0;  if(NULL==pRoot->_pLeft&&NULL==pRoot->_pRight)   return 1;  else  {  size_t leftHight=_Height(pRoot->_pLeft);  size_t rightHight=_Height(pRoot->_pRight);  if(leftHight>rightHight)  return leftHight+1;  else  return rightHight+1;  } }

树的层数

 size_t _GetKLevelNode(Node* pRoot, size_t k) {  if(pRoot==NULL||k<1||k>_Height(pRoot))   return 0;  if(NULL==pRoot->_pLeft&&NULL==pRoot->_pRight)   return 1;  return  _GetKLevelNode(pRoot->_pLeft,k-1)+ _GetKLevelNode(pRoot->_pRight,k-1); }

树的叶子节点的个数

 size_t _GetLeefNode(Node* pRoot) {   if(pRoot==NULL)    return 0;   if(NULL==pRoot->_pLeft&&NULL==pRoot->_pRight)    return 1;   return   _GetLeefNode(pRoot->_pLeft)+ _GetLeefNode(pRoot->_pRight); }

拷贝构造函数

 Node* _CopyBinaryTree(Node* pRoot)   //复制树 {  if(pRoot==NULL)  {   return NULL;  }  Node* pNewRoot=new Node(pRoot->_data);  pNewRoot->_pLeft=_CopyBinaryTree( pRoot->_pLeft);  pNewRoot->_pRight=_CopyBinaryTree( pRoot->_pRight);  return pNewRoot; }

在树中寻找某个结点

 Node* _Find(Node* pRoot, const T& value) {  Node* pCur=pRoot;  Node* P=NULL;  if(pCur==NULL)  {   return NULL;  }  if(value==pCur->_data)  {   P=pCur;  }  else  {   P=_Find(pCur->_pLeft,value);   if(P==NULL)    P=_Find(pCur->_pRight,value);  }  return P; }

以下是非递归算法：

非递归前序遍历算法：

 void _PreOrder_nor(Node* pRoot) {  stack<Node*> s;  Node* p=pRoot;  while(!s.empty()||p!=NULL)  {   while(p)   {    s.push(p);           cout<<p->_data<<"  ";    p=p->_pLeft;   }      p=s.top();   s.pop();   p=p->_pRight;  } }

非递归中遍历算法：

 //非递归中序遍历：访问左子树-->根-->右子树  void _InOrder_nor(Node* pRoot) {  stack<Node*> s;  Node* p=pRoot;  while(!s.empty()||p!=NULL)  {   while(p)   {    s.push(p);    p=p->_pLeft;   }      p=s.top();   s.pop();   cout<<p->_data<<"  ";   p=p->_pRight;  } }

非递归后序遍历算法：

 // 非递归后续遍历：访问左子树-->访问右子树-->访问根节点 void _PostOrder_nor(Node* pRoot) {  if(NULL==pRoot) //空树   return;  Node* PCur=pRoot; //当前结点为根节点  Node* Prev=NULL;  //已经访问的结点  stack<Node*> s;  while(!s.empty()||PCur)  {   while(PCur)    //把左孩子依次压栈   {    s.push(PCur);    PCur=PCur->_pLeft;   }    //当前结点为NULL   Node* top=s.top();  //指向栈顶   if(NULL==top->_pRight||Prev==top->_pRight)  //栈顶元素没有右孩子，或者右孩子已经被访问过   {    cout<<top->_data<<"";    Prev = top;   //已经访问的结点    s.pop();   }   else    PCur=top->_pRight;  } }