链表客观题训练

ID: 5695

客观题

尝试: 14

已通过: 1

难度: 10

上传者:

陈志向

题目1（2023年9月 C++五级第15题）

以下代码构成的链表类型是（）。

Node *firstNode = new Node(10);
firstNode->Next = new Node(100);
firstNode->Next->Next = new Node(111, firstNode);

A. 单向链表
B. 双向链表
C. 循环链表
D. 指针链表

题目2（2024年3月 C++五级第1题）

关于链表和数组的描述，错误的是（）。
{{ select(2) }}

A. 存储相同数目整数时，链表比数组占用更多内存
B. 数组支持随机访问，链表不支持
C. 链表插入和删除元素效率一定高于数组
D. 数组元素在内存中一定连续

题目3（2024年9月 C++五级第2题）

在双向链表中插入节点s到节点p后的正确操作顺序是（）。
{{ multiselect(3) }}

A. s->prev = p; s->next = p->next; p->next->prev = s; p->next = s;
B. p->next = s; s->prev = p; s->next = p->next; p->next->prev = s;
C. s->next = p->next; p->next->prev = s; s->prev = p; p->next = s;
D. 以上均正确

题目4（2024年12月 C++五级第1题）

链表不具备的特点是（）。
{{ select(4) }}

A. 可随机访问任何一个元素
B. 插入、删除操作不需要移动元素
C. 无需事先估计存储空间大小
D. 所需存储空间与存储元素个数成正比

题目5（2025年3月 C++五级第2题）

删除双向链表节点p的错误操作是（）。
{{ select(5) }}

A. p->next->prev = p->next; p->prev->next = p->prev; delete p;
B. p->prev->next = p->next; p->next->prev = p->prev; delete p;
C. p->next->prev = p->prev; p->next->prev->next = p->next; delete p;
D. p->prev->next = p->next; p->prev->next->prev = p->prev; delete p;

题目6（2023年12月 C++五级第3题）

双向循环链表的初始化代码应为（）。

void InitLinkedList(LinkedList* list) {
    list->head = new ListNode<T>;
    list->tail = new ListNode<T>;
    // 填入代码
}

A. head->next = tail; tail->prev = head;
B. head->prev = head; tail->prev = head;
C. head->next = tail; tail->next = head;
D. head->next = tail; tail->next = nullptr;

题目7（2024年6月 C++五级第3题）

单链表查找操作的时间复杂度是（）。
{{ select(7) }}

A. ( O(1) )
B. ( O(n) )
C. ( O(\log n) )
D. ( O(n^2) )

题目8（2024年6月 C++五级第4题）

双向链表头部插入新节点的正确代码是（）。

void insert(dl_node* head, string my_song) {
    dl_node* p = new dl_node;
    p->song = my_song;
    p->prev = nullptr;
    p->next = head;
    if (head != nullptr) {
        ______ // 填入代码
    }
    head = p;
}

A. head->prev = p;
B. head->next = p;
C. head->prev->next = p;
D. 触发异常

题目9（2023年9月 CSP-J 第4题）

在链表中插入新节点作为第一个节点的正确操作是（）。
{{ select(9) }}

A. newNode->next = head; head = newNode;
B. head->next = newNode;
C. newNode->next = head->next; head->next = newNode;
D. newNode->prev = head; head->next = newNode;

题目10（2024年9月 C++五级第1题）

关于链表和数组，错误的是（）。
{{ select(10) }}

A. 链表大小可动态调整，数组大小固定
B. 数组支持随机访问，链表只能顺序访问
C. 存储相同数目整数时，链表比数组内存多
D. 链表插入效率一定高于数组

题目11

下面关于链表和数组的描述，错误的是（）。
{{ select(11) }}

当数据数量不确定时，链表大小可动态调整，数组可能浪费空间
链表访问节点效率低，时间复杂度为O(n)
链表插入和删除元素效率低，时间复杂度为O(n)
链表的节点在内存中分散存储，通过指针连接

题目12

在循环单链表中，最后一个节点的next指针指向（）。
{{ select(12) }}

当前节点
nullptr
第一个节点
上一个节点

题目13

以下关于链表和数组的存储，不正确的是（）。
{{ select(13) }}

存储相同数目整数时，链表比数组占用更多内存
数组支持随机访问，链表不支持
链表插入元素效率一定高于数组
数组元素在内存中一定连续

题目14

以下代码实现了删除链表中值为val的节点，横线处应填入的代码是（）。

dummyHead->next = head;  
cur = dummyHead;

选项：
{{ select(14) }}

dummyHead->next = head; cur = dummyHead;
dummyHead->next = head->next; cur = dummyHead;
dummyHead->next = head; cur = dummyHead->next;
dummyHead->next = head->next; cur = dummyHead->next;

题目15

以下关于链表的说法，错误的是（）。
{{ select(15) }}

链表删除节点时需手动释放内存
双向链表可反向遍历
链表不支持二分查找
链表访问第k个元素的时间复杂度为O(1)

判断题

题目1

题干：单链表中删除某个结点p（非尾结点），但不知道头结点，可行的操作是将p的值设为p->next的值，然后删除p->next。
{{ select(21) }}

正确（√）
错误（×）

题目2

题干：链表存储线性表时要求内存中可用存储单元地址是连续的。
{{ select(22) }}

正确（√）
错误（×）

题目3

题干：单链表和双链表都可以在常数时间内实现在链表头部插入或删除节点的操作。
{{ select(23) }}

正确（√）
错误（×）

题目4

题干：双向链表的最后一个结点的下一项指针指向第一个结点，第一个结点的前一项指针指向最后一个结点，则该双向链表构成循环链表。
{{ select(24) }}

正确（√）
错误（×）

题目5

题干：链表的插入排序时间复杂度总是比快速排序低。
{{ select(25) }}

正确（√）
错误（×）

题目6

题干：链表访问第k个元素的时间复杂度为 (O(1))。
{{ select(26) }}

正确（√）
错误（×）

题目7

题干：双向循环链表的头尾哨兵节点不存储实际数据，仅用于简化操作。
{{ select(27) }}

正确（√）
错误（×）

题目8

题干：链表删除节点时需手动释放内存，否则会导致内存泄漏。
{{ select(28) }}

正确（√）
错误（×）

题目9

题干：链表支持二分查找，因为其节点逻辑上是有序的。
{{ select(29) }}

正确（√）
错误（×）

题目10

题干：循环单链表的最后一个节点的next指针指向头节点。
{{ select(30) }}

正确（√）
错误（×）

#5695. 链表客观题训练

题目1（2023年9月 C++五级 第15题）

题目2（2024年3月 C++五级 第1题）

题目3（2024年9月 C++五级 第2题）

题目4（2024年12月 C++五级 第1题）

题目5（2025年3月 C++五级 第2题）

题目6（2023年12月 C++五级 第3题）

题目7（2024年6月 C++五级 第3题）

题目8（2024年6月 C++五级 第4题）