二叉树的相关题目

目录

1、求二叉树的遍历顺序为自下至上，自右至左的层序遍历序列

2、判断二叉树是否为完全二叉树

3、统计二叉树中双分支结点的个数

4、求先序遍历序列中第k个结点的值

5、求二叉树的高度

6、判断二叉树是否为二叉排序树

7、求出二叉排序树中结点所在的层数

---

1、求二叉树的遍历顺序为自下至上，自右至左的层序遍历序列

算法思想：使用层序遍历。二叉树正常的层序遍历顺序是自上至下，自左向右的顺序，与题目要求刚好相反，使用一个栈，将正常的层序遍历序列取逆即可。

void levelOrder(BiTree bt)
{   //非递归层序遍历
    if(bt == NULL)
        return;
    InitStack(s);
    InitQueue(Q);
    BiTree p = bt;
    EnQueue(Q,p);
    while(!IsEmpty(Q))
    {
        DeQueue(Q,p);
        //visit(p);
        push(s,p);
        if(p-lchild)
            EnQueue(Q,p->lchild);
        if(p-rchild)
            EnQueue(Q,p->rchild);
        
    }//while    
     
    while(!IsEmpty(s))
    {
         pop(s,p);
         visit(p);   
    }//while

}//void

2、判断二叉树是否为完全二叉树

算法思想：使用层序遍历。将结点全部入队，空结点也需要入队。当遇到空结点时，就查看队中剩余结点是否有非空结点，若有，则该二叉树不是完全二叉树，若无，则是完全二叉树。

bool levelOrder(BiTree bt)
{   //非递归层序遍历
    if(bt == NULL)
        return true; //空树为完全二叉树
    InitQueue(Q);
    BiTree p = bt;
    EnQueue(Q,p);
    while(!IsEmpty(Q))
    {
        DeQueue(Q,p);
        if(p)
        {
            EnQueue(Q,p->lchild);
            EnQueue(Q,p->rchild);
        }
        else{
             while(!IsEmpty(Q)) 
             {
                Dequeue(Q,p);
                if(p)
                    return false;
             }
        }//else

    }//while 
  
    return true; 

}//void

3、统计二叉树中双分支结点的个数

递归

算法思想：

int  DsonNodes(BiTree bt)
{
    if(bt == NULL)
        return 0;
    else if(bt-lchild!=NULL && bt->rchild!=NULL)
        return DsonNodes(bt->lchild)+DsonNodes(bt->rchild)+1;
    else
        return DsonNodes(bt->lchild)+DsonNodes(bt>rchild);
}

非递归

算法思想：使用层序遍历。设置一个变量，用来记录双分支结点的个数。判断双分支节点就是判断左右子树是否为空，当遇到一个双分支结点时，使该变量加一，遍历结束时返回该变量即可。

int DsonNodes(BiTree bt)
{   //非递归层序遍历
    if(bt == NULL)
        return 0;
    int count = 0; //二叉树双分支结点个数
    InitQueue(Q);
    BiTree p = bt;
    EnQueue(Q,p);
    while(!IsEmpty(Q))
    {
        DeQueue(Q,p);
        //visit(p);
        if(p->lchild)
            EnQueue(Q,p->lchild);
        if(p->rchild)
            EnQueue(Q,p->rchild);
        if(p->lchild && p->rchild)//是否为双分支结点
            count ++;
    }//while    
    
    return count;
}//void

4、求先序遍历序列中第k个结点的值

递归

算法思想：先序递归遍历，设置一个全局变量，记录当前结点的序号，当访问到第k个结点时，返回该结点的值。。

int i = 1;
elemType preNode(BiTree bt, int k)
{
    if(b == NULL)
        return "#"
    if(i == k)
        return b->data;
    i++;
    ch = preNode(b->lchild,k);
    if(ch != "#")
        return ch;
    ch = preNode(b->rchild,k);
    return ch;
}

非递归

算法思想：使用先序遍历。设置一个变量，用来记录当前访问的结点序号，当访问到第k个结点时，返回该结点的值。

elemType preOrder2(BiTree bt, int k)
{   //非递归前序遍历
    if(bt == NULL || k <= 0)
        return " ";
    int n = 0;
    InitStack(s);
    BiTree p = bt;
    push(s,p);
    while(!IsEmpty(s))
    {
        pop(s,p);
        //visit(p);
        n++;
        if(n == k)
            return p->data;
        if(p->rchild)
            push(s,p->rchild);//需要注意的是，这里先让右孩子进栈，因为栈是后进先出
        if(p->lchild)
            push(s,p->lchild);
 
    }//while
    return " ";//k大于二叉树中结点个数时，返回" ";
}//void

5、求二叉树的高度

递归

算法思想：如果树为空，则返回0。否则，递归计算左子树右子树的高度，然后比较左右子树的高度，返回高度较大值加一。

int BTdepth(BiTree bt)
{
    if(bt == NULL)
        return 0;
    ldep = BTdepth(bt->lchild);
    rdep = BTdepth(bt->rchild);
    if(ldep > rdep)
        return ldep+1;
    else
        return rdep+1;
}

非递归

算法思想：使用层序遍历。设置变量level用来记录当前结点所在的层数，设置变量last用来记录当前层最右结点，每次层序遍历出队时与last指针比较，若相等，则层数加一，并让last指向下一层的最右节点。直到遍历结束，返回变量level。

int BTdepth2(BiTree bt)
{
    if(!bt)
        return 0;
    int front = -1, rear = -1;
    int last = 0, level = 0;
    BiTree Q[maxSize];
    Q[rear++] = bt;
    BiTree p;
    while(front < rear){
        p = Q[++front];
        if(p->lchild)
            Q[++rear] = p->lchild;
        if(p->rchild)
            Q[++rear] = p->rchild;
        if(front == last)
        {
            level ++;
            last == rear;
        }
    }//while
    return level;

}//void

6、判断二叉树是否为二叉排序树

算法思想：对二叉树进行中序遍历，若能始终保持前一个数比后一个数小，则说明是二叉排序树。

递归

KeyType predt = -32767;

int JudgeBST(BiTree bt)
{
    int b1, b2;
    if(bt == NULL)
        return 1;
    else{
        b1 = JudgeBST(bt->lchild);
        if(b1 == 0 || predt >= bt->data)
            return 0;
        predt = bt->data;
        b2 = JudgeBST(bt->rchild);
        return b2;
    }//else
    
}//int 

非递归

bool JudgeBST(BiTree bt)
{
    if(!bt)
        return true;
    InitStack(s);
    InitQueue(Q);
    while(p||!IsEmpty(s)){
        if(p)
        {
            push(s,p);
            p = p->lchild;
        }
        else{
            pop(s,p);
            EnQueue(Q,p);
            p = p->rchild;
        }
    }//while
    DeQueue(Q,temp);
    while(!IsEmpty(Q)){
        DeQueue(Q,p);
        if(p->data > temp->data){
            temp = p;
        }
        else
            return false;
    }//while
    return true;   
}//bool

7、求出二叉排序树中结点所在的层数

算法思想：与二叉排序树的查找很像，只是需要加一个变量记录当前结点的层数。

int level(BiTree bt, BSTNode *p)
{
    if(bt == NULL)
        return -1;
    int n=1;
    BiTree t = bt;
    while(t->data!=p->data){
        if(t->data < p->data)
            t = t->lchild;
        else
            t = t->rchild;
        n++;
    }
    return n;
}