二叉树问题总结（一）

二叉树结构
struct BinaryTreeNode
{
int m_nValue;
BinaryTreeNode *m_pLeft;
BinaryTreeNode *m_pRight;
}

问题1：求二叉树节点个数

思路：递归实现
1.如果二叉树为空，节点个数为0,
2，如果二叉树不为空，二叉树节点=左子树节点+右子树节点+1

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

问题2：求二叉树的深度

思路：递归实现
1.如果二叉树为空，深度为0
2.如果二叉树不为空，深度为max(左子树深度，右子树深度)+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);
}

问题3：前序遍历，中序遍历，后序遍历二叉树
1.前序遍历递归法：
（1）如果二叉树为空，空操作
（2）如果二叉树不为空，访问根节点，前序遍历左子树，前序遍历右子树

void PreOrderTraverse(BianryTree* pRoot)
{
    if(pRoot == NULL)
        return;
    Visit(pRoot);//遍历根节点
    PreOrderTraverse(pRoot->m_pLeft);
    PreOrderTraverse(pRoot->m_pRight);
}

2.中序遍历递归法：
（1）如果根节点为空，空操作
（2）如果二叉树不为空，中序遍历左子树，访问根节点内，中序遍历右子树；

void InOrderTraverse(BinaryTreeNode *pRoot)
{
    if(pRoot == NULL)
        return;
    InOrderTraverse(pRoot->m_pLeft);
    Visit(pRoot);
    InOrderTraverse(pRoot->m_pRight);
}

3.后序遍历递归法：
（1）如果二叉树为空，空操作
（2）如果二叉树不为空，后序遍历左子树，后序遍历右子树，访问根节点

void PostOrderTraverse(BinaryTreeNode* pRoot)
{
    if(pRoot == NULL)
        return;
    PostOrderTraverse(pRoot->m_pLeft);
    PostOrderTraverse(pRoot->m_pRight);
    Visit(pRoot);
}

问题4：分层遍历二叉树（按层从上到下，从左到右）
思路：
相当于广度优先队列搜索，用堆栈来实现，队列初始化，将根节点的压入队列。当队列不为空，进行如下操作：
弹出一个节点，访问，若左子树或右子树不为空，将其压入队列

void LeverTraverse(BinaryTreeNode *pRoot)
{
    if(pRoot == NULL)
        return;
    queue<BianryTreeNode*> q;
    q.push_back(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_pRith);
    }
    return ;
}

问题5：打印二叉树中每层的节点（从左到右），其中根节点为第0层，成功返回1，失败返回0(递归实现)

int PrintNodeLevel(BianryTreeNode *pRoot,int level)
{   
    if(!pRoot || level<0)
        return 0;
    if(level==0)
    {
        cout<<pRoot->m_nValue<<" ";
        return 1;
    }
    return PrintNodeLevel(pRoot->m_pLeft,level-1)+PrintNodeLevel(pRoot->m_pRight,level-1);
}

void PrintNodeByLevel(BinaryTreeNode *pRoot,int depth)
{
    for(int i=0;i<depth;i++)
    {       
        PrintNodeLevel(pRoot,i);
        cout<<endl;
    }
}