• 数据结构与算法 树 课后习题 选择题部分

    1.下列说法正确的是：C

    A.二叉树中任何一个结点的度都为2.

    B.二叉树的度为2.

    C.一棵二叉树的度可小于2

    D.任何一棵二叉树中至少有一个结点的度为2.

    分析：

    二叉树可以有五种基本形态：

     所以任何一个结点的度不一定为2，A错，C错；

    树的度：树中各节点度的最大值。

    所以二叉树的度不一定为2，也可能为0或1，B错；

    2.以二叉链表作为二叉树的存储结构，在具有n个结点的二叉链表中，空链域的个数为：C

    A.2n-1

    B.n-1

    C.n+1

    D.2n+1

    分析：

    例举法

    比如有3个结点:

    有四个空指针，所以选C。

    理论分析：

    一个具有n个结点的二叉树用二叉链表存储，那么有2n个指针域，其中有n-1个指针域用来存储结点孩子的位置，另外n+1个结点存放的是空指针。

    这有点像小学的路灯问题，有5个路灯沿马路排列，每两个路灯相距3m，那么这五个路灯总共多长？

    答案是：（5-1）*3=12

    有n个结点的二叉树，那么就有n-1个边去连接它们，也就是n-1个指针域。

    所以有n+1个空指针

    3.线索化二叉树中，某结点*p没有孩子的充要条件是：B

    A.p->lchild=NULL

    B.p->ltag=1 && p->rtag=1

    C.p->ltag=0

    D.p->lchild=NULL && p->ltag=1

    分析：

    线索二叉树的结构：

    定义：

    1. typedef struct TNode* BinTree;
    2. typedef struct TNode {
    3.     char data;
    4.     BinTree left;
    5.     BinTree right;
    6.     unsigned ltag;
    7.     unsigned rtag;
    8. };

     ltag为0时，lchild指向结点的左孩子；

    ltag为1时，lchild指向结点的前驱结点；

     rtag为0时，rchild指向结点的右孩子；

    rtag为1时，rchild指向结点的后继结点；

    结点*p没有孩子代表着结点p的左孩子指向该节点的前驱结点，p的右孩子指向该结点的后继结点，故ltag与rtag均为1，B对。

    在 A.p->lchild=NULL 中，因为是线索二叉树，一个结点左孩子不是指向下一个结点，就是指向该结点的前驱结点，不会为空。

    在 C.p->ltag=0 中，p->ltag=0 代表结点p有左孩子。

    在 D.p->lchild=NULL && p->ltag=1 中，同A，不会为空。

    4.如果结点A有3个兄弟，而且B是A的双亲，则B的度为：B

    A.3

    B.4

    C.5

    D.1

    分析：结点A是B的孩子，A有3个兄弟，那么B有4个孩子，所以B的度为4.


    5.某二叉树T有n个结点，设按某种顺序对T中的每个结点进行编号，编号值为1,2,……,n。且有如下性质: T中任意结点v，其编号等于左子树上的最小编号减1， 而V的右子树的结点中，其最小编号等于v左子树上结点的最大编号加1，这是按  (   )编号的。B
    A.中序遍历序列
    B.先序遍历序列
    C.后序遍历序列

    D. 层次顺序

    分析：还是例举法。


    6.设F是一个森林，B是由F转换得到的二又树，F中有n个非终端结点，B中右指
    针域为空的结点有( )个。C
    A. n-1
    B. n
    C. n+1
    D. n+2

    分析：

    例举法

    终端结点（Terminal Nodes）： 度数为零的结点就是树叶（叶子结点）也叫做终端结点。

    非终端结点（Nonterminal Nodes）： 终端结点以外的所有结点都是非终端结点。

    7.一棵完全二叉树上有1001个结点，其中叶子结点的个数是：B

    A.500

    B.501

    C.490

    D.495

    分析：

    完全二叉树（Complete Binary Tree）： 如果该二叉树的所有叶子结点都在最后一层或者倒数第二层，而且最后一层的叶子结点在左边连续，倒数第二层的叶子结点在右边连续，我们称为完全二叉树。

     所以设这棵完全二叉树有n层，那么它的n-1层是满二叉树。

    深度为k的二叉树中，最多有 （2的k次方）-1 个结点。

    当k=9时，最多有 （2的9次方）-1 个结点，,即512-1=511个结点，第9层有256个结点，第1---8层共有255个结点。

    那么剩下的1001-511=490个结点排列在下一层第10层。

    第10层上的每两个结点是第9层的一个结点的两个孩子，所以第9层中有490/2=245个结点有两个孩子，其余结点无孩子。

    所以有490+（256-245）=501个结点。

    8.设森林F有3棵树，第一，，第二和第三棵树的结点个数分别为N1,N2和N3，与森林F对应的二叉树根节点的右子树的结点个数为： D

    A.N1

    B.N1+N2

    C.N2

    D.N2+N3

    分析：

    n叉树转化为二叉树的方法：

    将一个结点的左孩子连接这个结点的长子，右孩子连接这个结点的兄弟。

    森林转化为二叉树的方法：

    将森林中的树转化为二叉树，

    将转化后的第一个二叉树的根节点的右孩子连接第二个二叉树的根节点，第二个二叉树的根节点的右孩子连接第三个二叉树的根节点，按这个规律连接完所有二叉树。

    所以森林F对应的二叉树根节点的右子树是除了第一个树以外的其他树，所以结点个数是其他树的结点个数之和。

    9.任何一棵二叉树的叶节点在先序，中序和后序遍历顺序的相对次序：A

    A.不发生改变

    B.发生改变

    C.不确定

    D.以上都不对

    分析：

    代码运行一遍就记住了

    在这里用了一下这个的代码来创建树，并用迭代法进行遍历：

    4-14 还原二叉树&&4-15 根据后序和中序遍历输出先序遍历

    生成的树是这样的：

    1. #include
    2. #include
    3. #include
    4. using namespace std;
    5.  
    6. typedef struct TNode* BinTree;
    7. typedef struct TNode {
    8.     char data;
    9.     BinTree left;
    10.     BinTree right;
    11.  
    12.     TNode(char(x)) :data(x), left(NULL), right(NULL) {};
    13.     TNode(char(x), BinTree(l), BinTree(r)) :data(x), left(l), right(r) {};
    14. };
    15.  
    16. BinTree get(char preod[], char inod[], int len) {
    17.     int i;
    18.     if (len <= 0) {
    19.         return NULL;
    20.     }
    21.     BinTree t = new TNode(preod[0]);
    22.     for (i = 0; inod[i] != preod[0]; i++);
    23.     t->left = get(preod + 1, inod, i);
    24.     t->right = get(preod + i + 1, inod + i + 1, len - i - 1);
    25.     return t;
    26. }
    27.  
    28. vector<char> preod(BinTree BT) {
    29.     vector<char> result;
    30.     stack st;
    31.     if (BT != NULL) {
    32.         st.push(BT);
    33.     }
    34.  
    35.     while (!st.empty()) {
    36.  
    37.         BinTree temp = st.top();
    38.         if (temp != NULL) {
    39.             st.pop();
    40.             if (temp->right) {
    41.                 st.push(temp->right);
    42.             }
    43.             if (temp->left) {
    44.                 st.push(temp->left);
    45.             }
    46.  
    47.             st.push(temp);
    48.             st.push(NULL);
    49.         }
    50.         else {
    51.             st.pop();
    52.             temp = st.top();
    53.             st.pop();
    54.             result.push_back(temp->data);
    55.         }
    56.     }
    57.     return result;
    58. }
    59.  
    60. vector<char> midod(BinTree BT) {
    61.     vector<char> result;
    62.     stack st;
    63.     if (BT != NULL) {
    64.         st.push(BT);
    65.     }
    66.  
    67.     while (!st.empty()) {
    68.  
    69.         BinTree temp = st.top();
    70.         if (temp != NULL) {
    71.             st.pop();
    72.             if (temp->right) {
    73.                 st.push(temp->right);
    74.             }
    75.  
    76.             st.push(temp);
    77.             st.push(NULL);
    78.  
    79.             if (temp->left) {
    80.                 st.push(temp->left);
    81.             } 
    82.         }
    83.         else {
    84.             st.pop();
    85.             temp = st.top();
    86.             st.pop();
    87.             result.push_back(temp->data);
    88.         }
    89.     }
    90.     return result;
    91. }
    92.  
    93. vector<char> rearod(BinTree BT) {
    94.     vector<char> result;
    95.     stack st;
    96.     if (BT != NULL) {
    97.         st.push(BT);
    98.     }
    99.  
    100.     while (!st.empty()) {
    101.  
    102.         BinTree temp = st.top();
    103.         if (temp != NULL) {
    104.             st.pop();
    105.  
    106.             st.push(temp);
    107.             st.push(NULL);
    108.  
    109.             if (temp->right) {
    110.                 st.push(temp->right);
    111.             }
    112.  
    113.             if (temp->left) {
    114.                 st.push(temp->left);
    115.             }
    116.  
    117.         }
    118.         else {
    119.             st.pop();
    120.             temp = st.top();
    121.             st.pop();
    122.             result.push_back(temp->data);
    123.         }
    124.     }
    125.     return result;
    126. }
    127.  
    128.  
    129. int main()
    130. {
    131.     int n;
    132.     scanf("%d", &n);
    133.     char s1[200], s2[200];
    134.     scanf("%s", &s1);
    135.     scanf("%s", &s2);
    136.  
    137.     BinTree root = get(s1, s2, n);
    138.  
    139.     printf("先序：");
    140.     vector<char> result1 = preod(root);
    141.     for (int i = 0; i < result1.size(); i++) {
    142.         if (result1[i] == 'F' || result1[i] == 'H' || result1[i] == 'I' || result1[i] == 'E' || result1[i] == 'C') {
    143.             cout << '*' << result1[i] << '*' << " ";
    144.         }
    145.         else {
    146.             cout << result1[i] << " ";
    147.         }
    148.     }
    149.  
    150.     printf("\n中序：");
    151.     vector<char> result2 = midod(root);
    152.     for (int i = 0; i < result2.size(); i++) {
    153.         if (result2[i] == 'F' || result2[i] == 'H' || result2[i] == 'I' || result2[i] == 'E' || result2[i] == 'C') {
    154.             cout << '*' << result2[i] << '*' << " ";
    155.         }
    156.         else {
    157.             cout << result1[i] << " ";
    158.         }
    159.     }
    160.  
    161.     printf("\n后序：");
    162.     vector<char> result3 = rearod(root);
    163.     for (int i = 0; i < result3.size(); i++) {
    164.         if (result3[i] == 'F' || result3[i] == 'H' || result3[i] == 'I' || result3[i] == 'E' || result3[i] == 'C') {
    165.             cout << '*' << result3[i] << '*' << " ";
    166.         }
    167.         else {
    168.             cout << result1[i] << " ";
    169.         }
    170.     }
    171.  
    172.     return 0;
    173. }

     运行结果：

    10.若一棵二叉树的后序遍历序列为dabec，中序遍历序列为debac，则先序遍历序列为：D

    A.cbed

    B.decab

    C.deabc

    D. cedba

    11.若一棵二叉树的先序遍历序列为abdgcefh，中序遍历序列为dgbaechf，则后序遍历序列为：D

    A.gcefha

    B.gdbecfha

    C.bdgaechf

    D.gdbehfca

    分析：第10题和第11题一样的，可以参考这个：

    4-14 还原二叉树&&4-15 根据后序和中序遍历输出先序遍历

    12.一棵非空二叉树的先序遍历序列与后序遍历序列正好相反，则该二叉树一定满足：C

    A.所有结点均无左孩子

    B.所有结点均无右孩子

    C.只有一个叶子结点

    D.是一棵满二叉树

    分析：

    这个我还不明白咋求出来的。。。

    以后补上

    13.设高度为h的二叉树上只有度为0和度为2的结点，则此类二叉树中所包含的结点个数至少为：B

    A.2*h

    B.2*h-1

    C.2*h+1

    D.h+1

    14.一个具有567个结点的二叉树的高h为：D

    A.9

    B.10

    C.9--566

    D.10--567

    15.给一个整数集合{3,5,6,7,9}，与该整数集合对应的哈夫曼树为：B

  • 相关阅读:
    Django学习笔记-创建第一个django项目
    协议的定制之序列化与反序列化 | 守护进程
    mmdetection3d SUN RGB-D数据集预处理
    Linux安装软件通用办法总结及注意事项(全局运行、守护进程、自启动,开放服务端口)
    三种方法教你下载 Windows 10 和 Windows 11 原生镜像
    数字安全实操AG网址漏洞扫描原理与技术手段分析
    （黑客）网络安全———自学方法
    golang map 并发读写 sync.Map 实现原理
    （附源码课件）10款Java小游戏满足你各种需求
    剑指 Offer 04. 二维数组中的查找
  • 原文地址：https://blog.csdn.net/JYHZZ/article/details/127794737