第4章第1节练习题3 二叉树特殊节点个数统计

最新推荐文章于 2021-11-13 22:48:04 发布
最新推荐文章于 2021-11-13 22:48:04 发布
阅读量3.2k 收藏 6
点赞数 3
分类专栏： Data Structure 数据结构与算法 文章标签： 数据结构 算法 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013595419/article/details/51707858
版权

为了方便说明二叉树的递归传值过程，这里首先给出一个基本的二叉树结构。

二叉树

图中值为NULL的节点实际是不存在的，故与父亲节点之间的连接用灰色的虚线表示。只是为了便于说明，才假设了一个NULL的空节点。
以下图中，黄色的线表明了传值的方向；绿色的数值表明了子节点传到父亲节点时的值，即根据递归公式计算便可。

一.统计二叉树中度为0的节点个数（递归/非递归）

递归方式实现

二叉树中，度为0则表明该节点的左孩子、右孩子均为空，根据二叉树的特性，最容易想到的便是采用递归方式实现该答案。首先列出基本递归公式：

f(T)=⎧⎩⎨0,f(T−>lchild)+f(T−>rchild)+1,f(T−>lchild)+f(T−>rchild),若T=NULL若T为叶子节点其他情况，若T为单分支节点，或双分支节点

然后可以参考下图

叶子节点

当指针遍历到叶子节点的子节点（NULL节点）时，向父节点返回一个0，又因为该节点是本次遍历需要统计的节点，然后再向父节点返回的时候+1，这样便完成了一次简单的统计，然后再由父节点的父节点对其“汇总”一次，不断的向上递归传值，便完成了叶子节点的统计。

算法描述如下

int CntLfNode_recursive(BiTNode* T){
    if(T==NULL){
        return 0;
    }
    if(T->lchild==NULL&&T->rchild==NULL){
        return CntLfNode_recursive(T->lchild)+CntLfNode_recursive(T->rchild)+1;
    }else{
        return CntLfNode_recursive(T->lchild)+CntLfNode_recursive(T->rchild);
    }
}

非递归方式实现

非递归方式的实现就比较容易理解了，只需要使用第4章第3节 二叉树的基本操作（非递归实现）中给到的遍历二叉树的方法，在访问节点时，判断下该节点的度是否为0：如果是0，则对其计数；如果不是，跳过便可。

这里便主体使用层次遍历方式实现，后对叶子节点进行计数，返回该数目。

int CntLfNode_norecursive(BiTNode* T){
    BiTNode* p=T;
    SqQueue Q;

    InitQueue(&Q);
    EnQueue(&Q,p);

    int cnt=0;
    while(IsEmptyQueue(&Q)!=0){
        p=DeQueue(&Q);
        if(p->lchild==NULL&&p->rchild==NULL){
            cnt++;
        }
        if(p->lchild!=NULL){
            EnQueue(&Q,p->lchild);
        }
        if(p->rchild!=NULL){
            EnQueue(&Q,p->rchild);
        }
    }
    return cnt;
}

二.统计二叉树中度为1的节点个数（递归/非递归）

递归方式实现

统计度为1的节点的递归实现方式与统计度为0的类似，首先列出基本递归公式：

f(T)=⎧⎩⎨0,f(T−>lchild)+f(T−>rchild)+1,f(T−>lchild)+f(T−>rchild),若T=NULL或T为叶子节点若T为单分支节点其他情况，若T为双分支节点

然后可以参考下图

单分支节点

统计度为1的节点的传值过程与度为0的节点的传值过程类似，只是本次统计的是单分支节点而已，然后对此节点向父节点的传值的时候+1便可。

算法描述如下

int CntDONode_recursive(BiTNode* T){
    if(T==NULL||(T->lchild==NULL&&T->rchild==NULL)){
        return 0;
    }else if((T->lchild!=NULL&&T->rchild==NULL)||(T->lchild==NULL&&T->rchild!=NULL)){
        return CntDONode_recursive(T->lchild)+CntDONode_recursive(T->rchild)+1;
    }else{
        return CntDONode_recursive(T->lchild)+CntDONode_recursive(T->rchild);
    }
}

非递归方式实现

非递归方式的实现方式与统计度为0的节点方式类似，在访问节点时，判断下该节点的度是否为1：如果是1，则对其计数；如果不是，跳过便可。

这里同样主体使用层次遍历方式实现，后对单分支节点进行计数，返回该数目。

int CntDONode_norecursive(BiTNode* T){
    BiTNode* p=T;
    SqQueue Q;

    InitQueue(&Q);
    EnQueue(&Q,p);

    int cnt=0;
    while(IsEmptyQueue(&Q)!=0){
        p=DeQueue(&Q);
        if((p->lchild!=NULL&&p->rchild==NULL)||(p->lchild==NULL&&p->rchild!=NULL)){
            cnt++;
        }
        if(p->lchild!=NULL){
            EnQueue(&Q,p->lchild);
        }
        if(p->rchild!=NULL){
            EnQueue(&Q,p->rchild);
        }
    }
    return cnt;
}

三.统计二叉树中度为2的节点个数（递归/非递归）

递归方式实现

统计度为2的节点的递归实现方式与统计度为1或度为0的方式类似，首先列出基本递归公式：

f(T)=⎧⎩⎨0,f(T−>lchild)+f(T−>rchild)+1,f(T−>lchild)+f(T−>rchild),若T=NULL若T为双分支节点其他情况，若T为单分支节点，或叶子节点

然后可以参考下图

双分支节点

与统计度为0和度为1的传值过程类似，只是需要统计的是双分支节点而已，在传值的时候，需要对双分支节点特殊处理，其他一样。

算法描述如下

int CntDTNode_recursive(BiTNode* T){
    if(T==NULL){
        return 0;
    }
    if(T->lchild!=NULL&&T->rchild!=NULL){
        return CntDTNode_recursive(T->lchild)+CntDTNode_recursive(T->rchild)+1;
    }else{
        return CntDTNode_recursive(T->lchild)+CntDTNode_recursive(T->rchild);
    }
}

非递归方式实现

与度为0和度为1的节点统计方式类似，在访问节点时，判断下该节点的度是否为2：如果是2，则对其计数；如果不是，跳过便可。

同样主体使用层次遍历方式实现，后对双分支节点进行计数，返回该数目。

int CntDTNode_norecursive(BiTNode* T){
    BiTNode* p=T;
    SqQueue Q;

    InitQueue(&Q);
    EnQueue(&Q,p);

    int cnt=0;
    while(IsEmptyQueue(&Q)!=0){
        p=DeQueue(&Q);
        if(p->lchild!=NULL&&p->rchild!=NULL){
            cnt++;
        }
        if(p->lchild!=NULL){
            EnQueue(&Q,p->lchild);
        }
        if(p->rchild!=NULL){
            EnQueue(&Q,p->rchild);
        }
    }
    return cnt;
}

具体代码见附件。

附件

//AB#DG###CE##F##
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 10
typedef char ElemType;
typedef struct BiTNode{
    ElemType data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

typedef struct{
    BiTNode* data[MaxSize];
    int front, rear;
}SqQueue;

BiTNode* CreateBiTree(BiTNode*);

void InitQueue(SqQueue*);
void EnQueue(SqQueue*,BiTNode*);
BiTNode* DeQueue(SqQueue*);
int IsEmptyQueue(SqQueue*);

void PreOrder(BiTNode*);
void InOrder(BiTNode*);


int CntLfNode_recursive(BiTNode*);
int CntLfNode_norecursive(BiTNode*);
int CntDONode_recursive(BiTNode*);
int CntDONode_norecursive(BiTNode*);
int CntDTNode_recursive(BiTNode*);
int CntDTNode_norecursive(BiTNode*);

int main(int argc, char* argv[]){
    BiTNode* T=(BiTNode*)malloc(sizeof(BiTNode));
    T=CreateBiTree(T);

    PreOrder(T);printf("\n");
    InOrder(T);printf("\n");

    int count_lf;
    count_lf=CntLfNode_recursive(T);
    printf("recursive:The count of leaf node is %d\n",count_lf);
    count_lf=CntLfNode_norecursive(T);
    printf("non-recursive:The count of leaf node is %d\n",count_lf);

    int count_do;
    count_do=CntDONode_recursive(T);
    printf("recursive:The count of node of degree one is %d\n",count_do);
    count_do=CntDONode_norecursive(T);
    printf("non-recursive:The count of degree one node is %d\n",count_do);

    int count_dt;
    count_dt=CntDTNode_recursive(T);
    printf("recursive:The count of degree two node is %d\n",count_dt);
    count_dt=CntDTNode_norecursive(T);
    printf("non-recursive:The count of degree two node is %d\n",count_dt);

    return 0;
}

//-------------------------------------------------------------------------------------

BiTNode* CreateBiTree(BiTNode* T){
    ElemType ch;
    scanf("%c",&ch);
    if(ch=='#'){
        return NULL;
    }
    T=(BiTNode*)malloc(sizeof(BiTNode));
    T->data=ch;
    T->lchild=CreateBiTree(T->lchild);
    T->rchild=CreateBiTree(T->rchild);
    return T;
}

//-------------------------------------------------------------------------------------

//统计二叉树中度为0的节点个数（递归）
int CntLfNode_recursive(BiTNode* T){
    if(T==NULL){
        return 0;
    }
    if(T->lchild==NULL&&T->rchild==NULL){
        return CntLfNode_recursive(T->lchild)+CntLfNode_recursive(T->rchild)+1;
    }else{
        return CntLfNode_recursive(T->lchild)+CntLfNode_recursive(T->rchild);
    }
}

//统计二叉树中度为0的节点个数（非递归）
int CntLfNode_norecursive(BiTNode* T){
    BiTNode* p=T;
    SqQueue Q;

    InitQueue(&Q);
    EnQueue(&Q,p);

    int cnt=0;
    while(IsEmptyQueue(&Q)!=0){
        p=DeQueue(&Q);
        if(p->lchild==NULL&&p->rchild==NULL){
            cnt++;
        }
        if(p->lchild!=NULL){
            EnQueue(&Q,p->lchild);
        }
        if(p->rchild!=NULL){
            EnQueue(&Q,p->rchild);
        }
    }
    return cnt;
}

//-------------------------------------------------------------------------------------

//统计二叉树中度为1的节点个数（递归）
int CntDONode_recursive(BiTNode* T){
    if(T==NULL||(T->lchild==NULL&&T->rchild==NULL)){
        return 0;
    }else if((T->lchild!=NULL&&T->rchild==NULL)||(T->lchild==NULL&&T->rchild!=NULL)){
        return CntDONode_recursive(T->lchild)+CntDONode_recursive(T->rchild)+1;
    }else{
        return CntDONode_recursive(T->lchild)+CntDONode_recursive(T->rchild);
    }
}

//统计二叉树中度为1的节点个数（非递归）
int CntDONode_norecursive(BiTNode* T){
    BiTNode* p=T;
    SqQueue Q;

    InitQueue(&Q);
    EnQueue(&Q,p);

    int cnt=0;
    while(IsEmptyQueue(&Q)!=0){
        p=DeQueue(&Q);
        if((p->lchild!=NULL&&p->rchild==NULL)||(p->lchild==NULL&&p->rchild!=NULL)){
            cnt++;
        }
        if(p->lchild!=NULL){
            EnQueue(&Q,p->lchild);
        }
        if(p->rchild!=NULL){
            EnQueue(&Q,p->rchild);
        }
    }
    return cnt;
}

//-------------------------------------------------------------------------------------

//统计二叉树中度为2的节点个数（递归）
int CntDTNode_recursive(BiTNode* T){
    if(T==NULL){
        return 0;
    }
    if(T->lchild!=NULL&&T->rchild!=NULL){
        return CntDTNode_recursive(T->lchild)+CntDTNode_recursive(T->rchild)+1;
    }else{
        return CntDTNode_recursive(T->lchild)+CntDTNode_recursive(T->rchild);
    }
}

//统计二叉树中度为2的节点个数（非递归）
int CntDTNode_norecursive(BiTNode* T){
    BiTNode* p=T;
    SqQueue Q;

    InitQueue(&Q);
    EnQueue(&Q,p);

    int cnt=0;
    while(IsEmptyQueue(&Q)!=0){
        p=DeQueue(&Q);
        if(p->lchild!=NULL&&p->rchild!=NULL){
            cnt++;
        }
        if(p->lchild!=NULL){
            EnQueue(&Q,p->lchild);
        }
        if(p->rchild!=NULL){
            EnQueue(&Q,p->rchild);
        }
    }
    return cnt;
}

//-------------------------------------------------------------------------------------

//先序遍历
void PreOrder(BiTNode* T){
    if(T==NULL){
        return;
    }
    printf("%c",T->data);
    PreOrder(T->lchild);
    PreOrder(T->rchild);
}

//中序遍历
void InOrder(BiTNode* T){
    if(T==NULL){
        return;
    }
    InOrder(T->lchild);
    printf("%c",T->data);
    InOrder(T->rchild);
}

//-------------------------------------------------------------------------------------

//队列的基本操作

void InitQueue(SqQueue* Q){
    Q->front=0;
    Q->rear=0;
}

void EnQueue(SqQueue* Q, BiTNode* T){
    if((Q->rear+1)%MaxSize==Q->front){
        return;
    }
    Q->data[Q->rear++]=T;
}

BiTNode* DeQueue(SqQueue* Q){
    if(Q->front==Q->rear){
        return NULL;
    }
    return Q->data[Q->front++];
}

int IsEmptyQueue(SqQueue* Q){
    if(Q->rear==Q->front){
        return 0;
    }else{
        return -1;
    }
}
法海你懂不
关注
专栏目录
二叉树练习题之计算二叉树的节点个数
kosokahonoka的博客
09-11 161
二叉树练习1
算法习题11：求二叉树中节点的最大距离
ylf13的专栏
10-15 849
求二叉树中节点的最大距离... 如果我们把二叉树看成一个图， 父子节点之间的连线看成是双向的， 我们姑且定义"距离"为两节点之间边的个数。 写一个程序， 求一棵二叉树中相距最远的两个节点之间的距离。 --------------------------------- 其实遇到这种二叉树问题，最先想到的办法应该是遍历，先序 后序 中序  总之这种遍历能够得到你想要的各种信息！！
设一棵二叉树以二叉链表表示，试编写有关二叉树的递归算法
11-22
设一棵二叉树以二叉链表表示，试编写有关二叉树的递归算法
数据结构 - 统计二叉树度为0/1/2的结点个数（递归）
TKK的博客
11-13 4696
数据结构 - 统计二叉树度为0/1/2的结点个数（递归） 文章目录数据结构 - 统计二叉树度为0/1/2的结点个数（递归）0. 变量/函数声明树的结构体函数声明1. 统计结点数统计度为0的结点数统计度为1的结点数统计度为2的结点数2. 运行情况INPUTOUTPUT 0. 变量/函数声明 树的结构体 #define ElemType int typedef struct BiTNode { ElemType data; // 数据域 struct BiTNode *l_child, *r_
递归统计二叉树中右孩子的个数
qq_51187952的博客
03-31 3932
递归统计二叉树中右孩子的个数 本题要求采用递归方式统计二叉树中右孩子结点的个数 函数接口定义： 在这里描述函数接口。例如： int CountRightNode(BinTree bt); 其中bt是待统计的二叉树，函数返回右孩子结点的个数 裁判测试程序样例： #include <stdio.h> #include <stdlib.h> typedef char DataType; typedef struct BTreeNode { DataType d...
二叉树结点的计算
jm135的专栏
12-09 5284
某二叉树的前序遍历结点访问顺序是abdgcefh，中序遍历的结点访问顺序是dgbaechf，则后序遍历的结点访问顺序是（gdbehfca） 首先我们知道，前序遍历的规则是：根结点→左子结点→右子结点 中序遍历是：左子结点→根结点→右子结点 后序遍历是：左子结点→右子结点→根结点 那么，对于一棵二叉树，前序遍历的第一个结点一定是这棵树的根结点，即根结点是a。 在中序遍历的顺序dgbaechf中，以a分成左、右两边，左边是dgb，右边是echf。 所以，这棵树现在可以确定如下：       a
第六章 树和二叉树习题1
最新发布
03-20
6. 二叉树的节点个数与深度的关系并不总是2k-1-1。例如，高度为1的二叉树只有一个节点，不是2k-1-1。 7. 二叉树中，不存在非空左子树并不意味着不存在非空右子树，反之亦然。比如，单支二叉树只有一个子节点，可以...
数据结构（C语言版） 第五章 树与二叉树 知识梳理 + 作业习题详解1
08-04
3. 完全二叉树的叶子节点数n0与2度节点数n2的关系是n0 = n2 + 1。 完全二叉树是所有层都尽可能填满的二叉树，除了最后一层。若二叉树有5000个节点，那么根据性质3，其叶子节点的个数为2500。 二叉树的存储方式有两...
二叉树练习题及答案.docx
12-05
二叉树是一种特殊的树结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树的度是指节点的最大子节点数，因此二叉树的度可以是0（叶节点）、1（只有一个子节点）、或2（有两个子节点）。在二叉树的...
Java程序设计与数据结构第六章习题答案
11-05
二叉树是树的一种特殊形式，每个节点最多有两个子节点。Java的TreeSet和TreeMap类基于红黑树实现，是学习树结构的好例子。此外，AVL树和B树等平衡树的概念也是重要知识点。 5. **图**：图由顶点和边组成，可以表示...
数据结构 第五章 树与二叉树 习题
AnthonyM08的博客
11-08 1992
@TOC 5.1 树的基本概念 定义 在任意一棵非空树中应满足： 1）有且仅有一个特定的称为根的结点。 2）当n>1n>1n>1时，其余节点可分为mmm个互不相交的有限集T1T2...TmT_1T_2...T_mT1​T2​...Tm​，其中每个集合本身又是一棵树，称为根的子树。 特点 树是一种递归的数据结构。 1）树的根结点没有前驱，除根节点外的所有结点有且只有一个前驱。 2）树中所有结点可以有零个或多个后继。 树适合表示有层次的数据结构，某个结点（除根节点外）最多只和其父节点有直接关系
求二叉树某一节点出现次数
sinat_18558057的博客
04-26 448
求某一节点的值在所有路径当中的最大值。先求出路径，路径即是二叉树中跟节点到叶子节点所有路径。 # Definition for a binary tree node. class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None class Solution: def getMaxNumInAllPath(self, root,
【二叉树】统计成绩出现的次数
Wonder233的学习博客
11-06 1056
编程实现二叉搜索树来记录考试成绩的分布。 解题： 修改 Node 对象， 为其增加一个记录成绩出现频次的成员。function Node(data,left,right){ this.data = data; this.count = 1; this.left = left; this.right = right; }同时还需要一个方法， 当在 BST 中发现某成绩
统计二叉树中只有右孩子的结点个数
欢迎光临雨落星辰的博客
06-16 3385
Description 设二叉树的存储结构为二叉链表。在二叉链表中的每个结点由三部分组成：左孩子指针、右孩子指针和结点数据，其中如果一个结点的左右孩子不存在，则对应的指针记录为空，空指针用字符^占位。 Input 输入包括两部分： 第一部分，输入测试组数T（T<=10) 第二部分，T行 每行一棵非空的二叉树，每棵二叉树按先序遍历形式，空指针用字符^占位。 测试时，每棵二叉树不会超过20个结点。 Output 一个整数，代表该二叉树中只有右孩子的结点个数。 Sample Input 2 ABC^^^^
递归——求二叉树中子树的结点数量
白给、少年
09-14 815
题目描述： 已知一个二叉树的最后一个结点为n，现在求结点m所在的子树中一共包括了多少个结点。可以设定一个全局变量num记录结点数，然后用递归方法计算结点的左右子树的结点数。 输入描述： 每行包含m，n 输出0，0表示结束 输出描述: m所在子树的结点数 代码： #include<iostream> #include<cstdio> using namespace std; int n; int num=0; int count(int m) ...
递归计算二叉树结点数目
weixin_46232441的博客
04-14 4235
一、要求 示例：编写一个函数，一棵二叉树为输入，返回二叉树的结点数目。 二、代码 int getNodeNum(BinaryTree* tree){ BinaryTreeNode* pointer = tree->root; //根结点数 int num=0; //左子数结点数 int numL=0; //右子树结点数 int numR=0; if (tree-&g
统计节点个数
Closure
03-09 1503
题目描述: 给出一棵有向树，- -共有N(1 <N≤1000个节点如果一个节点的度(入度+出度)不小于它所有儿子以及它父亲的度(如果存在父亲或儿子,那么我们称这个节点为p节点现在你的任务是统计p节点的个数。 如样例，第一组的p节点为1,23;第二组的p节点为0。 输入格式: 第一行为数据组数T(1≤T≤100)。 每组数据第-行为N表示树的节点数。后面为N - 1行,每行两个数x,y(...
求二叉树节点个数（递归）
weixin_45755718的博客
04-19 7655
下面有一个二叉树，求其节点个数。 分析： 想要得到二叉树的节点个数，我们可以递归遍历这个二叉树，当一个树的根节点不为null时，对其计数。 我在下面得代码里写了两种方法，一种是借助成员变量，一种是直接递归计数。 代码： public class TestTree1 { static class Node { public char val; public ...
二叉树递归遍历结点个数
I_AM_KK的博客
08-17 1170
这里先直接按照上一篇博客单链表的递归套路写下来。 int count(BiTree root){ if (root == NULL){ return 0; } int l_count = conut (root->lchild); int r_count = count (root->rchild); return l_count + r_count + 1; } 其实，单链表是“一叉树”，遍历的时候只有写一个递归句子就好了，二叉树相当于向左遍历一次，向右遍历一次。 难想的是，为
二叉树理论与习题解析
1. 3个节点的二叉树有4种形态：两个叶节点和一个根节点，一个叶节点和两个非空子节点，一个根节点和两个相同深度的子树，以及一个满二叉树（3个节点都在同一层）。 2. 深度为6的满二叉树有6个分支节点（即度为2的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值