【数据结构】练习集

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

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

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

  4. 栈和队列的存储方式,既可以是顺序方式,也可以是链式方式。(T)

  • 顺序栈和顺序队列适合需要快速随机访问且大小相对固定的情况
  • 链式栈和链式队列适合需要动态调整大小的情况,且不需要频繁的随机访问
  1. 环形队列中有多少个元素可以根据队首指针和队尾指针的值来计算。(T)

  2. 可以通过少用一个存储空间的方法解决循环队列中队空和队满条件的区分。(T)

  3. 二叉树中至少存在一个度为2的结点。(F)

  4. 哈夫曼树中一定没有度为 1 的结点。(T)

  5. 哈夫曼树一定是完全二叉树。(F)

  6. 对于任何一个图,从它的某个顶点进行一次深度或广度优先搜索可以访问到该图的每个顶点。(F)

  7. 连通图上各边权值均不相同,则该图的最小生成树是唯一的。(T)

  8. 从n个顶点的连通图中选取n-1条权值最小的边即可构成最小生成树。(F)

  • 在 Kruskal’s 算法中,我们需要确保所选择的边不会形成环(即回路)。而在 Prim’s 算法中,由于每次选择的边都是连接已访问顶点和未访问顶点,因此天然不会形成环。
  1. 在线性表的顺序存储结构中,插入和删除元素时,移动元素的个数与该元素的位置有关。(T)

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

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

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

  5. 若采用“队首指针和队尾指针的值相等”作为环形队列为空的标志,则在设置一个空队时只需将队首指针和队尾指针赋同一个值,不管什么值都可以。(T)

  6. 可以通过少用一个存储空间的方法解决循环队列假溢出现象。(F)

  7. 一棵有124个结点的完全二叉树,其叶结点个数是确定的。(T)

  • 如果完全二叉树的总结点数 n 是奇数,则叶结点数 l 等于 ( n + 1 ) / 2
  • 如果完全二叉树的总结点数 n 是偶数,则叶结点数 l 等于 n / 2
  • l = 124 / 2 = 62,因此,这棵有 124 个结点的完全二叉树的叶结点个数是 62
  1. 哈夫曼树的结点个数不能是偶数。(T)
  • 哈夫曼树的结点个数不能是偶数。 除叶子节点外,其他节点都有左右子节点,再加上根节点,所以是奇数
  1. 哈夫曼树是带权路径长度最短的树,路径上权值较大的结点离根较近。(T)
  • 哈夫曼树是一种特殊的二叉树,其特点是带权路径长度最短,也就是说,它是所有可能的树形结构中带权路径长度(即各节点的权值乘以到根节点的路径长度之和)最小的树。
  1. 图的深度优先遍历非递归算法通常采用队列实现,广度优先遍历非递归算法通常采用堆栈实现。(F)
  • 图的广度优先搜索(BFS)通常使用队列来实现,而深度优先搜索(DFS)通常使用堆栈(或者递归调用栈)来实现
  1. Prim 算法是通过每步添加一条边及其相连的顶点到一棵树,从而逐步生成最小生成树。(T)
  • 对于非连通图来说,生成树只包含每个连通分量中的所有顶点,而不是整个图的所有顶点。
  1. 连通图的生成树包含了图中的所有顶点。(T)
  • 如果连通图G的一个子图是一棵包含G的所有顶点的树,则该子图称为G的生成树(SpanningTree)
  • 生成树是连通图的包含图中的所有顶点的极小连通子图
  • 图的生成树不惟一
  1. 对于顺序存储的长度为N的线性表,删除第一个元素和插入最后一个元素的时间复杂度分别对应为O(1)和O(N)。(F)
  • 删除第一个元素的时间复杂度为 O(N):
  • 删除第一个元素意味着需要将数组中所有元素向前移动一个位置,以填补删除的空缺。具体操作包括将第二个元素移到第一个位置,第三个元素移到第二个位置,以此类推,直到最后一个元素移动到倒数第二个位置。这种操作的时间复杂度是线性的,即 O(N)
  • 删除第一个元素的时间复杂度为 O(N),因为需要移动剩余元素来填补空缺
  • 插入最后一个元素的时间复杂度为 O(1):
  • 在数组末尾插入一个元素通常是比较高效的操作,因为只需要在数组的末尾位置写入新的元素,并更新数组的长度信息。这个过程是常数时间的操作,即 O(1)。
  • 插入最后一个元素的时间复杂度为 O(1),因为直接在数组末尾插入元素而无需移动其他元素
  1. 顺序存储结构的主要缺点是不利于插入或删除操作。(T)

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

  3. 对单链表来说,只有从头结点开始才能访问到表中所有结点。(T)

  4. 下列函数试图求链式存储的线性表的表长,是否正确?(F)

int  Length ( List  *PtrL )
{    List  *p = PtrL;      
     int  j = 0;
     while ( p ) { 
           p++; 
           j++;                 
     }   
     return  j;
}
  • 指针p的增加操作:在链表中,应该使用指针p指向当前节点的下一个节点,而不是简单地使用 p++。链表的遍历应该通过节点的指针域来进行,例如 p = p->next; 这样的操作
  • 指针p的类型:如果List *p是指向链表节点的指针,那么 p++ 实际上是在指针上进行递增,而不是在节点上。应该使用指向节点的指针,例如 ListNode *p = PtrL->next;,然后使用p=p->next
  1. 线性表的顺序存储表示优于链式存储表示。(F)
  • 顺序存储适合于元素数量不变、频繁进行查找和更新操作的场景,例如数组。
  • 链式存储适合于需要频繁插入和删除操作、元素数量变化较大或者未知的场景,例如链表。
  1. 在具有N个结点的单链表中,访问结点和增加结点的时间复杂度分别对应为O(1)和O(N)。(F)
  • 访问结点的时间复杂度:
  • 如果知道要访问的结点的位置(例如第k个结点),那么访问这个结点的时间复杂度为O(k)。如果要访问头结点(第一个结点),时间复杂度是O(1)。如果要访问尾结点,需要从头结点开始遍历到尾结点,时间复杂度为O(N),其中N是链表中的结点数。
  • 总结: 单链表中访问结点的时间复杂度可以是O(1)(访问头结点)到O(N)(访问尾结点)之间
  • 增加结点的时间复杂度:
  • 如果在已知位置后面插入结点,可以在O(1)的时间内完成,因为只需修改前一个结点的指针即可。如果在链表末尾插入结点,需要先遍历到尾结点,时间复杂度为O(N),然后再进行插入操作。
  • 总结: 单链表中增加结点的时间复杂度可以是O(1)(在已知位置后插入)或者O(N)(在末尾插入)
  1. 线性表采用链式存储表示时,所有结点之间的存储单元地址可以连续也可以不连续。(T)
  • 因为链式存储方式通过使用指针(或引用)来连接各个结点,每个结点存储自身的数据以及指向下一个结点的指针。
  1. 在具有头结点的链式存储结构中,头指针指向链表中的第一个元素结点。(F)
  • 在具有头结点的链式存储结构中,头指针指向链表中的第一个元素结点之前的一个特殊结点,这个特殊结点称为头结点(dummy node)或者哨兵结点(sentinel node)
  1. 在线性表的顺序存储结构中可实现快速的随机存取,而在链式存储结构中则只能进行顺序存取。(T)

  2. 若一个栈的输入序列为1,2,3,…,N,输出序列的第一个元素是i,则第j个输出元素是j−i−1。(F)

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

  • 在栈(Stack)数据结构中,栈底元素是指最先进入栈的元素,通常是最底部的元素。在标准的栈实现中,确实是不能直接删除栈底元素的。
  • 从栈的设计和操作角度来看,栈底元素通常是不可直接删除的。如果需要删除栈底元素,一般需要先将栈中的其他元素依次出栈,直到要删除的元素变成栈顶元素,然后再将它出栈。
  1. 栈顶元素和栈底元素有可能是冋一个元素。(T)

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

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

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

  • 循环队列是把顺序队列首尾相连,把存储队列元素的表从逻辑上看成一个环,成为循环队列。在逻辑上是一个循环结构,即frt和rar的位置是任意的。
  • 由于出队与入队操作front = (front+1)% n,rear = (rear + 1)% n;
  • 我们只能保证front与rear是在0到n-1之间的,但是我们无法保证front是一直小于等于rear的。
  1. 队列是一种插入和删除操作分别在表的两端进行的线性表,是一种先进后出的结构。(F)

  2. 不论是入队列操作还是入栈操作,在顺序存储结构上都需要考虑"溢出"情况。(T)

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

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

  • 循环队列执行出队操作时通常不会引起大量元素的移动,它通过指针的移动来实现高效的出队操作,是队列数据结构中一种常见且有效的实现方式
  1. n个元素进队的顺序和出队的顺序总是一致的。(T)

  2. 在对不带头结点的链队列作出队操作时,不会改变头指针的值。(F)

  • 在进行不带头结点的链队列的出队操作时,头指针的值会发生变化。这是因为头指针始终指向队首元素,当队首元素被出队后,头指针需要指向新的队列首元素,以确保队列的正确性和连续性。因此,头指针的值在出队操作后会改变,以指向新的队列首元素。
  1. 将一棵完全二叉树存于数组中(根结点的下标为1)。则下标为23和24的两个结点是兄弟。(F)

  2. 一棵有9层结点的完全二叉树(层次从1开始计数),至少有255个结点。(F)

  • 完全二叉树的节点数量可以通过以下公式计算:2^k - 1
  • 节点总数:2^9 − 1 = 512 − 1 = 511
  • 2^k − 1 ≥ 255,得出 h = 8
  • 一个有8层结点的完全二叉树,恰好满足至少有255个结点的条件
  1. 一棵有9层结点的完全二叉树(层次从1开始计数),至少有512个结点。(F)
  • 2^k − 1 ≥ 512,得出 h = 10
  • 一个有10层结点的完全二叉树,恰好满足至少有512个结点的条件
  1. 对N(≥2)个权值均不相同的字符构造哈夫曼树,则树中任一非叶结点的权值一定不小于下一层任一结点的权值。(T)

  2. 需要借助于一个队列来实现DFS算法。(F)

  • 深度优先搜索(DFS)是一种常用的图和树的遍历算法,通常使用递归或栈来实现。虽然队列通常用于广度优先搜索(BFS),但我们可以通过在DFS中使用显式的栈(或模拟栈的数据结构)来实现。
  1. 如果无向图G必须进行3次深度优先搜索才能访问其所有顶点,则G一定有3个连通分量。(T)

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

  3. 图的深度优先遍历非递归算法通常采用栈实现,广度优先遍历非递归算法通常采用队列实现。(T)

  4. 图的深度优先遍历相当于二叉树的先序遍历。(T)

  5. 图的深度优先遍历相当于二叉树的层次遍历。(F)

  6. 采用邻接表存储的图,其广度优先遍历类似于二叉树的先序遍历。(F)

  • 相当于按层遍历
  1. 图的广度优先遍历相当于二叉树的层次遍历。(T)

  2. 图的广度优先遍历相当于二叉树的后序遍历。(F)

  3. 若有向图不存在回路,即使不用访问标志位同一结点也不会被访问两次。(F)

  4. Prim 算法是维护一个森林,每一步把两棵树合并成一棵。(F)

  5. 带权无向图的最小生成树必是唯一的。(F)

  6. 最小生成树是指边数最少的生成树。(F)

  7. 若图G为连通图,则G必有唯一的一棵最小生成树。(F)

  8. 对于带权无向图 G = (V, E),M 是 G 的最小生成树,则 M 中任意两点 V1 到 V2 的路径一定是它们之间的最短路径。(F)

  9. 连通图的最小生成树一定是唯一的。(F)

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

  11. 一个带权的无向连通图的最小生成树的权值之和是唯一的。(T)

  12. 关于二叉树,下列说法正确的是(AC)

  • A. 每个结点至多有两个子树
  • B. 二叉树的子树无左右之分
  • C. 树的结点包含一个数据元素和指向其子树的分支
  • D. 二叉树只能进行链式存储
  1. 以下哪些项是栈元素操作的基本特点:(BC)
  • A. 先进先出
  • B. 先进后出
  • C. 后进先出
  • D. 后进后出

相关推荐

  1. 数据结构练习

    2024-06-19 09:50:06       13 阅读
  2. 数据结构练习3

    2024-06-19 09:50:06       31 阅读
  3. 数据结构练习——素数统计

    2024-06-19 09:50:06       36 阅读

最近更新

  1. 【深度学习】sdxl的Lora训练技巧

    2024-06-19 09:50:06       0 阅读
  2. 理解Cookie、Session和Token

    2024-06-19 09:50:06       0 阅读
  3. 第四节shell条件测试(5)

    2024-06-19 09:50:06       0 阅读
  4. Python内存泄漏排查

    2024-06-19 09:50:06       0 阅读
  5. 【瓴岳科技】历史面试题

    2024-06-19 09:50:06       0 阅读

热门阅读

  1. template标签

    2024-06-19 09:50:06       15 阅读
  2. Springboot应用设置跳过SSL证书认证

    2024-06-19 09:50:06       17 阅读
  3. MySQL-DML-约束

    2024-06-19 09:50:06       14 阅读
  4. 研导AI写作:辅助创作的未来伙伴

    2024-06-19 09:50:06       15 阅读
  5. vue3基础

    2024-06-19 09:50:06       16 阅读
  6. C++ 设计模式

    2024-06-19 09:50:06       15 阅读
  7. 19、架构-虚拟化容器

    2024-06-19 09:50:06       13 阅读
  8. python 数据清洗基础教程

    2024-06-19 09:50:06       14 阅读