二叉树--判断一棵二叉树是否是平衡二叉树&&求一颗二叉树的镜像

本文链接：https://blog.csdn.net/sayhello_world/article/details/76166203

判断一棵二叉树是否是平衡二叉树

平衡二叉树：此树中任意一个左右子树的高度差小于等于1
递归思路：

//求高度
size_t Height(BinaryTreeNode<T>* pRoot)
{
     if(pRoot == NULL)
          return 0;
     int LeftHeight = Height(pRoot->Left) + 1;
     int RightHeight = Height(pRoot->Right) + 1;
     return LeftHeight > RightRoot ? LeftHeight : RightHeight;
}

//对每个结点进行判断
bool IsBalance(BinaryTreeNode *pRoot)
{
     if(pRoot == NULL)
          return true;

     int leftHeight = Height(pRoot -> left);
     int  rightHeight = Height(pRoot -> right);
     int long = leftHeight - rightHeight;
     if(long <= 1 && long >= -1)
          return IsBalance(pRoot -> left)&&IsBalance(pRoot -> right);
     else
          return false;
}

求一颗二叉树的镜像

递归：
镜像就是左右子树互相交换,先交换此结点再交换此结点的左右孩子节点

void BinaryMirror(BinaryTreeNode<T>* pRoot)
{
          if(pRoot != NULL)
          {
               std::swap(pRoot -> left,pRoot -> right);
               BinaryMirror(pRoot -> left);
               BinaryMirror(pRoot -> right);
          }
}

非递归：
利用队列/栈实现

用队列：

//镜像 非递归 队列
//左右交换即可
BinaryTreeNode <T >* _BinaryMirror_Nor_q (BinaryTreeNode <T >* pRoot )
{
         if ( pRoot == NULL)
                 return NULL;
         queue< BinaryTreeNode <T >*>q ;
                 q. push( pRoot);
         while (! q. empty())
         {
                     BinaryTreeNode <T >* pCur = q .front ();
                     std:: swap( pCur-> _pLeftChild, pCur-> _pRightChild);
                     q. pop();
                     if ( pCur-> _pLeftChild)
                           q. push( pCur-> _pLeftChild);
                     if ( pCur-> _pRightChild)
                           q. push( pCur-> _pRightChild);
         }
       return pRoot;
 }

用栈：思想和队列一样都是左右交换这里不存在什么先压左还是先压右的问题因为就是结点子节点的左右交换

BinaryTreeNode <T >* _BinaryMirror_Nor_s (BinaryTreeNode <T >* pRoot )
{
         if ( pRoot == NULL)
                 return NULL;
         stack< BinaryTreeNode <T >*>s ;
                 s. push( pRoot);
         while (! s. empty())
         {
                     BinaryTreeNode <T >* pCur = s .top ();
                     std:: swap( pCur-> _pLeftChild, pCur-> _pRightChild);
                     s. pop();
                     if ( pCur-> _pLeftChild)
                           s. push( pCur-> _pLeftChild);
                     if ( pCur-> _pRightChild)
                           s. push( pCur-> _pRightChild);
         }
       return pRoot;
 }