CSP-J 卷

第 1 题单选未作答

链表不具有的特点是（）。

（2 分）

A

所需空间与线性表长度成正比

B

插入删除不需要移动元素

C

可随机访问任一元素

D

不必事先估计存储空间

CSP-J 2019 · 单选第6题｜知识点单向链表、一维数组

第 2 题单选未作答

链表和数组的区别包括（）。

（2 分）

A

数组不能排序，链表可以

B

链表比数组能存储更多的信息

C

数组大小固定，链表大小可动态调整

D

以上均正确

CSP-J 2022 · 单选第4题｜知识点单向链表、一维数组

第 3 题单选未作答

假设有一个链表的节点定义如下：

01struct Node {
02    int data;
03    Node* next;
04};

现在有一个指向链表头部的指针：Node* head。如果想要在链表中插入一个新节点，其成员 data 的值为 42，并使新节点成为链表的第一个节点，下面哪个操作是正确的？（）

（2 分）

A

Node* newNode = new Node;
newNode->data = 42;
newNode->next = head;
head = newNode;

B

Node* newNode = new Node;
head->data = 42;
newNode->next = head;
head = newNode;

C

Node* newNode = new Node;
newNode->data = 42;
head->next = newNode;

D

Node* newNode = new Node;
newNode->data = 42;
newNode->next = head;

CSP-J 2023 · 单选第4题｜知识点单向链表、程序阅读与输出推断、指针

第 4 题判断未作答

在 C++ 中，通过恰当的实现，可以将链表首尾相接，形成循环链表。

（2 分）

A

正确

B

错误

GESP 五级 2023-09 · 判断第5题｜知识点循环链表、单向链表

第 5 题判断未作答

如果将双向链表的最后一个结点的下一项指针指向第一个结点，第一个结点的前一项指针指向最后一个结点，则该双向链表构成循环链表。

（2 分）

A

正确

B

错误

GESP 五级 2024-06 · 判断第1题｜知识点循环链表、双向链表

第 6 题判断未作答

数组和链表都是线性表，链表的优点是插入删除不需要移动元素，并且能随机查找。

（2 分）

A

正确

B

错误

GESP 五级 2024-06 · 判断第2题｜知识点单向链表、一维数组

第 7 题判断未作答

链表的存储空间物理上可以连续，也可以不连续。

（2 分）

A

正确

B

错误

GESP 五级 2024-06 · 判断第3题｜知识点单向链表

第 8 题单选未作答

下面关于链表和数组的描述，错误的是（）。

（2 分）

A

数组大小固定，链表大小可动态调整。

B

数组支持随机访问，链表只能顺序访问。

C

存储相同数目的整数，数组比链表所需的内存多。

D

数组插入和删除元素效率低，链表插入和删除元素效率高。

GESP 五级 2024-09 · 单选第1题｜知识点单向链表、一维数组

第 9 题单选未作答

在循环单链表中，节点的 next 指针指向下一个节点，最后一个节点的 next 指针指向（）。

（2 分）

A

当前节点

B

nullptr

C

第一个节点

D

上一个节点

GESP 五级 2024-12 · 单选第2题｜知识点循环链表、单向链表

第 10 题判断未作答

单链表只支持在表头进行插入和删除操作。

（2 分）

A

正确

B

错误

GESP 五级 2024-12 · 判断第1题｜知识点单向链表

第 11 题单选未作答

链表不具备的特点是（）。

（2 分）

A

可随机访问任何一个元素

B

插入、删除操作不需要移动元素

C

无需事先估计存储空间大小

D

所需存储空间与存储元素个数成正比

GESP 五级 2025-03 · 单选第1题｜知识点单向链表、一维数组

第 12 题判断未作答

链表存储线性表时要求内存中可用存储单元地址是连续的。

（2 分）

A

正确

B

错误

GESP 五级 2025-03 · 判断第2题｜知识点单向链表

第 13 题单选未作答

与数组相比，链表在（）操作上通常具有更高的效率。

（2 分）

A

随机访问元素

B

查找指定元素

C

在已知位置插入或删除节点

D

遍历所有元素

GESP 五级 2025-06 · 单选第1题｜知识点单向链表、一维数组

第 14 题单选未作答

以下哪种情况使用链表比数组更合适？

（2 分）

A

数据量固定且读多写少

B

需要频繁在中间或开头插入、删除元素

C

需要高效随机访问元素

D

存储空间必须连续

GESP 五级 2025-09 · 单选第1题｜知识点单向链表

第 15 题单选未作答

以下哪组操作能完成在双向循环链表结点 p 之后插入结点 s 的效果（其中，next 域为结点的直接后继，prev 域为结点的直接前驱）：（）。

（2 分）

A

p->next->prev = s;
s->prev = p;
p->next = s;
s->next = p->next;

B

p->next->prev = s;
p->next = s;
s->prev = p;
s->next = p->next;

C

s->prev = p;
s->next = p->next;
p->next = s;
p->next->prev = s;

D

s->next = p->next;
p->next->prev = s;
s->prev = p;
p->next = s;

CSP-J 2022 · 单选第11题｜知识点双向链表、程序阅读与输出推断、指针

第 16 题单选未作答

有关下面代码的说法正确的是（）。

01#include <iostream>
02
03class Node {
04public:
05    int Value;
06    Node * Next;
07
08    Node(int Val, Node * Nxt = nullptr) {
09        Value = Val;
10        Next = Nxt;
11    }
12};
13
14int main() {
15    Node * firstNode = new Node(10);
16    firstNode->Next = new Node(100);
17    firstNode->Next->Next = new Node(111, firstNode);
18    return 0;
19}

（2 分）

A

上述代码构成单向链表。

B

上述代码构成双向链表。

C

上述代码构成循环链表。

D

上述代码构成指针链表。

GESP 五级 2023-09 · 单选第15题｜知识点循环链表、单向链表、类与对象

第 17 题单选未作答

有关下面 C++ 代码的说法正确的是（）。

01class Node
02{
03public:
04    int Value;
05    Node* Prev;
06    Node* Next;
07    Node(int Val, Node* Prv = NULL, Node* Nxt = NULL);
08};
09
10Node::Node(int Val, Node*Prv, Node* Nxt)
11{
12    this->Value = Val;
13    this->Prev = Prv;
14    this->Next = Nxt;
15}
16
17int main()
18{
19    Node firstNode = Node(10);
20    firstNode.Next = new Node(100, &firstNode);
21    firstNode.Next->Next = new Node(111, firstNode.Next);
22}

（2 分）

A

上述代码构成单向链表

B

上述代码构成双向链表

C

上述代码构成循环链表

D

上述代码构成指针链表

GESP 五级 2023-12 · 单选第12题｜知识点双向链表、类与对象、指针

第 18 题判断未作答

同样的整数序列分别保存在单链表和双向链中，这两种链表上的简单冒泡排序的复杂度相同。

（2 分）

A

正确

B

错误

GESP 五级 2023-12 · 判断第10题｜知识点冒泡排序、单向链表、双向链表

第 19 题单选未作答

下面的代码片段用于在双向链表中删除一个节点。请在横线处填入（），使其能正确实现相应功能。

01void deleteNode(DoublyListNode*& head, int value) {
02    DoublyListNode* current = head;
03    while (current != nullptr && current->val != value) {
04        current = current->next;
05    }
06    if (current != nullptr) {
07        if (current->prev != nullptr) {
08            ____________ // 在此处填入代码
09        } else {
10            head = current->next;
11        }
12        if (current->next != nullptr) {
13            current->next->prev = current->prev;
14        }
15        delete current;
16    }
17}

（2 分）

A

if (current->next != nullptr) current->next->prev = current->prev;

B

current->prev->next = current->next;

C

delete current->next;

D

current->prev = current->next;

GESP 五级 2024-03 · 单选第4题｜知识点双向链表、程序补全

第 20 题判断未作答

单链表和双链表都可以在常数时间内实现在链表头部插入或删除节点的操作。

（2 分）

A

正确

B

错误

GESP 五级 2024-03 · 判断第9题｜知识点单向链表、双向链表

第 21 题单选未作答

小杨采用如下双链表结构保存他喜欢的歌曲列表：

01struct dl_node {
02    string song;
03    dl_node* next;
04    dl_node* prev;
05};

小杨想在头指针为 head 的双链表中查找他喜欢的某首歌曲，采用如下查询函数，该操作的时间复杂度为（）。

01dl_node* search(dl_node* head, string my_song) {
02    dl_node* temp = head;
03    while (temp != nullptr) {
04        if (temp->song == my_song)
05            return temp;
06        temp = temp->next;
07    }
08    return nullptr;
09}

（2 分）

A

$O(1)$

B

$O(n)$

C

$O(\log n)$

D

$O(n^2)$

GESP 五级 2024-06 · 单选第3题｜知识点双向链表、时间复杂度

第 22 题单选未作答

通过（）操作，能完成在双向循环链表结点 p 之后插入结点 s 的功能（其中 next 域为结点的直接后继，prev 域为结点的直接前驱）。

（2 分）

A

p->next->prev = s; s->prev = p; p->next = s; s->next = p->next;

B

p->next->prev = s; p->next = s; s->prev = p; s->next = p->next;

C

s->prev = p; s->next = p->next; p->next = s; p->next->prev = s;

D

s->next = p->next; p->next->prev = s; s->prev = p; p->next = s;

GESP 五级 2024-09 · 单选第2题｜知识点双向链表、循环链表、程序补全

第 23 题判断未作答

在操作系统中，需要对一组进程进行循环。每个进程被赋予一个时间片，当时间片用完时，CPU 将切换到下一个进程。这种循环操作可以通过环形链表来实现。

（2 分）

A

正确

B

错误

GESP 五级 2024-09 · 判断第1题｜知识点循环链表

第 24 题单选未作答

为了方便链表的增删操作，一些算法生成一个虚拟头节点，方便统一删除头节点和其他节点。下面代码实现了删除链表中值为 val 的节点，横线上应填的最佳代码是（）。

0102 03 04 05 06 0708 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

class="lc">struct LinkedNode { int val; LinkedNode* next; LinkedNode(int val):val(val), next(nullptr){} };  class="kw">void removeElements(LinkedNode* head, int val) { if (head == nullptr) { return; } LinkedNode* cur; LinkedNode* dummyHead = new LinkedNode(0); //虚拟头节点 ____________      // 在此处填入代码  while(cur ->next ! = nullptr) { if(cur->next->val == val) { LinkedNode* tmp = cur->next; cur->next = cur->next->next; delete tmp; tmp = nullptr; } else { cur = cur ->next; } } head = dummyHead->next; delete dummyHead; dummyHead = nullptr; }

（2 分）

A

dummyHead->next = head; cur = dummyHead;

B

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

C

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

D

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

GESP 五级 2024-12 · 单选第3题｜知识点单向链表、程序补全

第 25 题判断未作答

二分查找仅适用于数组而不适合链表，因为二分查找需要跳跃式访问元素，链表中执行跳跃式访问的效率低。

（2 分）

A

正确

B

错误

GESP 五级 2024-12 · 判断第8题｜知识点二分查找、单向链表

第 26 题单选未作答

双向链表中每个结点有两个指针域 prev 和 next，分别指向该结点的前驱及后继结点。设 p 指向链表中的一个结点，它的前驱结点和后继结点均非空。要删除结点 p，则下述语句中错误的是（）。

（2 分）

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;

GESP 五级 2025-03 · 单选第2题｜知识点双向链表、程序补全

第 27 题单选未作答

假设双向循环链表包含头尾哨兵结点（不存储实际内容），分别为 head 和 tail，链表中每个结点有两个指针域 prev 和 next，分别指向该结点的前驱及后继结点。下面代码实现了一个空的双向循环链表，横线上应填的最佳代码是（）。

01// 链表结点
02template <typename T>
03struct ListNode {
04    T data;
05    ListNode* prev;
06    ListNode* next;
07    // 构造函数
08    explicit ListNode(const T& val = T())
09        : data(val), prev(nullptr), next(nullptr) {}
10};
11
12struct LinkedList {
13    ListNode<T>* head;
14    ListNode<T>* tail;
15};
16
17void InitLinkedList(LinkedList* list) {
18    list->head = new ListNode<T>;
19    list->tail = new ListNode<T>;
20    ____________      // 在此处填入代码
21}

（2 分）

A

list->head->prev = list->head;
list->tail->prev = list->head;

B

list->head->next = list->tail;
list->tail->prev = list->head;

C

list->head->next = list->tail;
list->tail->next = list->head;

D

list->head->next = list->tail;
list->tail->next = nullptr;

GESP 五级 2025-03 · 单选第3题｜知识点循环链表、双向链表、程序补全

第 28 题判断未作答

要删除单链表中某个结点 p（非尾结点），但不知道头结点，可行的操作是将 p->next 的数据拷贝到 p 的数据，将 p->next 设置为 p->next->next，然后删除 p->next。

（2 分）

A

正确

B

错误

GESP 五级 2025-03 · 判断第1题｜知识点单向链表

第 29 题单选未作答

下面 C++ 代码实现双向链表。函数 is_empty() 判断链表是否为空，如果链表为空返回 true，否则返回 false。横线处不能填写（）。

01// 节点结构体
02struct Node {
03    int data;
04    Node* prev;
05    Node* next;
06};
07
08// 双向链表结构体
09struct DoubleLink {
10    Node* head;
11    Node* tail;
12    int size;
13
14    DoubleLink() {
15        head = nullptr;
16        tail = nullptr;
17        size = 0;
18    }
19
20    ~DoubleLink() {
21        Node* curr = head;
22        while (curr) {
23            Node* next = curr->next;
24            delete curr;
25            curr = next;
26        }
27    }
28
29    // 判断链表是否为空
30    bool is_empty() const {
31        ____________
32    }
33};

（2 分）

A

01return head == nullptr;

B

01return tail == nullptr;

C

01return head.data == 0;

D

01return size == 0;

GESP 五级 2025-06 · 单选第2题｜知识点双向链表、程序补全

第 30 题单选未作答

在双向链表尾部增加新节点的 append() 函数中，横线上应填写（）。

01void append(int data) {
02    Node* newNode = new Node(data, nullptr, nullptr);
03
04    if (is_empty()) {
05        head = tail = newNode;
06    } else {
07        ____________
08    }
09    ++size;
10}

（2 分）

A

tail->next = newNode;

B

newNode->prev = tail;
tail = newNode;

C

tail = newNode;
newNode->prev = tail;
tail->next = newNode;

D

tail->next = newNode;
newNode->prev = tail;
tail = newNode;

GESP 五级 2025-06 · 单选第3题｜知识点双向链表、程序补全

第 31 题单选未作答

函数 removeElements 删除单链表中所有结点值等于 val 的结点，并返回新的头结点，其中链表头结点为 head，则横线处填写（）。

01// 结点结构体
02struct Node {
03    int val;
04    Node* next;
05    Node() : val(0), next(nullptr) {}
06    Node(int x) : val(x), next(nullptr) {}
07    Node(int x, Node *next) : val(x), next(next) {}
08};
09
10Node* removeElements(Node* head, int val) {
11    Node dummy(0, head);        // 哑结点，统一处理头结点
12    Node* cur = &dummy;
13    while (cur->next) {
14        if (cur->next->val == val) {
15            ____________        // 在此填入代码
16        }
17        else {
18            cur = cur->next;
19        }
20    }
21    return dummy.next;
22}

（2 分）

A

Node* del = cur;
cur = del->next;
delete del;

B

Node* del = cur->next;
cur->next = del;
delete del;

C

Node* del = cur->next;
cur->next = del->next;
delete del;

D

Node* del = cur->next;
delete del;
cur->next = del->next;

GESP 五级 2025-09 · 单选第2题｜知识点单向链表、程序补全

第 32 题判断未作答

链表通过更改指针实现高效的结点插入与删除，但结点访问效率低、占用内存较多，且对缓存利用不友好。

（2 分）

A

正确

B

错误

GESP 五级 2025-09 · 判断第4题｜知识点单向链表

第 33 题单选未作答

对如下定义的循环单链表，横线处填写（）。

01// 循环单链表的结点
02struct Node {
03    int data;        // 数据域
04    Node* next;      // 指针域
05
06    Node(int d) : data(d), next(nullptr) {}
07};
08
09// 创建一个只有一个结点的循环单链表
10Node* createList(int value) {
11    Node* head = new Node(value);
12    head->next = head;
13    return head;
14}
15
16// 在循环单链表尾部插入新结点
17void insertTail(Node* head, int value) {
18    Node* p = head;
19    while (p->next != head) {
20        p = p->next;
21    }
22    Node* node = new Node(value);
23    node->next = head;
24    p->next = node;
25}
26
27// 遍历并输出循环单链表
28void printList(Node* head) {
29    if (head == nullptr) return;
30
31    Node* p = head;
32    ____________      // 在此处填入代码
33    cout << endl;
34}

（2 分）

A

01while (p != nullptr){
02    cout << p->data << " ";
03    p = p->next;
04}

B

01while (p->next != nullptr){
02    cout << p->data << " ";
03    p = p->next;
04}

C

01do {
02    cout << p->data << " ";
03    p = p->next;
04} while (p != head);

D

01for(; p; p=p->next){
02    cout << p->data << " ";
03}

GESP 五级 2025-12 · 单选第1题｜知识点循环链表、程序补全

第 34 题单选未作答

$N$ 个节点的双向循环链，在其中查找某个节点的平均时间复杂度是（）。

（2 分）

A

$O(1)$

B

$O(N)$

C

$O(\log N)$

D

$O(N^2)$

GESP 六级 2023-09 · 单选第14题｜知识点双向链表、循环链表、时间复杂度

第 35 题单选未作答

有关下面 C++ 代码的说法正确的是（）。

01typedef struct LinkList {
02    int data;
03
04    LinkList* next;
05
06    LinkList* prev;
07
08}LinkList,LinkNode;
09bool ListInit(LinkList* &L) {
10
11    L = new LinkNode;
12    if (!L)return false;
13
14    L->next = NULL;
15    L->prev = NULL;
16    L->data = -1;
17
18    return true;
19
20}

（2 分）

A

上述代码构成单向链表。

B

上述代码构成双向链表。

C

上述代码构成循环链表。

D

上述代码构成指针链表。

GESP 六级 2023-12 · 单选第6题｜知识点双向链表、单向链表

判分报告

客观题

重置作答

CSP-J 卷

判 分 报 告

客 观 题

打印

导出 HTML 子卷

判分报告

客观题