题目描述

1.链表与数组的主要区别是： {{ select(1) }}

• 链表元素在内存中连续存储，数组不需要
• 链表支持随机访问，数组不支持
• 链表动态分配内存，数组大小固定
• 链表插入/删除效率低，数组效率高

2. 单链表中，删除某个节点的前提是：{{ select(2) }}

• 仅需知道该节点的地址
• 必须知道该节点的前驱节点
• 必须从头节点重新遍历
• 必须知道该节点的后继节点

3. 以下哪种链表可以双向遍历？{{ select(3) }}

• 单链表
• 循环链表
• 双向链表
• 静态链表

4. 判断链表是否有环的经典算法是：{{ select(4) }}

• 深度优先搜索（DFS）
• 快慢指针法
• 哈希表存储节点值
• 二分查找

5. 在单链表中插入一个节点的时间复杂度是：{{ select(5) }}

• O(1)
• O(n)
• O(log n)
• 取决于插入位置（头节点O(1)，其他位置O(n)）

6. 循环链表的最后一个节点的指针指向：{{ select(6) }}

• NULL
• 头节点
• 第一个数据节点
• 自身

7. 合并两个有序链表的时间复杂度最优解是：{{ select(7) }}

• O(n^2)
• O(n log n)
• O(n)
• O(1)

8. 以下哪项不是链表的优点？{{ select(8) }}

• 动态扩展无需预先分配空间
• 插入/删除操作高效
• 内存利用率高（无碎片）
• 支持快速随机访问

9. 若单链表（无虚拟头节点）的头指针为head，判断链表为空的条件是：{{ select(9) }}

• head == NULL
• head->next == NULL
• head->next == head
• head != NULL

10. 双向链表中，删除某个节点需要修改的指针数量是：{{ select(10) }}

• 1
• 2
• 3
• 4

11. 在单链表（无虚拟头节点）的头部插入一个新节点，正确的操作顺序是？{{ select(11) }}

• 新节点 next = head; head = 新节点
• head = 新节点; 新节点 next = head
• 新节点 next = head->next; head = 新节点
• head->next = 新节点; 新节点 next = NULL

12. 在单链表的尾部插入一个新节点，必须先进行的操作是？{{ select(12) }}

• 直接让尾节点指向新节点
• 从头遍历找到尾节点，再修改尾节点的 next
• 使用快慢指针定位尾节点
• 新节点的 next 设为 NULL

13. 在单链表中删除节点 p（非头节点），但不知道其前驱节点，如何实现？{{ select(13) }}

• 无法删除
• 将 p->next 的值复制到 p，然后删除 p->next
• 从头遍历找到 p 的前驱节点再删除
• 直接释放 p 的内存

14. 在双向链表中删除节点 p，需要修改哪些指针？{{ select(14) }}

• p->prev->next = p->next
• p->next->prev = p->prev
• 仅需修改 p->prev
• A 和 B 都需要

15. 在循环单链表中，删除尾节点的关键步骤是？{{ select(15) }}

• 找到尾节点的前驱节点，让其 next 指向头节点
• 直接让尾节点的 next 指向 NULL
• 修改头节点指向新的尾节点
• 不需要特殊处理，和普通单链表一样

16. 在单链表中，如果要在节点 p 之后插入新节点 q，正确的操作是？{{ select(16) }}

• q->next = p->next; p->next = q
• p->next = q; q->next = p->next
• q->next = p; p->next = q
• p->next = q->next; q->next = p

17. 在双向链表的节点 p 之后插入新节点 q，需要修改哪些指针？{{ select(17) }}

• q->prev = p; q->next = p->next; p->next->prev = q; p->next = q
• q->next = p; q->prev = p->prev; p->prev = q
• p->next = q; q->prev = p
• 仅需修改 q->next 和 q->prev

18. 在一个无虚拟头节点的单链表中，如果 head 指向 NULL（空链表），插入新节点 q 的正确操作是？{{ select(18) }}

• head = q; q->next = NULL
• q->next = head; head = q
• head->next = q; q->next = NULL
• 无法插入，必须先初始化头节点

19. 在循环双链表中，删除头节点的正确步骤是？{{ select(19) }}

• head->prev->next = head->next; head->next->prev = head->prev; head = head->next
• 直接 head = head->next
• 仅需 head->next->prev = NULL
• 循环双链表不能删除头节点

20. 在单链表中，如果误将 p->next = p（自引用），会导致？{{ select(20) }}

• 链表正常，无影响
• 链表断裂，p 之后的节点丢失
• 形成环，遍历时无限循环
• 程序立即崩溃