二叉树相关笔试面试题（一）

本博客内容
一、二叉树的结构
二、求二叉树中节点个数
三、求二叉树的第k层的节点个数
四、求二叉树的叶子节点的个数
五、求二叉树的深度
六、二叉树的遍历（前序、中序、后序）
七、层序遍历二叉树（从上到下、从左到右）
八、将二叉搜索树变为有序的双向链表（要求：不创建新节点，只调整指针）
九、判断二叉树是否相同
十、判断二叉树是否是平衡二叉树

一、二叉树的结构

struct BinaryTreeNode
{
    int m_nValue;
    BinaryTreeNode * m_pLeft;
    BinaryTreeNode * m_pRight;
};

二、求二叉树中节点个数

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

三、求二叉树的第k层的节点个数

//递归求解
int GetNumKthLevel(BinaryTreeNode *pRoot,int k)
{
    if(pRoot==NULL||k<1)
        return 0;
    if(k==1)
        return 1;
    int numLeft=GetNumKthLevel(pRoot->m_pLeft,k-1);
    int numRight=GetNumKthLevel(pRoot->m_pRight,k-1);
    return (numLeft+numRight);
}

四、求二叉树的叶子节点的个数

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;
}   

五、求二叉树的深度

unsigned int GetDepth(BinaryTreeNode * pRoot)
{
    if(pRoot==NULL)
        return 0;
    int left=0,right=0;
    left=GetDepth(pRoot->m_pLeft);
    right=GetDepth(pRoot->m_pRight);
    return left>right?left+1:right+1;
}

六、二叉树的遍历（前序、中序、后序）

void visit(BinaryTreeNode * pRoot)
{
    printf("%d",pRoot->m_nValue);
}
//前序
void PreOrderTraverse(BinaryTreeNode * pRoot)
{
    if(pRoot==NULL)
        return ;
    visit(pRoot);
    PreOrderTraverse(pRoot->m_pLeft);
    PreOrderTraverse(pRoot->m_pRight);
}
//中序
void InOrderTraverse(BinaryTreeNode * pRoot)
{
    if(pRoot==NULL)
        return ;
    InOrderTraverse(pRoot->m_pLeft);
    visit(pRoot);
    InOrderTraverse(pRoot->m_pRight);
}
//后序
void PostOrderTraverse(BinaryTreeNode * pRoot)
{
    if(pRoot==NULL)
        return ;
    PostOrderTraverse(pRoot->m_pLeft);
    PostOrderTraverse(pRoot->m_pRight);
    visit(pRoot);
}

七、层序遍历二叉树（从上到下、从左到右）

①利用队列实现

void LevelTraverse(BinaryTreeNode * pRoot)
{
    if(pRoot==NULL)
        return ;
    queue<BinaryTreeNode * > que;
    que.push(pRoot);
    while(!que.empty())
    {
        BinaryTreeNode  * temp=que.front();
        visit(temp);
        que.pop();
        if(temp->m_pLeft)
            que.push(temp->m_pLeft);
        if(temp->m_pRight)
            que.push(temp->m_pRight);
    }
    return ;
}

②按层打印二叉树（将每一层保存到vector中）

vector<vector<int> > Print(BinaryTreeNode * pRoot)
{
    vector<vector<int> > result;
    vector<int>temp;
    queue<BinaryTreeNode * > que;    //需要一个队列
    if(pRoot==NULL)
        return result;
        que.push(pRoot);
    int nextLevel=0;  //记录层数
    int toBeDeleted=1;  //记录当前待删除的个数
    while(!que.empty())
    {
        BinaryTreeNode *pNode=que.front();
        temp.push_back(pNode->m_nValue);
        if(pNode->m_pLeft)
            {
                que.push(pNode->m_pLeft);
                nextLevel++;    //nextLevel来记录本行需要打印几个值
            }
        if(pNode->m_pRight)
            {
                que.push(pNode->m_pRight);
                nextLevel++;
            }
        que.pop();
        --toBeDeleted;
        if(toBeDeleted==0)
        {
            result.push_back(temp);
            temp.clear();
            toBeDeleted=nextLevel;
            nextLevel=0;
        }
        return result;
    }
}

八、将二叉搜索树变为有序的双向链表（要求：不创建新节点，只调整指针）

//借助vector和中序遍历
vector<BinaryTreeNode *>temp;
void InOrderTraverseNode(BinaryTreeNode * pRoot)
{
    if(pRoot==NULL)
        return;
    InOrderTraverseNode(pRoot->m_pLeft);
    temp.push_back(pRoot);
    InOrderTraverseNode(pRoot->m_pRight);
}
void ConvertBinaryTreeNodeToDoubleList(BinaryTreeNode * pRoot)
{
    if(pRoot==NULL)
        retrun ;
    InOrderTraverseNode(pRoot);//中序遍历，将值保存到vector中
    for(int i=0;i<temp.size()-1;++i)
        temp[i]->m_pRight=temp[i+1];
    temp[temp.size()-1]->m_pRight=NULL; //最后一个右节点指向为空
    for(int j=temp.size()-1;j>0;j--)
        temp[j]->m_pLeft=temp[j-1];
    temp[0]->m_pLeft=NULL;
}

九、判断二叉树是否相同

bool StructureCmp(BinaryTreeNode *pRoot1,BinaryTreeNode *pRoot2)
{
    if(pRoot1==NULL&&pRoot2==NULL)
        return true;
    if(pRoot1===NULL || pRoot2==NULL)
        return false;
     bool left=StructureCmp(pRoot1->m_pLeft,pRoot2->m_pLeft);                   
     bool right=StructureCmp(pRoot1->m_pRight,pRoot2->m_pRight);
     return left &&right;
 }

十、判断二叉树是否是平衡二叉树

bool IsAVL(BinaryTreeNode * pRoot, int & height)
{
    if(pRoot==NULL)
    {
        height=0;
        return true;
    }
    int left,right;
    bool resultleft=IsAVL(pRoot->m_pLeft,left);
    bool resultright=IsAVL(pRoot->m_pRight,right);
    if(resultleft&&resultright&&abs(left-right)<=1)
        {
            height=max(left,right)+1;
            return true;
        }
    else
        {
            height=max(left,right)+1;
            return false;
        }
}

参考了牛客网和其他大神的博客，如有错误，请大家批评指正，谢谢，未完待续….