沈师PTA数据结构判断，附解析版

1. 数据元素可以由类型互不相同的数据项构成。T

2. 算法和程序没有区别，在数据结构中二者是通用的。F

   解析：N.沃思教授提出：程序=算法+数据结构

3. 数据元素是数据的最小单位。F

   解析：数据项是数据的最小单位

4. 数据结构概念包括数据之间的逻辑结构、数据在计算机中的存储方式和数据的运算三个方面。T

5. 数据结构的抽象操作的定义与具体实现有关。F

   解析：抽象操作看成面向对象编程，不考虑实现的细节，比如一个操作可以用链表或数组来处理，条条大路通罗马，达到目的即可。

6. 关于《数据结构》学科:《数据结构》是一门研究数值计算的程序设计问题的学科 。F

   解析：研究的是非数值计算的程序设计问题。

7. 算法独立于具体的程序设计语言，与具体的计算机无关。T

8. 数据结构包括数据对象集以及它们的逻辑结构和物理结构，还包括与数据对象相关联的操作集，以及实现这些操作的高效的算法。T

9. 数据的逻辑结构是指数据的各数据项之间的逻辑关系。F

   解析： 数据元素间抽象化的相互关系，与数据的存储无关，独立于计算机，它是从具体问题抽象出来的数学模型。

10. 算法分析的两个主要方面是时间复杂度和空间复杂度的分析。T

11. 数据的逻辑结构说明数据元素之间的顺序关系，它依赖于计算机的存储结构。F

    解析：逻辑结构可用不同的存储结构实现。

12. 抽象数据类型与计算机内部表示和实现无关。T

13. 算法可以没有输入，但是必须有输出。T

14. $在任何情况下，时间复杂度为O(n^2)的算法比时间复杂度为O(n\ast logn)的算法所花费的时间都长。.$ F

    解析：O(nlogn)的算法关键是它建立了一个数组c[]，c[i]表示长度为i的不下降序列中结尾元素的最小值，用K表示数组目前的长度，算法完成后K的值即为最长不下降子序列的长度。

    具体点来讲：

    • 设当前的以求出的长度为K，则判断a[i]和c[k]：
      如果a[i]>=c[k]，即a[i]大于长度为K的序列中的最后一个元素，这样就可以使序列的长度增加1，即K=K+1,然后现在的c[k]=a[i]；
    • 如果a[i]<c[k]，那么就在c[1]...c[k]中找到最大的j,使得c[j]<a[i],然后因为c[j]<a[i]，所以a[i]大于长度为j的序列的最后一个元素，那么就可以更新长度为j+1的序列的最后一个元素，即c[j+1]=a[i]。
      算法复杂度的分析：
    • 因为共有n个元素要进行计算；每次计算又要查找n次，所以复杂度是$O(n^2)$，但是，注意到c[]数组里的元素的单调递增的，所以我们可以用二分法，查找变成了logn次。这样算法的复杂度就变成了O(n*logn)。

15. 算法的优劣与算法描述语言无关，但与所用计算机有关。F

    解析：算法的优劣与算法描述语言有关，与计算机无关。评价算法最重要的标准是算法的正确性。

16. 数据的逻辑结构与数据元素本身的内容和形式无关。T

17. 对于某些算法，随着问题规模的扩大，所花的时间不一定单调增加。T

18. 数据项是数据的最小单位。T

19. 顺序存储的线性表可以随机存取。T

20. (neuDS)所谓随机存取，就是通过首地址和元素的位序号值可以在O(1)的时间内找到指定的元素。T

21. 带头结点的单循环链表中，任一结点的后继结点的指针域均不空。T

22. 在一个设有头指针和尾指针的单链表中，执行删除该单链表中最后一个元素的操作与链表的长度无关。F

    解析：删除最后一个元素需要找到最后一个元素的前驱，在通过尾指针无法快速找到其前驱。只能通过头指针向后遍历链表，链表有多长就需要遍历多长，所以执行该操作与链表长度有关。

    

23. 顺序存储结构的主要缺点是不利于插入或删除操作。T

24. (neuDS)在顺序表上进行插入、删除操作时需要移动元素的个数与待插入或待删除元素的位置无关。F

    解析：假定一个顺序表原来有10个元素，在首位插入元素后面的元素全需要移动，在末位插入元素，前面的元素则不需要移动

25. 在顺序表中取出第i个元素所花费的时间与i成正比。F

    解析：取出第i个元素的意思不是找到这个元素，而是找到后删除或别的什么操作。 那么找到第i个元素的过程是不花费时间的，仅仅是一个地址移位运算而已。 但是接下来需要把i后面所有元素往前移一位，这才是花费时间的地方。 所以不是与i成正比，而是i越大花费时间越小.

26. 顺序存储方式只能用于存储线性结构。F

    解析：顺序存储方式不仅能用于存储线性结构，还可以用来存放非线性结构，例如完全二叉树是属于非线性结构，但其最佳存储方式是顺序存储方式

27. 线性表的顺序存储表示优于链式存储表示。F

    解析：如果元素个数已知，且插入删除较少的可以使用顺序结构，而对于频繁有插入删除操作，元素个数未知的，最好使用链式结构，编程时可结合要处理的数据的特点设计数据结构的。

28. 在线性表的顺序存储结构中，插入和删除元素时，移动元素的个数与该元素的位置有关。T

29. 在具有头结点的链式存储结构中，头指针指向链表中的第一个元素结点。F

    解析：头指针指向的是头结点。

30. 线性表采用链式存储表示时，所有结点之间的存储单元地址可以连续也可以不连续。T

31. 链式存储的优点是插入、删除元素时不会引起后续元素的移动，缺点是只能顺序访问各元素。T

32. (neuDS)在线性表的顺序存储结构中可实现快速的随机存取，而在链式存储结构中则只能进行顺序存取。T

33. 若用链表来表示一个线性表，则表中元素的地址一定是连续的。F

    解析：线性表的链表存储结构的特点是可以利用内存空间中一组任意的存储单元（可以是不连续的，也可以是连续的）来存储线性表的数据元素。

34. 循环链表可以做到从任一结点出发，访问到链表的全部结点。T

35. (neuDS)在顺序表中逻辑上相邻的元素，其对应的物理位置也是相邻的。T

36. 链表的每个结点都恰好有一个指针。F

    解析：链表中的每个结点可含多个指针域，分别存放多个指针。例如双向链表中的结点可以含有两个指针域，分别存放指向其直接前趋和直接后继的指针。

37. 若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算，则利用顺序表存储最节省时间。T

38. 链表 - 存储结构:链表中逻辑上相邻的元素，其物理位置也一定相邻。F

    解析：物理位置也就是地址，可能是malloc动态分配的，分配的空间大小不一定相同。

39. 栈是一种对进栈、出栈操作总次数做了限制的线性表。F

    解析：可以进行任意次进栈、出栈操作。

40. 通过对堆栈S操作：Push(S,1), Push(S,2), Pop(S), Push(S,3), Pop(S), Pop(S)。输出的序列为：123。F

    解析：输出的序列应为231。Push代表入，Pop代表出。

41. 环形队列中有多少个元素可以根据队首指针和队尾指针的值来计算。T

42. 栈顶元素和栈底元素有可能是冋一个元素。T

43. 栈底元素是不能删除的元素。F

    解析：当一个栈内只有一个元素的时候，既是栈顶元素、又是栈底元素。

44. n个元素进队的顺序和出队的顺序总是一致的。T

45. 栈和队列的存储方式，既可以是顺序方式，也可以是链式方式。T

46. 对顺序栈进行进栈、出栈操作不涉及元素的前、后移动问题。T

47. 循环队列也存在着空间溢出问题。T

    解析：循环队列的存储空间也是有限的。

48. 循环队列执行出队操作时会引起大量元素的移动。F

    解析：出队对队首指针进行操作就行。

49. 在用数组表示的循环队列中，front值一定小于等于rear值。F

    解析：环形循环队列font的值有可能大于rear。

50. 顺序栈中元素值的大小是有序的。F

    解析：顺序栈是指用顺序存储结构实现的栈，栈中的元素不一定是有序的

51. 栈是插入和删除只能在一端进行的线性表；队列是插入在一端进行，删除在另一端进行的线性表。T

52. 若一个栈的输入序列为{1, 2, 3, 4, 5}，则不可能得到{3, 4, 1, 2, 5}这样的出栈序列。T

53. 若采用“队首指针和队尾指针的值相等”作为环形队列为空的标志，则在设置一个空队时只需将队首指针和队尾

54. 指针赋同一个值，不管什么值都可以。T

55. 在n个元素连续进栈以后，它们的出栈顺序和进栈顺序一定正好相反。T

56. 具有10个叶结点的二叉树中，有9个度为2的结点。T

57. 对于一个有N个结点、K条边的森林，不能确定它共有几棵树。F

    解析：设边的数目 EdgeNum， 树的数目为 TreeNum
    根据 NodeNum - 1 = EdgeNum
    所以 (NodeNum1 - 1) + … + (NodeNumi - 1) = K
    即 N - TreeNum = K`

58. 存在一棵总共有2016个结点的二叉树，其中有16个结点只有一个孩子。F

    解析：假设没有孩子的结点（叶结点）个数为n₀，只有一个孩子的结点（度为1的结点）个数为n₁，有两个孩子的结点（度为2的结点）个数为n₂。
    则n₀+n₁+n₂=2016
    ∵n₀=n₂+1（二叉树的性质：叶结点个数等于度为2的结点个数加1）
    ∴n₀+n₁+n₂=2016
    ⇨n₂+1+16+n₂=2016
    ⇨2n₂=1999
    n₂除不尽，所以答案为F。

59. 某二叉树的前序和中序遍历序列正好一样，则该二叉树中的任何结点一定都无右孩子。F

    解析：前序遍历，根节点-左子树-右子树；中序遍历，左子树-根节点-右子树。所以前序和中序遍历顺序一样应该是任何节点没有左子树（左孩子）。

60. 设只包含根结点的二叉树高度为0，则高度为k的二叉树最小结点数为k+1。T

61. 若一个结点是某二叉树的中序遍历序列的最后一个结点，则它必是该树的前序遍历序列中的最后一个结点。F
    解析：前序遍历，根节点-左子树-右子树；中序遍历，左子树-根节点-右子树。如果这个二叉树没有右孩子，只有左孩子。那么中序遍历的最后一个结点就是该二叉树的根节点，同时，该结点为前序遍历的首结点。

62. 二叉树可以用二叉链表存储，树无法用二叉链表存储。F

    解析：所有的树都可以转换为唯一对应的二叉树，不是一般性。

63. 在任意一棵二叉树中，分支结点的数目一定少于叶结点的数目。F

    解析：只有一个结点

64. 在含有n个结点的树中，边数只能是n-1条。T

65. 将一棵完全二叉树存于数组中（根结点的下标为1）。则下标为23和24的两个结点是兄弟。F

    解析：完全二叉树第n行的孩子结点个数为$2^{n-1}$

    所以可知$\frac{1+2^{n-1}\ast n}{2}$，23，24在第5行，从16-32：22-23，24-25

66. 完全二叉树中，若一个结点没有左孩子，则它必是树叶。T

67. 某二叉树的后序和中序遍历序列正好一样，则该二叉树中的任何结点一定都无右孩子。T

68. 任何二叉搜索树中同一层的结点从左到右是有序的（从小到大）。T

69. 对N（≥2）个权值均不相同的字符构造哈夫曼树，则树中任一非叶结点的权值一定不小于下一层任一结点的权值。T

70. 若A和B都是一棵二叉树的叶子结点，则存在这样的二叉树，其前序遍历序列为...A...B...，而中序遍历序列为...B...A...。F

    解析：前序和中序指的是根的访问次序，因为a和b都是叶子节点，所以并不影响他们访问的先后次序

71. 树的后根序遍历序列等同于它所对应二叉树的中序遍历序列。T

72. 将一棵树转成二叉树，根结点没有左子树。F

    解析：根节点应该是没有右子树。

73. 某二叉树的后序和中序遍历序列正好一样，则该二叉树中的任何结点一定都无左孩子。F

    解析：中序遍历，左孩子-根节点-右孩子；后序遍历，左孩子-右孩子-根节点。

74. 一棵有124个结点的完全二叉树，其叶结点个数是确定的。T

75. 某二叉树的前序和中序遍历序列正好一样，则该二叉树中的任何结点一定都无左孩子。T

76. 二叉树通常有顺序存储结构和链式存储结构。T

77. 关于树和二叉树:二叉树就是度为 2 的树。F

    解析：二叉树是度不大于2的树（度可以为0,1,2）。

78. 在任一有向图中，所有顶点的入度之和等于所有顶点的出度之和。T

79. 若图G为连通图且不存在拓扑排序序列，则图G必有环。T

80. 用邻接表法存储图，占用的存储空间数只与图中结点个数有关，而与边数无关。F

    解析：课本P156：邻接表由两部分组成：表头结点表和边表；
    所以用邻接表法存储图，占用的存储空间数只与图中结点个数和边数都有关；

81. 用邻接矩阵法存储图，占用的存储空间数只与图中结点个数有关，而与边数无关。T

82. 如果无向图G必须进行两次广度优先搜索才能访问其所有顶点，则G中一定有回路。F

    解析：

83. 在一个有向图中，所有顶点的入度与出度之和等于所有边之和的2倍。T

84. Kruskal 算法是维护一个森林，每一步把两棵树合并成一棵。T

85. 如果 e 是有权无向图 G 唯一的一条最短边，那么边 e 一定会在该图的最小生成树上。T

86. 若图G有环，则G不存在拓扑排序序列。T

87. 无向连通图至少有一个顶点的度为1。F

    解析：课本P149图6.1示例

88. Kruskal 算法是通过每步添加一条边及其相连的顶点到一棵树，从而逐步生成最小生成树。F

    解析：Kruskal 算法是维护一个森林，每一步把两棵树合并成一棵。

89. 无向连通图边数一定大于顶点个数减1。F

    解析：课本P149图6.1示例

90. Prim 算法是维护一个森林，每一步把两棵树合并成一棵。F

    解析：prim算法是通过每步添加一条边及其相连的顶点到一棵树，从而逐步生成最小生成树。

91. 无向连通图所有顶点的度之和为偶数。T

92. 如果无向图G必须进行两次广度优先搜索才能访问其所有顶点，则G一定有2个连通分量。T

93. Prim 算法是通过每步添加一条边及其相连的顶点到一棵树，从而逐步生成最小生成树。T

94. 若用平方探测法解决冲突，则插入新元素时，若散列表容量为质数，插入就一定可以成功。F

    解析：属于散列表范围，不在考察范围。

95. 将M个元素存入用长度为S的数组表示的散列表，则该表的装填因子为M/S。T

    解析：属于散列表范围，不在考察范围。

96. 将 10 个元素散列到 100 000 个单元的哈希表中，一定不会产生冲突。F

    解析：属于散列表范围，不在考察范围。

97. 即使把2个元素散列到有100个单元的表中，仍然有可能发生冲突。T

    解析：属于散列表范围，不在考察范围。

98. 二叉排序树的后序遍历序列必然是递增的。F

    解析：二叉排序树，又叫二叉查找树，如果非空，则具有以下性质：

    • 若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值；
    • 若它的右子树不空，则右子树上所有节点的值均大于它的根节点的值；
    • 它的左右子树也分别为二叉排序树。
    • 由定义可得出 二叉排序树的一个重要性质： 中序遍历该二叉树可以得到一个结点值递增的有序序列。

99. 在散列表中，所谓同义词就是具有相同散列地址的两个元素。T

**<font color="red">解析</font>**：属于散列表范围，不在考察范围。

101. 在散列表中，所谓同义词就是被不同散列函数映射到同一地址的两个元素。F

     解析：属于散列表范围，不在考察范围。

102. 折半查找与二分查找树的时间性能在最坏的情况下是相同的。F

     解析：从查找过程看，二叉排序树与二分查找相似。就平均时间性能而言，二叉排序树上的查找和二分查找差不多，但不完全一致；
     折半查找的性能分析可以用二叉判定树来衡量，平均查找长度和最大查找长度都是O(logn)；
     二叉排序树的查找性能与数据的输入顺序有关，最好情况下的平均查找长度与折半查找相同，但最坏情况时，即形成单支树时，其查找长度为O(n)。
     折半查找的判定树唯一，而二叉排序树不唯一，相同的关键字其插入顺序不同可能生成不同的二叉排序树。

103. 在二叉排序树中插入一个新结点，总是插入到叶子结点下面。F

     解析：二叉排序树的插入是以查找为基础的。要将一个关键字值为key的结点*S插入到二叉排序树中，则需要从根节点向下查找，当树中不存在关键字等于key的结点时才进行插入。新插入的结点一定是一个新添加的叶子结点，并且是查找不成功时查找路径上访问的最后一个结点的左孩子或右孩子结点。（书上原话）

104. 折半查找法的查找速度一定比顺序查找法快。F

     解析：顺序查找时间复杂度为O(n),折半查找的时间复杂度为O($lo{g}_{2}x$)。根数函数图像可知顺序查找有比折半查找速度快的情况。

105. 用向量和单链表表示的有序表均可使用折半查找方法来提高查找速度。F

     解析：折半查找的两个前提条件：①有序，②可随机访问元素；故单链表不可以，单链表不是随机存取。

106. 在散列中，函数“插入”和“查找”具有同样的时间复杂度。T

     解析：散列表，不在考察范围。

107. (neuDS)由顺序表和单链表表示的有序表均可使用二分查找法来提高查找速度。F

     解析：二分查找不可以用链表存储

108. 给定序列｛100,86,48,73,35,39,42,57,66,21｝，按堆结构的定义，它一定是堆。T

109. 堆是满二叉树。F

     解析：堆是完全二叉树，但不是满二叉树，满二叉树是特殊的完全二叉树。

110. (neuDS)直接插入排序算法在最好情况下的时间复杂度为O(n)。T

111. 堆排序是稳定的排序算法。（ ）F

     解析：堆排序算法特点，是不稳定的排序算法；只能用于顺序结构，不能用于链式结构。

112. 对N个记录进行快速排序，在最坏的情况下，其时间复杂度是O(NlogN)。F

     解析：最坏情况时间复杂度是O($n^2$)，平均情况的时间复杂度是O(NlogN)。

113. 对于n个记录的集合进行冒泡排序，在最坏情况下需要的时间是$O(n^2)$。 T

114. 希尔排序是稳定的算法。F

     解析：记录跳跃式地记录导致排序方法是不稳定的。

115. $直接选择排序的时间复杂度为O(n^2)，不受数据初始排列的影响。.$T

116. 直接选择排序算法在最好情况下的时间复杂度为O（N）。F

     解析：关键字比较次数永远是n(n-1)/2，记录移动次数最多为3(n-1)，最少0次，前者起主导作用，因此实际上时间复杂度还是O($n^2$)。

117. 插入排序算法在每一趟都能选取出一个元素放在其最终的位置上。F

     解析：不一定会位于最终的位置，因为不确定后面插入的元素对于前面的元素是否产生影响。

118. 堆是完全二叉树，完全二叉树不一定是堆。（ ）T

119. 对N个记录进行堆排序，需要的额外空间为O(N)。F

     解析：仅需一个记录大小供交换用的辅助存储空间，所以空间复杂度为O(1)。

120. 堆肯定是一棵平衡二叉树。F

     解析：二叉排序树：或是一颗空树，或者是结点的左子树上的结点关键字都比该结点关键字值小，该结点的右子树上的结点关键字之都比该结点的关键字值大，并且是递归定义的。

     堆：对于一个数组中的关键字，如果按照完全二叉树的结点来造树，则完全二叉树中的非终端结点关键字值不大于（不小于）其左右孩子的值。

     所以综上所述可知，堆不是一颗二叉平衡树。

121. 内排序的快速排序方法，在任何情况下均可得到最快的排序效果。F

     解析：快速排序的基本思想是以基准元素为中心，将待排序表分成两个子表，然后继续对子表进行划分，直到所有子表的长度为1。

     快速排序第一趟的结果是：将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小

122. 由于希尔排序的最后一趟与直接插入排序过程相同，因此前者一定比后者花费的时间更多。F

     解析：希尔排序时间复杂度O($n^{\frac{3}{2}}$),直接插入排序时间复杂度O($n^2$)。

123. 在堆排序中，若要进行升序排序，则需要建立大根堆。（ ）T

124. 快速排序是稳定的算法。F

     解析：记录非顺次的移动导致排序方法是不稳定的。

125. 有一大根堆，堆中任意结点的关键字均大于它的左右孩子关键字，则其具有最小值的结点一定是一个叶子结点并可能在堆的最后两层中。T

126. 直接插入排序是不稳定的排序方法。F

     解析：稳定排序。

127. $对N个记录进行简单选择排序，比较次数和移动次数分别为O(n^2)和O(N)。.$T

128. 排序算法中的比较次数与初始元素序列的排列无关。F

     解析：排序算法中比较次数与初始元素序列排序无关的只有选择排序和基数排序，其他的都有关

129. 当待排序记录已经从小到大排序或者已经从大到小排序时，快速排序的执行时间最省。F

     解析：根据快排的特点可知，快速排序基本有序情况下效率最低，在基本无序情况下效率最高。

130. 起泡排序的排序趟数与参加排序的序列原始状态有关。T

131. 用希尔(shell)方法排序时，若关键字的初始排序杂乱无序，则排序效率就低。F

     解析：希尔排序又称“缩小增量排序”，即每趟只对相同增量距离的关键字进行比较，这与关键字序列初始有序或无序无关

132. 内排序要求数据一定要以顺序方式存储。F

     解析：内排序是完全在内存中存放待排序元素的排序，存储形式不一定是顺序的。

133. (neuDS)排序的稳定性是指排序算法中的比较次数保持不变，且算法能够终止。F

     解析：对于如下冒泡排序算法，原本是稳定的排序算法，如果将记录交换的条件改成r[j]>=r[j+1]，则两个相等的记录就会交换位置，从而变成不稳定的算法。

     void BubbleSort(SqList &L){
         //对顺序表L做冒泡排序
         int m = L.length - 1,flag = 1;  //flag用来标记某一趟排序是否发生交换
         while((m>0)  && (flag == 1)){
             flag = 0;  //flag置为0，如果本趟排序没有发生交换，则不会执行下一趟排序
             for(int j = 1;j <= m;j++)
                 if(L.r[j].key > L.r[j+1].key){
                     flag = 1;  //flag置为1，表示本趟排序发生了交换
                     int t = L.r[j]; L.r[j] = L.r[j+1];L.r[j+1] = t;  //交换前后两个记录
                 }
             --m;
         }
     }