二叉树相关题目

1、求二叉树深度

int GetDepth(BinaryTreeNode * pRoot)
{
 if(pRoot == NULL) // 递归出口
  return 0;
 int depthLeft = GetDepth(pRoot->m_pLeft);
 int depthRight = GetDepth(pRoot->m_pRight);
 return depthLeft > depthRight ? (depthLeft + 1) : (depthRight + 1); 
}

2、求二叉树总节点数

int GetNodeNum(BinaryTreeNode * pRoot)
{
 if(pRoot == NULL) // 递归出口
  return 0;
 return GetNodeNum(pRoot->m_pLeft) + GetNodeNum(pRoot->m_pRight) + 1;
}

3、求二叉树叶子数

int GetLeafNodeNum(BinaryTreeNode * pRoot)
{
 if(pRoot == NULL)
  return 0;
 if(pRoot->m_pLeft == NULL && pRoot->m_pRight == NULL)
  return 1;
 int numLeft = GetLeafNodeNum(pRoot->m_pLeft); // 左子树中叶节点的个数
 int numRight = GetLeafNodeNum(pRoot->m_pRight); // 右子树中叶节点的个数
 return (numLeft + numRight);
}

4、求k层节点个数

int GetNodeNumKthLevel(BinaryTreeNode * pRoot, int k)
{
 if(pRoot == NULL || k < 1)
  return 0;
 if(k == 1)
  return 1;
 int numLeft = GetNodeNumKthLevel(pRoot->m_pLeft, k-1); // 左子树中k-1层的节点个数
 int numRight = GetNodeNumKthLevel(pRoot->m_pRight, k-1); // 右子树中k-1层的节点个数
 return (numLeft + numRight);
}

5、二叉树遍历（前序遍历）

void PreOrderTraverse(BinaryTreeNode * pRoot)
{
 if(pRoot == NULL)
  return;
 Visit(pRoot); // 访问根节点
 PreOrderTraverse(pRoot->m_pLeft); // 前序遍历左子树
 PreOrderTraverse(pRoot->m_pRight); // 前序遍历右子树
}

6、分层遍历

void LevelTraverse(BinaryTreeNode * pRoot)
{
 if(pRoot == NULL)
  return;
 queue<BinaryTreeNode *> q;
 q.push(pRoot);
 while(!q.empty())
 {
  BinaryTreeNode * pNode = q.front();
  q.pop();
  Visit(pNode); // 访问节点
  if(pNode->m_pLeft != NULL)
   q.push(pNode->m_pLeft);
  if(pNode->m_pRight != NULL)
   q.push(pNode->m_pRight);
 }
 return;
}

7、求二叉树镜像

BinaryTreeNode * Mirror(BinaryTreeNode * pRoot)
{
 if(pRoot == NULL) // 返回NULL
  return NULL;
 BinaryTreeNode * pLeft = Mirror(pRoot->m_pLeft); // 求左子树镜像
 BinaryTreeNode * pRight = Mirror(pRoot->m_pRight); // 求右子树镜像
 // 交换左子树和右子树
 pRoot->m_pLeft = pRight;
 pRoot->m_pRight = pLeft;
 return pRoot;
}

8、判断两棵二叉树结构是否相同

bool StructureCmp(BinaryTreeNode * pRoot1, BinaryTreeNode * pRoot2)
{
 if(pRoot1 == NULL && pRoot2 == NULL) // 都为空，返回真
  return true;
 else if(pRoot1 == NULL || pRoot2 == NULL) // 有一个为空，一个不为空，返回假
  return false;
 bool resultLeft = StructureCmp(pRoot1->m_pLeft, pRoot2->m_pLeft); // 比较对应左子树 
 bool resultRight = StructureCmp(pRoot1->m_pRight, pRoot2->m_pRight); // 比较对应右子树
 return (resultLeft && resultRight);
}

9、判断二叉树是不是平衡二叉树

bool IsAVL(BinaryTreeNode * pRoot, int & height)
{
 if(pRoot == NULL) // 空树，返回真
 {
  height = 0;
  return true;
 }
 int heightLeft;
 bool resultLeft = IsAVL(pRoot->m_pLeft, heightLeft);
 int heightRight;
 bool resultRight = IsAVL(pRoot->m_pRight, heightRight);
 if(resultLeft && resultRight && abs(heightLeft - heightRight) <= 1) // 左子树和右子树都是AVL，并且高度相差不大于1，返回真
 {
  height = max(heightLeft, heightRight) + 1;
  return true;
 }
 else
 {
  height = max(heightLeft, heightRight) + 1;
  return false;
 }
}

10、由前序遍历序列和中序遍历序列重建二叉树

BinaryTreeNode * RebuildBinaryTree(int* pPreOrder, int* pInOrder, int nodeNum)
{
 if(pPreOrder == NULL || pInOrder == NULL || nodeNum <= 0)
  return NULL;
 BinaryTreeNode * pRoot = new BinaryTreeNode;
 // 前序遍历的第一个数据就是根节点数据
 pRoot->m_nValue = pPreOrder[0];
 pRoot->m_pLeft = NULL;
 pRoot->m_pRight = NULL;
 // 查找根节点在中序遍历中的位置，中序遍历中，根节点左边为左子树，右边为右子树
 int rootPositionInOrder = -1;
 for(int i = 0; i < nodeNum; i++)
  if(pInOrder[i] == pRoot->m_nValue)
  {
   rootPositionInOrder = i;
   break;
  }
 if(rootPositionInOrder == -1)
 {
  throw std::exception("Invalid input.");
 }
 // 重建左子树
 int nodeNumLeft = rootPositionInOrder;
 int * pPreOrderLeft = pPreOrder + 1;
 int * pInOrderLeft = pInOrder;
 pRoot->m_pLeft = RebuildBinaryTree(pPreOrderLeft, pInOrderLeft, nodeNumLeft);
 // 重建右子树
 int nodeNumRight = nodeNum - nodeNumLeft - 1;
 int * pPreOrderRight = pPreOrder + 1 + nodeNumLeft;
 int * pInOrderRight = pInOrder + nodeNumLeft + 1;
 pRoot->m_pRight = RebuildBinaryTree(pPreOrderRight, pInOrderRight, nodeNumRight);
 return pRoot;
}