第三章 单链表 题目和答案
数据结构各章综合题(含答案)
第3章线性表算法题：1、线性表的单链表存储结构如下：Typedef struct LNode{int data；struct LNode *next；}LNode，*linklist；试写算法，计算单循环链表的长度。
函数头定义为：int listlength（linklist ta）{ ...}//listlength2.线性表的单链表存储结构如下：typedef struct LNode{ int data；struct LNode *next；}LNode，*linklist；试写算法，将值为x的结点插到带头结点的单链表的链尾。
函数头定义为：void insert(LNode *h, int x){ ...}// insert第4章栈和队列1、P78 题1（1）出栈序列：1,3，2，4（2）出栈序列1432可以得到，即1入栈后出栈，2，3，4依次入栈后出栈4，3，2；出栈序列1423不可能得到，因为先是1入栈后出栈，接着是4出栈，应是按234入栈后开始出栈，这时2不能先于3出栈。
2、P78 题4（1）将栈S中的数据倒置（2）将栈S1数据复制到栈S2中（3）将栈S中值为m的数据删除（4）将队列Q中数据倒置（5）将队列Q1中数据复制到Q2中3、已知一个后缀算术表达式为3 7 25 5 / * - 8 2 * + #画出在进行后缀表达式求值的过程中数值栈的变化。
答案：数值栈的变化：第6章树试问：⑴哪个结点是根结点？⑵哪个结点是D的双亲结点？⑶C的左右孩子分别是什么？⑷画出这棵二叉树。
答案:根结点为: AD的双亲结点: CC的左右孩子: 空、D2. 假设一棵二叉树的先序序列为ABDEGHJCFI 和中序序列为DBGEHJACIF 。
请画出该树。
答案：3.已知二叉树如图所示，画出二叉树中序的线索二叉树的逻辑结构图。
C(a)CBAC(d)(e)答案：GDJHKBEACFMI4. 设有一组权ＷＧ＝1,4,9,16,25,36,49,64,81,100，试画出其哈夫曼树，并计算加权的路径长度。
数据结构第三章的习题答案
数据结构第三章的习题答案数据结构第三章的习题答案在学习数据结构的过程中，习题是巩固知识和提高能力的重要方式。
第三章的习题主要涉及线性表、栈和队列的实现和操作。
本文将对这些习题进行解答，并给出详细的步骤和思路。
1. 第一题要求实现一个线性表的插入操作。
线性表是一种常用的数据结构，它的特点是元素之间存在一对一的关系。
要实现插入操作，首先需要定义线性表的数据结构，可以使用数组或链表来实现。
然后，根据插入位置，将插入位置之后的元素依次后移，为要插入的元素腾出空间。
最后，将要插入的元素放入插入位置。
2. 第二题要求实现一个栈的压栈和出栈操作。
栈是一种后进先出（LIFO）的数据结构，可以使用数组或链表来实现。
压栈操作就是将元素放入栈顶，出栈操作就是将栈顶元素取出并删除。
要实现这两个操作，可以使用一个指针来指示栈顶位置，每次压栈时将指针加一，出栈时将指针减一。
需要注意的是，栈满时不能再进行压栈操作，栈空时不能进行出栈操作。
3. 第三题要求实现一个队列的入队和出队操作。
队列是一种先进先出（FIFO）的数据结构，同样可以使用数组或链表来实现。
入队操作就是将元素放入队尾，出队操作就是将队头元素取出并删除。
与栈不同的是，队列需要维护队头和队尾两个指针。
每次入队时将元素放入队尾，并将队尾指针后移一位；出队时将队头元素取出，并将队头指针后移一位。
需要注意的是，队列满时不能再进行入队操作，队列空时不能进行出队操作。
4. 第四题要求实现一个栈的括号匹配算法。
括号匹配是一种常见的应用场景，例如编程语言中的括号匹配。
要实现这个算法，可以使用栈来辅助。
遍历字符串中的每个字符，如果是左括号，则将其压入栈中；如果是右括号，则将栈顶元素取出并判断是否与右括号匹配。
如果匹配，则继续遍历下一个字符；如果不匹配，则说明括号不匹配，返回错误。
最后，如果栈为空，则说明括号匹配成功；如果栈不为空，则说明括号不匹配，返回错误。
5. 第五题要求使用栈实现一个逆波兰表达式的计算器。
C、C++程序设计：链表单元测试与答案
一、单选题1、在一个单链表中，已知q所指结点是p所指结点的前驱结点，若在q和p之间插入结点s，则执行（）。
A.s->next=p->next;p->next=s;B.p->next=s->next; s->next=p;C.p->next=s;s->next=q;D.q->next=s;s->next=p;正确答案：D2、在一个表头指针为HL单链表中，若要向表头插入一个由指针p 指向的结点，则执行( )。
A.p一>next＝HL;HL＝p;B.HL＝p; p一>next＝HL;C.p一>next＝Hl; p＝HL;D.p一>next＝HL一>next; HL＝p;正确答案：A3、在单链表指针为p的结点之后插入指针为s的结点，正确的操作是：（）。
A.p->next=s->next;p->next=s;B.p->next=s;s->next=p->next;C.p->next=s;p->next=s->next;D.s->next=p->next;p->next=s;正确答案：D4、在表尾指针为rs的链表的后面插入指针为p的结点的正确语句为（）。
A.p->next=NULL; rs=p;B.rs->next=p; p->next=NULL;C.rs->next=p; rs->next=NULL;D.p->next=rs; rs->next=NULL;正确答案：B5、假设p为表尾指针rs的前驱指针，则删除表尾结点的正确语句为（）。
A.p->next=NULL; delete p;B.p->next=NULL; delete rs;C.p=NULL; delete rs;D.rs=NULL; delete rs;正确答案：B二、判断题1、链表存储时，各结点的存储空间可以是不连续的。
数据结构：链表单元测试与答案
一、单选题1、线性表采用链式存储时，其地址______。
A.部分地址必须是连续的B.一定是不连续的C.连续与否均可以D.必须是连续的正确答案：C2、从一个具有n个结点的单链表中查找值等于x的结点时，在查找成功的情况下，需要平均比较______个结点。
A.(n-1)/2B.(n+1)/2C.nD.n/2正确答案：B3、能够满足快速完成插入和删除运算的线性表存储结构是____。
A.有序存储B.链式存储C.顺序存储D.散列存储正确答案：B4、已知单向链表中指针p指向结点A，______表示删除A的后继结点（若存在）的链操作（不考虑回收）。
A.p—>next=pB.p=p—>next—>nextC.p=p—>nextD.p—>next=p—>next—>next正确答案：D5、在一个单向链表中，已知结点*q是*p的前趋结点，若在*q和*p 之间插入*s结点，则须执行_____。
A. p—>next= s—>next；s—>next= p；B.s—>next= p—>next；p—>next=s；C.p—>next=s； s—>next=q；D. q—>next=s； s—>next= p；正确答案：D6、已知h是指向单向加头链表的头指针，删除首元结点（第1个实际元素）的操作是_____。
A.p=h->next;free(p);h=h->next;B.p=h,h=p->next;free(p);C.p=h->next,h->next=p->next;free(p);D.free(h->next);h=h->next;正确答案：C7、就单一的____运算来说，线性表采用顺序存储比采用链式存储好（n是表长）。
A.输出所有结点B.查找结点x在表中的序号C.存取任意第i（0≤i≤n-1）个结点D.交换前两个结点的值正确答案：C8、判定以head为头指针的单向简单链表为空的条件是 ______。
数据结构二期练习题解答
数据结构第二期练习题解答第三章链表3-2试编写一个算法，在带表头结点的单链表中寻找第i个结点。
若找到，则函数返回第i个结点的地址；若找不到，则函数返回0。
【解答】template <class Type>ListNode <Type> * List <Type> ::GetANode ( int i > {//取得单链表中第i个结点地址,i从0开始计数, i < 0时返回指针0, i = 0时返回表头结点地址。
if ( i < 1 > return NULL。
ListNode <Type> * p = first。
int k = 0。
while ( p != NULL&&k < i > {p = p→link。
k++。
}return p。
}3-3 设ha和hb分别是两个带表头结点的非递减有序单链表的表头指针, 试设计一个算法, 将这两个有序链表合并成一个非递增有序的单链表。
要求结果链表仍使用原来两个链表的存储空间,不另外占用其它的存储空间。
表中允许有重复的数据。
【解答】#include <iostream.h>template <class Type> class List。
template <class Type> class ListNode{friend class List<Type>。
public:ListNode(>。
//构造函数ListNode(const Type&item>。
//构造函数private:Type data。
ListNode<Type> *link。
}。
template <class Type> class List{public:List(const Type finishied >。
链表练习题及答案
1、已知L是带表头的单链表，其P结点既不是首元结点，也不是尾元结点，a.删除p结点的直接后继的语句是11，3，14b.删除p结点的直接前驱的语句是10，12，8，11，3，14c.删除p结点的语句序列是10，7，3，14d.删除首元结点的语句序列是12，10，13，14e.删除尾元结点的语句序列是9，11，3，14（1）p=p->next;(2) p->next=p;(3)p->next=p->next->next;(4)p=p->next->next;(5)while(p)p=p->next;(6)whlie(Q->next){p=Q;Q=Q->next;}(7)while(p->next!=Q)p=p->next;(8)while(p->next->next!=Q)p=p->next;(9)while(p->next->next)p=p->next;(10)Q=p;(11)Q=p->next;(12)p=L;(13)L=L->next;(14)free(Q);2、已知L是带表头的单链表，其P结点既不是首元结点，也不是尾元结点，a.在p结点后插入s结点的语句序列是4，1b.在p结点前插入s结点的语句序列是7，11，8，4，1c.在表首插入s结点的语句序列是5，12d.在表尾插入s结点的语句序列是7，9，4，1或11，9，1，61.p-> next =s;2.p-> next=p-> next-> next;3.p->next=s->next;4.s->next=p-> next;5.s-> next=L;6.s->next=NULL;7.q=p ;8.while(p->next!=q) p=p->next;9.while(p->next!=NULL) p=p->next;10.p =q;11.p=L;12.L=s;13.L=P;3、已知P结点是某双向链表的中间结点，从下列提供的答案中选择合适的语句序列a.在P结点后插入S结点的语句序列是12，7，3，6b.在P结点前插入S结点的语句序列是13，8，5，4c.删除p结点的直接后继结点的语句序列是15，1，11，18d.删除p结点的直接前驱结点的语句序列是16，2，10，18e.删除p结点的语句序列是9，14，171.P->next=P->next->next;2.P->priou=P->priou->priou;3.P->next=S;4.P->priou=S;5.S->next=P;6.S->priou=P;7.S->next=P->next;8.S->priou=P->priou;9.P->priou->next=P->next;10.P->priou->next=P;11.P->next->priou=P;12.P->next->priou=S;13.P->priou->next=S;14.P->next->priou=P->priou;15.Q=p->next;16.Q=P->priou;17.free(P);18.free(Q);。
数据结构-C语言版：单链表例题
delmax是用类程序设计语言描述的，删除带表 头结点的单链表 lk 中数据域值最大的结点的算法。 链表中的结点 node 包括一个整型数据域 data 和一 个指向后继结点的指针 域 next，如图所示。
data next
lk
node
类程序设计语言描述形式 p 指向的结点的数据域用 p^.data表示、指针域用 p^. next 表示。算法中，“←”为赋值号，nil 为空指 针。
据域值最大结点的
（前
{ m←p^.data;
驱结点或后继结点）。
(3); } q←p; p←p^.next }
6）若算法中的链表是循环单链表，
则程序中的“p<>nil”这个条件应
改为
。
7）设 lk 单链表中的结点数据域值
q←r^.next;
依次为 3，1，7，5，4，则程序执
(4); dispose(q)
Algorithm delmaxl(lk) //lk 为单链表的头指针//
{ r←lk;
// m 为整型量//
p←lk^. next;
//p,q,r 为辅助指针//
if p<>nil
{ m←p^.data;
(1);
p←p^.next;
while p<>nil
{ if
(2)
回答以下问题：
5）该算法中的 r 变量最终指向数
行结束时，m=
。
}
}
参考答案
(1) q←p (2) p^.data>m (3) r←q (4) r^.next←q^.next (5) 前驱结点 (6) p!=lk (7) 7
C语言链表题目及答案
下面哪种选项描述了链表的特点？A) 可以随机访问元素B) 拥有固定大小的内存空间C) 元素之间通过指针连接D) 可以自动调整大小答案: C在链表中，头节点的作用是什么？A) 存储链表的长度B) 存储链表的最后一个节点C) 存储链表的第一个节点D) 存储链表的中间节点答案: C下面哪种选项描述了双向链表的特点？A) 每个节点只有一个指针指向下一个节点B) 每个节点只有一个指针指向上一个节点C) 每个节点同时拥有指向前一个节点和后一个节点的指针D) 只能从链表的一端进行操作答案: C在链表中，删除一个节点的操作涉及修改哪些指针？A) 只需要修改被删除节点的前一个节点的指针B) 只需要修改被删除节点的后一个节点的指针C) 需要修改被删除节点的前一个节点和后一个节点的指针D) 不需要修改任何指针答案: C在链表的尾部添加一个新节点的操作复杂度是多少？A) O(1)B) O(n)C) O(log n)D) O(n^2)答案: A如何遍历链表的所有节点？A) 使用for循环B) 使用while循环C) 使用递归函数D) 使用if语句答案: B在链表中，如何找到特定值的节点？A) 使用线性搜索B) 使用二分搜索C) 使用递归搜索D) 使用栈搜索答案: A链表和数组相比，哪个更适合频繁插入和删除操作？A) 链表B) 数组C) 二叉树D) 堆栈答案: A在链表中，如何在指定位置插入一个新节点？A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 不需要修改任何指针答案: A链表的头指针指向什么？A) 链表的第一个节点B) 链表的最后一个节点C) 链表的中间节点D) 链表的空节点答案: A链表中节点的个数称为什么？A) 链表的长度B) 链表的高度C) 链表的宽度D) 链表的容量答案: A在链表中，如何删除指定值的节点？A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 不需要修改任何指针答案: A单链表的最后一个节点指向什么？A) 链表的第一个节点B) 链表的最后一个节点C) NULLD) 链表的中间节点答案: C双向链表相比于单向链表的优势是什么？A) 占用更少的内存空间B) 遍历速度更快C) 可以从任意方向遍历D) 插入和删除操作更快答案: C在链表中，如何找到倒数第n个节点？A) 遍历整个链表B) 使用递归函数C) 使用栈数据结构D) 使用双指针技巧答案: D链表的删除操作和数组的删除操作的时间复杂度分别是什么？A) 链表的删除操作为O(1)，数组的删除操作为O(n)B) 链表的删除操作为O(n)，数组的删除操作为O(1)C) 链表的删除操作为O(n)，数组的删除操作为O(n)D) 链表的删除操作为O(1)，数组的删除操作为O(1)答案: A在链表中，如何判断链表是否为空？A) 检查头指针是否为NULLB) 检查尾指针是否为NULLC) 检查链表的长度是否为0D) 检查链表的第一个节点是否为NULL答案: A链表的逆序操作是指什么？A) 删除链表中的节点B) 反转链表中节点的顺序C) 插入节点到链表的尾部D) 在链表中查找指定值的节点答案: B在链表中，如何查找指定值的节点？A) 使用线性搜索B) 使用二分搜索C) 使用递归搜索D) 使用栈搜索答案: A在双向链表中，如何删除指定值的节点？A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 不需要修改任何指针答案: A链表的插入操作和数组的插入操作的时间复杂度分别是什么？A) 链表的插入操作为O(1)，数组的插入操作为O(n)B) 链表的插入操作为O(n)，数组的插入操作为O(1)C) 链表的插入操作为O(n)，数组的插入操作为O(n)D) 链表的插入操作为O(1)，数组的插入操作为O(1)答案: A如何删除单向链表中的重复节点？A) 使用递归算法B) 使用双指针技巧C) 使用栈数据结构D) 不需要额外操作，链表会自动去重答案: B链表的优势之一是什么？A) 随机访问速度快B) 占用内存空间少C) 插入和删除操作高效D) 支持高级操作如排序和搜索答案: C在链表中，如何找到中间节点？A) 遍历整个链表B) 使用递归函数C) 使用栈数据结构D) 使用快慢指针技巧答案: D在链表中，如何在尾部添加一个新节点？A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 创建一个新节点并更新尾指针答案: D链表的查找操作的时间复杂度是多少？A) O(1)B) O(log n)C) O(n)D) O(n^2)答案: C在双向链表中，如何找到倒数第n个节点？A) 从头节点开始遍历B) 从尾节点开始遍历C) 使用递归函数D) 使用双指针技巧答案: B链表的删除操作的时间复杂度是多少？A) O(1)B) O(log n)C) O(n)D) O(n^2)答案: A链表和数组相比，哪个更适合频繁插入和删除操作？A) 链表B) 数组C) 哈希表D) 栈答案: A如何判断链表是否有环？A) 使用线性搜索B) 使用递归算法C) 使用快慢指针技巧D) 使用栈数据结构答案: C在链表中，如何反转链表的顺序？A) 使用递归算法B) 使用栈数据结构C) 使用双指针技巧D) 使用循环迭代答案: D在链表中，如何删除所有节点？A) 依次删除每个节点B) 修改头指针为NULLC) 修改尾指针为NULLD) 不需要额外操作，链表会自动清空答案: A链表的头节点是什么？A) 链表的第一个节点B) 链表的最后一个节点C) 链表的中间节点D) 链表的空节点答案: A在链表中，如何插入一个新节点到指定位置之前？A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 不需要修改任何指针答案: A在链表中，如何删除指定位置的节点？A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 不需要修改任何指针答案: A单向链表和双向链表的区别是什么？A) 单向链表只有一个指针指向下一个节点，双向链表有两个指针分别指向前一个节点和后一个节点B) 单向链表只能从头到尾遍历，双向链表可以从头到尾或者从尾到头遍历C) 单向链表只能在尾部添加节点，双向链表可以在头部和尾部都添加节点D) 单向链表只能包含整型数据，双向链表可以包含任意类型的数据答案: A链表的删除操作和数组的删除操作的时间复杂度分别是什么？A) 链表的删除操作为O(1)，数组的删除操作为O(n)B) 链表的删除操作为O(n)，数组的删除操作为O(1)C) 链表的删除操作为O(n)，数组的删除操作为O(n)D) 链表的删除操作为O(1)，数组的删除操作为O(1)答案: A如何判断两个链表是否相交？A) 比较链表的长度是否相等B) 比较链表的头节点是否相等C) 比较链表的尾节点是否相等D) 比较链表中的所有节点是否相等答案: B链表和数组的主要区别是什么？A) 链表是一种线性数据结构，数组是一种非线性数据结构B) 链表的长度可变，数组的长度固定C) 链表支持随机访问，数组只能顺序访问D) 链表的插入和删除操作效率高，数组的访问效率高答案: B在链表中，如何找到倒数第k个节点？A) 从头节点开始遍历，直到倒数第k个节点B) 从尾节点开始遍历，直到倒数第k个节点C) 使用递归函数查找倒数第k个节点D) 使用双指针技巧，一个指针先移动k步，然后两个指针同时移动直到第一个指针到达链表末尾答案: D在链表中，如何判断是否存在环？A) 使用线性搜索，检查是否有重复的节点B) 使用递归算法，判断节点是否已经访问过C) 使用栈数据结构，检查节点是否已经入栈D) 使用快慢指针技巧，如果两个指针相遇，则存在环答案: D如何将两个有序链表合并成一个有序链表？A) 创建一个新链表，依次比较两个链表的节点并插入新链表中B) 将第一个链表的尾节点指向第二个链表的头节点C) 将第二个链表的尾节点指向第一个链表的头节点D) 使用递归算法，依次比较两个链表的节点并合并答案: A在链表中，如何删除重复的节点？A) 使用递归算法，遍历链表并删除重复的节点B) 使用双指针技巧，依次比较相邻节点并删除重复的节点C) 使用栈数据结构，检查节点是否已经入栈并删除重复的节点D) 不需要额外操作，链表会自动去重答案: B链表的优点是什么？A) 占用内存空间少B) 插入和删除操作高效C) 支持高级操作如排序和搜索D) 可以随机访问任意位置的元素答案: B。
数据结构课后习题答案第三章
第三章栈和队列(参考答案)// 从数据结构角度看，栈和队列是操作受限的线性结构，其顺序存储结构// 和链式存储结构的定义与线性表相同，请参考教材，这里不再重复。
3.1 1 2 3 4 2 1 3 4 3 2 1 4 4 3 2 11 2 4 3 2 1 4 3 3 2 4 11 32 4 23 14 3 4 2 11 3 42 234 11 4 32 2 43 1设入栈序列元素数为n，则可能的出栈序列数为C2n n=(1/n+1)*(2n!/(n!)2)3.2 证明：由j<k和p j<p k说明p j在p k之前出栈，即在k未进栈之前p j已出栈，之后k进栈，然后p k出栈；由j<k和p j>p k说明p j在p k之后出栈，即p j被p k压在下面，后进先出。
由以上两条，不可能存在i<j<k使p j<p k<p i。
也就是说，若有1，2，3顺序入栈，不可能有3，1，2的出栈序列。
3.3 void sympthy(linklist *head, stack *s)//判断长为n的字符串是否中心对称{ int i=1; linklist *p=head->next;while (i<=n/2) // 前一半字符进栈{ push(s,p->data); p=p->next; }if (n % 2 !==0) p=p->next;// 奇数个结点时跳过中心结点while (p && p->data==pop(s)) p=p->next;if (p==null) printf(“链表中心对称”)；else printf(“链表不是中心对称”)；} // 算法结束3.4int match()//从键盘读入算术表达式，本算法判断圆括号是否正确配对（init s;//初始化栈sscanf(“%c”,&ch);while (ch!=’#’) //’#’是表达式输入结束符号switch (ch){ case ’(’: push(s,ch); break;case ’)’: if (empty(s)) {printf(“括号不配对”); exit(0);}pop(s);}if (!empty(s)) printf(“括号不配对”);else printf(“括号配对”);} // 算法结束3.5typedef struct // 两栈共享一向量空间{ ElemType v[m]; // 栈可用空间0—m-1int top[2] // 栈顶指针}twostack;int push(twostack *s,int i, ElemType x)// 两栈共享向量空间,i是0或1，表示两个栈，x是进栈元素，// 本算法是入栈操作{ if (abs(s->top[0] - s->top[1])==1) return(0);// 栈满else {switch (i){case 0: s->v[++(s->top)]=x; break;case 1: s->v[--(s->top)]=x; break;default: printf(“栈编号输入错误”); return(0);}return(1); // 入栈成功}} // 算法结束ElemType pop(twostack *s,int i)// 两栈共享向量空间,i是0或1，表示两个栈，本算法是退栈操作{ ElemType x;if (i!=0 && i!=1) return(0);// 栈编号错误else {switch (i){case 0: if(s->top[0]==-1) return(0);//栈空else x=s->v[s->top--];break;case 1: if(s->top[1]==m) return(0);//栈空else x=s->v[s->top++]; break;default: printf(“栈编号输入错误”);return(0);}return(x); // 退栈成功}} // 算法结束ElemType top (twostack *s,int i)// 两栈共享向量空间,i是0或1，表示两个栈，本算法是取栈顶元素操作{ ElemType x;switch (i){case 0: if(s->top[0]==-1) return(0);//栈空else x=s->v[s->top]; break;case 1: if(s->top[1]==m) return(0);//栈空else x=s->v[s->top]; break;default: printf(“栈编号输入错误”);return(0);}return(x); // 取栈顶元素成功} // 算法结束3．6void Ackerman(int m,int n)// Ackerman 函数的递归算法{ if (m==0) return(n+1);else if (m!=0 && n==0) return(Ackerman(m-1,1);else return(Ackerman(m-1,Ackerman(m,n-1))} // 算法结束3．7(1) linklist *init(linklist *q)// q是以带头结点的循环链表表示的队列的尾指针，本算法将队列置空{ q=(linklist *)malloc(sizeof(linklist));//申请空间，不判断空间溢出q->next=q;return (q);} // 算法结束(2) linklist *enqueue(linklist *q，ElemType x)// q是以带头结点的循环链表表示的队列的尾指针，本算法将元素x入队{ s=(linklist *)malloc(sizeof(linklist));//申请空间，不判断空间溢出s->next=q->next; // 将元素结点s入队列q->next=s;q=s; // 修改队尾指针return (q);} // 算法结束(3) linklist *delqueue(linklist *q)//q是以带头结点的循环链表表示的队列的尾指针，这是出队算法{ if (q==q->next) return (null); // 判断队列是否为空else {linklist *s=q->next->next; // s指向出队元素if (s==q) q=q->next; // 若队列中只一个元素，置空队列else q->next->next=s->next;// 修改队头元素指针free (s); // 释放出队结点}return (q);} // 算法结束。
单链表、双链表、循环链表和静态链表的习题
单链表、双链表、循环链表和静态链表的习题一、单项选择题1.关于线性表的顺序存储结构和链式存储结构的描述中，正确的是（）。
Ⅰ.线性表的顺序存储结构优于其链式存储结构Ⅱ.链式存储结构比顺序存储结构能更方便地表示各种逻辑结构Ⅲ.如频繁使用插入和删除结点操作，顺序存储结构更优于链式存储结构Ⅳ.顺序存储结构和链式存储结构都可以进行顺序存取A. Ⅰ、Ⅱ、ⅢB. Ⅱ、ⅣC. Ⅱ、ⅢD. Ⅲ、Ⅳ2.对于一个线性表既要求能够进行较快速地插入和删除，又要求存储结构能反映数据之间的逻辑关系，则应该用（）。
A.顺序存储方式B.链式存储方式C.散列存储方式D.以上均可以3.对于顺序存储的线性表，其算法的时间复杂度为O(1)的运算应该是（）。
A.将n个元素从小到大排序B.删除第i个元素（1<i<n）C.改变第i个元素的值（1<=i<=n）D.在第i个元素后插入一个新元素（1<=i<=n）4.下列关于线性表说法正确的是（）。
Ⅰ.顺序存储方式只能用于存储线性结构Ⅱ.取线性表的第i个元素的时间同i的大小有关Ⅲ.静态链表需要分配较大的连续空间，插入和删除不需要移动元素Ⅳ.在一个长度为n的有序单链表中插入一个新结点并仍保持有序的时间复杂度为O(n) Ⅴ.若用单链表来表示队列，则应该选用带尾指针的循环链表A. Ⅰ、ⅡB.Ⅰ、Ⅲ、Ⅳ、ⅤC. Ⅳ、ⅤD. Ⅲ、Ⅳ、Ⅴ5.设线性表中有2n个元素，（）在单链表上实现要比在顺序表上实现效率更高。
A.删除所有值为x的元素B.在最后一个元素的后面插入一个新元素C.顺序输出前k个元素D.交换第i个元素和第2n-i-l个元素的值(i=0,…, n-1)6.在一个单链表中，已知q所指结点是p所指结点的前驱结点，若在q和p之间插入结点s，则执行（）。
A .s->next=p->next;p->next=s; B.p->next=s->next; s->next=p;C. q->next=s;s->next=p;D. p->next=s;s->next=q;7.给定有n个元素的一维数组，建立一个有序单链表的最低时间复杂度是（）。
单向链表练习题
单向链表练习题单向链表练习题链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。
在计算机科学中，链表常用于实现其他数据结构，如栈和队列。
掌握链表的基本操作对于编程人员来说是至关重要的。
在本篇文章中，我们将通过一些练习题来加深对单向链表的理解。
1. 反转链表题目：给定一个单向链表，将其反转。
示例：输入：1 -> 2 -> 3 -> 4 -> 5输出：5 -> 4 -> 3 -> 2 -> 1解析：反转链表是一个常见的链表操作。
我们可以使用三个指针prev、curr和next来完成反转。
初始时，prev指向null，curr指向头节点。
我们需要将curr的next指针指向prev，然后移动prev、curr和next指针，直到遍历完整个链表。
2. 链表中倒数第k个节点题目：给定一个单向链表，找到链表中倒数第k个节点。
示例：输入：1 -> 2 -> 3 -> 4 -> 5，k = 2输出：4解析：要找到链表中倒数第k个节点，我们可以使用双指针法。
首先，我们让一个指针p1指向链表的头节点，然后让另一个指针p2指向链表的第k个节点。
接下来，同时移动p1和p2指针，直到p2指向链表的末尾。
此时，p1指向的节点就是倒数第k个节点。
3. 合并两个有序链表题目：给定两个有序链表，将它们合并为一个有序链表。
示例：输入：1 -> 2 -> 4, 1 -> 3 -> 4输出：1 -> 1 -> 2 -> 3 -> 4 -> 4解析：合并两个有序链表是一个常见的链表操作。
我们可以使用递归或迭代的方式来实现。
递归的思路是比较两个链表的头节点，将较小的节点作为合并后的链表的头节点，并递归地合并剩余的节点。
迭代的思路是使用一个额外的指针来指向合并后的链表的末尾，然后比较两个链表的头节点，将较小的节点接在末尾，并更新指针和链表头。
数据结构c语言版课后习题答案
数据结构c语言版课后习题答案数据结构是计算机科学中的一个重要概念，它涉及到组织、管理和存储数据的方式，以便可以有效地访问和修改数据。
C语言是一种广泛使用的编程语言，它提供了丰富的数据结构实现方式。
对于学习数据结构的C语言版课程，课后习题是巩固理论知识和提高实践能力的重要手段。
数据结构C语言版课后习题答案1. 单链表的实现在C语言中，单链表是一种常见的线性数据结构。
它由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针。
实现单链表的基本操作通常包括创建链表、插入节点、删除节点、遍历链表等。
答案：- 创建链表：定义一个链表结构体，然后使用动态内存分配为每个节点分配内存。
- 插入节点：根据插入位置，调整前后节点的指针，并将新节点插入到链表中。
- 删除节点：找到要删除的节点，调整其前后节点的指针，然后释放该节点的内存。
- 遍历链表：从头节点开始，使用指针遍历链表，直到达到链表尾部。
2. 二叉树的遍历二叉树是一种特殊的树形数据结构，其中每个节点最多有两个子节点。
二叉树的遍历是数据结构中的一个重要概念，常见的遍历方式有前序遍历、中序遍历、后序遍历和层序遍历。
答案：- 前序遍历：先访问根节点，然后递归遍历左子树，最后递归遍历右子树。
- 中序遍历：先递归遍历左子树，然后访问根节点，最后递归遍历右子树。
- 后序遍历：先递归遍历左子树，然后递归遍历右子树，最后访问根节点。
- 层序遍历：使用队列，按照从上到下，从左到右的顺序访问每个节点。
3. 哈希表的实现哈希表是一种通过哈希函数将键映射到表中一个位置来访问记录的数据结构。
它提供了快速的数据访问能力，但需要处理哈希冲突。
答案：- 哈希函数：设计一个哈希函数，将键映射到哈希表的索引。
- 哈希冲突：使用链地址法、开放地址法或双重哈希法等解决冲突。
- 插入操作：计算键的哈希值，将其插入到对应的哈希桶中。
- 删除操作：找到键对应的哈希桶，删除相应的键值对。
4. 图的表示和遍历图是一种复杂的非线性数据结构，由顶点（节点）和边组成。
第三章单链表题目和答案
第三章单链表题⽬和答案第2章⾃测卷答案⼀、填空1.顺序表中逻辑上相邻的元素的物理位置相互相邻。
单链表中逻辑上相邻的元素的物理位置不相邻。
2.在单链表中，除了⾸元结点外，任⼀结点的存储位置由其直接前驱结点值域指⽰。
3．在n个结点的单链表中要删除已知结点*p，需找到它的地址。
⼆、判断正误（在正确的说法后⾯打勾，反之打叉）1. 链表的每个结点中都恰好包含⼀个指针。
X2. 链表的物理存储结构具有同链表⼀样的顺序。
X3. 链表的删除算法很简单，因为当删除链中某个结点后，计算机会⾃动地将后续的各个单元向前移动。
X4. 线性表的每个结点只能是⼀个简单类型，⽽链表的每个结点可以是⼀个复杂类型。
Y5. 顺序表结构适宜于进⾏顺序存取，⽽链表适宜于进⾏随机存取。
Y6. 顺序存储⽅式的优点是存储密度⼤，且插⼊、删除运算效率⾼。
X7. 线性表在物理存储空间中也⼀定是连续的。
X8. 线性表在顺序存储时，逻辑上相邻的元素未必在存储的物理位置次序上相邻。
X9. 顺序存储⽅式只能⽤于存储线性结构。
X10. 线性表的逻辑顺序与存储顺序总是⼀致的。
X三、单项选择题（A）1. 链接存储的存储结构所占存储空间：（A）分两部分，⼀部分存放结点值，另⼀部分存放表⽰结点间关系的指针（B）只有⼀部分，存放结点值（C）只有⼀部分，存储表⽰结点间关系的指针（D）分两部分，⼀部分存放结点值，另⼀部分存放结点所占单元数（B）2. 链表是⼀种采⽤存储结构存储的线性表；（A）顺序（B）链式（C）星式（D）⽹状（D）3. 线性表若采⽤链式存储结构时，要求内存中可⽤存储单元的地址:（A）必须是连续的（B）部分地址必须是连续的（C）⼀定是不连续的（D）连续或不连续都可以（B）4．线性表Ｌ在情况下适⽤于使⽤链式结构实现。
（Ａ）需经常修改Ｌ中的结点值（Ｂ）需不断对Ｌ进⾏删除插⼊（Ｃ）Ｌ中含有⼤量的结点（Ｄ）Ｌ中结点结构复杂（C）5．单链表的存储密度（Ａ）⼤于1；（Ｂ）等于1；（Ｃ）⼩于1；（Ｄ）不能确定（A）6、在单链表的⼀个结点中有个指针。
帮你掌握数据结构(第三章系列经典试题及答案)
第3章栈和队列一、填空题（每空1分，共15分）1。
向量、栈和队列都是线性结构，可以在向量的任何位置插入和删除元素；对于栈只能在栈顶插入和删除元素；对于队列只能在队尾插入和队首删除元素。
2。
栈是一种特殊的线性表，允许插入和删除运算的一端称为栈顶。
不允许插入和删除运算的一端称为栈底。
3。
队列是被限定为只能在表的一端进行插入运算，在表的另一端进行删除运算的线性表。
4。
在一个循环队列中，队首指针指向队首元素的前一个位置。
5。
在具有n个单元的循环队列中，队满时共有n-1 个元素.6. 向栈中压入元素的操作是先存入元素，后移动栈顶指针。
7.从循环队列中删除一个元素时，其操作是先移动队首指针，后取出元素。
8。
〖00年统考题〗带表头结点的空循环双向链表的长度等于0。
解：二、判断正误(）（每小题1分，共10分）（×）1。
是一个复杂类型。
错，线性表是逻辑结构概念，可以顺序存储或链式存储，与元素数据类型无关。
（×）2。
在表结构中最常用的是线性表,栈和队列不太常用。
错，不一定吧？调用子程序或函数常用，CPU中也用队列。
（√）3. 栈是一种对所有插入、删除操作限于在表的一端进行的线性表，是一种后进先出型结构。
（√）4. 对于不同的使用者，一个表结构既可以是栈,也可以是队列，也可以是线性表.正确，都是线性逻辑结构，栈和队列其实是特殊的线性表，对运算的定义略有不同而已。
( ×）5. 栈和链表是两种不同的数据结构。
错,栈是逻辑结构的概念，是特殊殊线性表，而链表是存储结构概念,二者不是同类项。
（×)6. 栈和队列是一种非线性数据结构。
错,他们都是线性逻辑结构,栈和队列其实是特殊的线性表,对运算的定义略有不同而已。
（√）7。
栈和队列的存储方式既可是顺序方式，也可是链接方式。
（√)8。
两个栈共享一片连续内存空间时，为提高内存利用率，减少溢出机会，应把两个栈的栈底分别设在这片内存空间的两端。
（×）9. 队是一种插入与删除操作分别在表的两端进行的线性表，是一种先进后出型结构。
第三章 链表 基本题
第三章链表基本题3.2.1单项选择题1.不带头结点的单链表head为空的判定条件是A.head=NULLB.head->next=NULLC.head->next=headD.head!=NULL2.带头接待点的单链表head为空的判定条件是A.head=NULLB.head->next=NULLC.head->next=headD.head!=NULL3.非空的循环单链表head的尾结点(由p所指向)满足A.p->head=NULLB.p=NULLC.p->next=headD.p=head4.在循环双链表p的所指结点之后插入s所指结点的操作是A.p->right=s; s->left=p; p->right->lefe=s; s->right=p->right;B.p->right=s; p->right->left=s; s->lefe=p; s->right=p->right;C.s->lefe=p; s->right=p->right; p->right=s; p->right->left=s;D.s->left=p; s->right=p->right; p->right->left=s; p->right=s;5.在一个单链表中，已知q所指结点是所指结点p的前驱结点，若在q和p之间插入结点S，则执行A.s->next=p->next; p->next=s;B.p->next=s->next; s->next=p;C.q->next=s; s->next=p;D.p->next=s; s->next=q;6.在一个单链表中，若p所指结点不是最后结点，在p之后插入s所指结点，则执行A.s->next=p; p->next=s;B.s->next=p->next; p->next=s;C.s->next=p->next; p=s;D.p->next=s; s->next=p;7.在一个单链表中，若删除p所指结点的后续结点，则执行A.p->next=p->next->next;B.p=p->next; p->next=p->next->next;C.p->next=p->nextD.p=p->next->next8.假设双链表结点的类型如下：typedef struct linknode{int data; /*数据域*/Struct linknode *llink; /*llink是指向前驱结点的指针域*/Struct linknode *rlink; /*rlink是指向后续结点的指针域*/}bnode下面给出的算法段是要把一个所指新结点作为非空双向链表中的所指结点的前驱结点插入到该双链表中，能正确完成要求的算法段是A.q->rling=p; q->llink=p->llink; p->llink=q;p->llink->rlink=q;B.p->llink=q; q->rlink=p; p->llink->rlink=q; q->llink=p->llink;C.q->llink=p->llink; q->rlink=p; p->llink->rlink=q; p->llink=q;D.以上都不对9.从一个具有n个结点的有序单链表中查找其值等于x结点时，在查找成功的情况下，需平均比较（）个结点。
数据结构作业及答案
第一章绪论一、选择题1.数据结构是一门研究非数值计算的程序设计问题中计算机的1以及它们之间的2和运算等的学科。
1 A.数据元素 B.计算方法 C.逻辑存储 D.数据映像2 A.结构 B.关系 C.运算 D.算法2.数据结构被形式地定义为(K, R)，其中K是1的有限集，R是K上的2有限集。
1 A.算法 B.数据元素 C.数据操作 D.逻辑结构2 A.操作 B.映像 C.存储 D.关系3.在数据结构中，从逻辑上可以把数据结构分成。
A.动态结构和静态结构B.紧凑结构和非紧凑结构C.线性结构和非线性结构D.内部结构和外部结构4.线性结构的顺序存储结构是一种1的存储结构，线性表的链式存储结构是一种2的存储结构。
A.随机存取 B.顺序存取 C.索引存取 D.散列存取5.算法分析的目的是1，算法分析的两个主要方面其一是指2，其二是指正确性和简单性。
1 A.找出数据结构的合理性 B.研究算法中的输入和输出的关系C.分析算法的效率以求改进D.分析算法的易懂性和文档性2 A.空间复杂度和时间复杂度 B.研究算法中的输入和输出的关系C.可读性和文档性D.数据复杂性和程序复杂性k6.计算机算法指的是1，它必须具备输入、输出和2等5个特性。
1 A.计算方法 B.排序方法 C.解决问题的有限运算序列 D.调度方法2 A.可执行性、可移植性和可扩充性 B.可行性、确定性和有穷性C.确定性、有穷性和稳定性D.易读性、稳定性和安全性7.线性表的逻辑顺序与存储顺序总是一致的，这种说法。
A.正确 B.不正确8线性表若采用链式存储结构时，要求内存中可用存储单元的地址。
A.必须连续的B.部分地址必须连续的C.一定是不续的D连续不连续都可以9.以下的叙述中，正确的是。
A.线性表的存储结构优于链式存储结构 B.二维数组是其数据元素为线性表的线性表C.栈的操作方式是先进先出D.队列的操作方式是先进后出10.每种数据结构都具备三个基本运算：插入、删除和查找，这种说法。
单链表算法题
单链表算法题以下是单链表算法题：1. 判断单链表是否有环题目描述：给定一个链表的头节点 head，判断链表中是否有环。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。
示例：输入：head = [1,2,3,4], pos = -1输出：false解释：链表中没有环。
解题思路：使用快慢指针法，快指针每次移动两个节点，慢指针每次移动一个节点。
如果存在环，快指针最终会追上慢指针并相遇；如果不存在环，快指针会先到达链表尾部。
2. 单链表插入元素题目描述：给定一个链表的头节点 head 和要插入的位置 pos，以及要插入的元素 value。
在链表中插入新元素后，返回插入后的链表。
示例：输入：head = [1,2,3], pos = 2, value = 4输出：[1,2,4,3]解释：在位置 2 处插入元素 4，得到新的链表 [1,2,4,3]。
解题思路：在链表中插入元素需要先找到要插入的位置的前驱节点，然后将新节点插入到前驱节点和后继节点之间。
如果插入位置为链表第一个位置，则需要创建新节点并将其指向头节点；如果插入位置超过了链表的长度，则无法插入元素。
3. 单链表删除元素题目描述：给定一个链表的头节点 head 和要删除的位置 pos，删除链表中第 pos 个节点（从 1 开始计数），并返回删除后的链表。
示例：输入：head = [1,2,3,4], pos = 2输出：[1,3,4]解释：删除位置 2 上的节点 2，得到新的链表 [1,3,4]。
解题思路：在链表中删除元素需要先找到要删除位置的前驱节点，然后将前驱节点的 next 指针指向要删除节点的后继节点，最后释放要删除节点的内存空间。
如果删除位置为链表第一个位置，则需要修改头节点；如果删除位置超过了链表的长度，则无法删除元素。
数据结构第3单元课后练习答案
//构造函数 template <class T> LinkedStack<T>::LinkedStack() { top=NULL; } //析构函数 template <class T> LinkedStack<T>::~LinkedStack() { Node<T> *q; while (top) { q=top->link; delete top; top=q; } }
答：2）和3）不能。对2）中的E，B，D而言，E最先 出栈则表明，此时B和D均在栈中，由于，B先于D进 栈，所以应有D先出栈。同理3）也不能。 (1)能。 push,pop,push,pop,push,pop,push,pop,push,pop (4)能。 push,push,push,push,push,pop,pop,pop,pop,pop
第三单元 栈与队列
链式堆栈的单链表 √ ）。 栈和队列都是线性表，只是在插入和删除时受到了一些限制（× ）。
设A、B、C、D、E五个元素依次进栈(进栈后可立即出栈)， 问能否得到下列序列。若能得到，则给出相应的push和 pop序列；若不能，则说明理由。 1) A,B,C,D,E 2) A,C,E,B,D 3) C,A,B,D,E 4) E,D,C,B,A
//解法三 不用栈，也不用数组，只用一个计数器top bool match(char a[],int n) { int top=-1; for (int i=0;i<n;i++) if (a[i]=='(') top++; else if (a[i]==')') if (top>-1) top--; //继续检查 else return true; //不匹配 if (top>-1) return true; //不匹配 return false; //匹配 }
链表练习题及答案
链表练习题及答案1、已知L是带表头的单链表，其P结点既不是首元结点，也不是尾元结点，a.删除p结点的直接后继的语句是11，3，14b.删除p结点的直接前驱的语句是10，12，8，11，3，14c.删除p结点的语句序列是10，7，3，14d.删除首元结点的语句序列是12，10，13，14e.删除尾元结点的语句序列是9，11，3，14（1）p=p->next;(2) p->next=p;(3)p->next=p->next->next;(4)p=p->next->next;(5)while(p)p=p->next;(6)whlie(Q->next){p=Q;Q=Q->next;}(7)while(p->next!=Q)p=p->next;(8)while(p->next->next!=Q)p=p->next;(9)while(p->next->next)p=p->next;(10)Q=p;(11)Q=p->next;(12)p=L;(13)L=L->next;(14)free(Q);2、已知L是带表头的单链表，其P结点既不是首元结点，也不是尾元结点，a.在p结点后插入s结点的语句序列是4，1b.在p结点前插入s结点的语句序列是7，11，8，4，1c.在表首插入s结点的语句序列是5，12d.在表尾插入s结点的语句序列是7，9，4，1或11，9，1，61.p-> next =s;2.p-> next=p-> next-> next;3.p->next=s->next;4.s->next=p-> next;5.s-> next=L;6.s->next=NULL;7.q=p ;8.while(p->next!=q) p=p->next;9.while(p->next!=NULL) p=p->next;10.p =q;11.p=L;12.L=s;13.L=P;3、已知P结点是某双向链表的中间结点，从下列提供的答案中选择合适的语句序列a.在P结点后插入S结点的语句序列是12，7，3，6b.在P结点前插入S结点的语句序列是13，8，5，4c.删除p结点的直接后继结点的语句序列是15，1，11，18d.删除p结点的直接前驱结点的语句序列是16，2，10，18e.删除p结点的语句序列是9，14，171.P->next=P->next->next;2.P->priou=P->priou->priou;3.P->next=S;4.P->priou=S;5.S->next=P;6.S->priou=P;7.S->next=P->next;8.S->priou=P->priou;9.P->priou->next=P->next;10.P->priou->next=P;11.P->next->priou=P;12.P->next->priou=S;13.P->priou->next=S;14.P->next->priou=P->priou;15.Q=p->next;16.Q=P->priou;17.free(P);18.free(Q);。
数据结构第三章习题
数据结构第三章习题3．1 单项选择题2.一个栈的入栈序列a, b, c, d, e, 则栈的不可能的输出序列是。
A. edcbaB. DecbaC. DceabD. abcde3. 若已知一个栈的入栈序列是1，2，3，………..n, 其输出序列为p1, p2, p3,……,pn, 若p1=n, 则pi为。
A.i.B. n=IC. n- i+1D.不确定4．栈结构通常采用的两种存储结构是。
A. 顺序存储结构和链表存储结构B. 散链方式和索引方式C.链表存储结构和数组D. 线性存储结构和非线性存储结构5．判定一个栈ST（最多元素为m0）为空的条件是。
A. ST->top<>0B. ST->top=0C.ST->top<>m0D.ST->top=m06．判定一个栈ST（最多元素为m0）为栈满的条件是。
A. ST->top!=0B.ST->top==0C.ST->top!=m0D.ST->top==m07.栈的特点是，队列的特点是。
A先进先出 B. 先进后出8. 一个队列的入栈序列是1，2，3，4，则队列的输出序列是。
A. 4,3,2,1B. 1,2,3,4C. 1,4,3,2D. 3,2,4,19. 判定一个队列QU(最多元素为m0)为空的条件是。
A.QU->rear- QU->front==m0B.QU->rear- QU->front-1==m0C.QU->front== QU->rearD. QU->front== QU->rear+110.判定一个队列QU（最多元素为m0）为满队列的条件是。
A.QU->rear- QU->front==m0B.QU->rear- QU->front-1==m0C.QU->front== QU->rearD.QU->front== QU->rear+111. 判定一个循环队列QU(最多元素为m0)为空的条件是。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
第2章自测卷答案一、填空1.顺序表中逻辑上相邻的元素的物理位置相互相邻。
单链表中逻辑上相邻的元素的物理位置不相邻。
2.在单链表中，除了首元结点外，任一结点的存储位置由其直接前驱结点值域指示。
3．在n个结点的单链表中要删除已知结点*p，需找到它的地址。
二、判断正误（在正确的说法后面打勾，反之打叉）1. 链表的每个结点中都恰好包含一个指针。
X2. 链表的物理存储结构具有同链表一样的顺序。
X3. 链表的删除算法很简单，因为当删除链中某个结点后，计算机会自动地将后续的各个单元向前移动。
X4. 线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。
Y5. 顺序表结构适宜于进行顺序存取，而链表适宜于进行随机存取。
Y6. 顺序存储方式的优点是存储密度大，且插入、删除运算效率高。
X7. 线性表在物理存储空间中也一定是连续的。
X8. 线性表在顺序存储时，逻辑上相邻的元素未必在存储的物理位置次序上相邻。
X9. 顺序存储方式只能用于存储线性结构。
X10. 线性表的逻辑顺序与存储顺序总是一致的。
X三、单项选择题（A）1. 链接存储的存储结构所占存储空间：（A）分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针（B）只有一部分，存放结点值（C）只有一部分，存储表示结点间关系的指针（D）分两部分，一部分存放结点值，另一部分存放结点所占单元数（B）2. 链表是一种采用存储结构存储的线性表；（A）顺序（B）链式（C）星式（D）网状（D）3. 线性表若采用链式存储结构时，要求内存中可用存储单元的地址:（A）必须是连续的（B）部分地址必须是连续的（C）一定是不连续的（D）连续或不连续都可以（B）4．线性表Ｌ在情况下适用于使用链式结构实现。
（Ａ）需经常修改Ｌ中的结点值（Ｂ）需不断对Ｌ进行删除插入（Ｃ）Ｌ中含有大量的结点（Ｄ）Ｌ中结点结构复杂（C）5．单链表的存储密度（Ａ）大于1；（Ｂ）等于1；（Ｃ）小于1；（Ｄ）不能确定（A）6、在单链表的一个结点中有个指针。
A、1B、2C、3D、4（D）7、设一个链表最常用的操作是在末尾插入结点和删除尾结点，则选用最节省时间。
A、单链表B、单循环链表C、带尾指针的单循环链表D、带头结点的双循环链表（B ）8、在单链表指针为p的结点之后插入指针为s的结点，正确的操作是。
A、p->next=s;s->next=p->next;B、s->next=p->next;p->next=s;C、p->next=s;p->next=s->next;D、p->next=s->next;p->next=s;（C ）9、对于一个头指针为head的带头结点的单链表，判定该表为空表的条件是。
A、head==NULLB、head→next==NULLC、head→next==headD、head!=NULL （head指向谁的)（c）10、在双向链表指针p的结点前插入一个指针q的结点操作是。
A、p->prior=q;q->next=p;p->prior->next=q;q->prior=q;B、p->prior=q;p->prior->next=q;q->next=p;q->prior=p->prior;C、q->next=p;q->prior=p->prior;p->Prior->next=q;p->prior=q;D、q->prior=p->prior;q->next=q;p->prior=q;p->prior=q;（A ）11、在一个单链表中，若删除P所指结点的后续结点，则执行。
A、p-next=p->next->next;B、p=p->next;p->next=p->next->next;C、p->next=p->next;D、p=p->next->next;（A）12、不带头结点的单链表head为空的判定条件是。
A、head=NULLB、head->next=NULLC、head->next=headD、head!=NULL（B）13、链表不具有的特点是。
A、插入、删除不需要移动元素B、可随机访问任一元素C、不必事先估计存储空间D、所需空间与线性长度成正比×）1. 链表的每个结点中都恰好包含一个指针。
答：错误。
链表中的结点可含多个指针域，分别存放多个指针。
例如，双向链表中的结点可以含有两个指针域，分别存放指向其直接前趋和直接后继结点的指针。
（×）2. 链表的物理存储结构具有同链表一样的顺序。
错，链表的存储结构特点是无序，而链表的示意图有序。
（×）3. 链表的删除算法很简单，因为当删除链中某个结点后，计算机会自动地将后续的各个单元向前移动。
错，链表的结点不会移动，只是指针内容改变。
（×）4. 线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。
错，混淆了逻辑结构与物理结构，链表也是线性表！且即使是顺序表，也能存放记录型数据。
（×）5. 顺序表结构适宜于进行顺序存取，而链表适宜于进行随机存取。
错，正好说反了。
顺序表才适合随机存取，链表恰恰适于“顺藤摸瓜”（×）6. 顺序存储方式的优点是存储密度大，且插入、删除运算效率高。
错，前一半正确，但后一半说法错误，那是链式存储的优点。
顺序存储方式插入、删除运算效率较低，在表长为n的顺序表中，插入和删除一个数据元素，平均需移动表长一半个数的数据元素。
（×）7. 线性表在物理存储空间中也一定是连续的。
错，线性表有两种存储方式，顺序存储和链式存储。
后者不要求连续存放。
（×）8. 线性表在顺序存储时，逻辑上相邻的元素未必在存储的物理位置次序上相邻。
错误。
线性表有两种存储方式，在顺序存储时，逻辑上相邻的元素在存储的物理位置次序上也相邻。
（×）9. 顺序存储方式只能用于存储线性结构。
错误。
顺序存储方式不仅能用于存储线性结构，还可以用来存放非线性结构，例如完全二叉树是属于非线性结构，但其最佳存储方式是顺序存储方式。
（后一节介绍）（×）10. 线性表的逻辑顺序与存储顺序总是一致的。
错，理由同7。
链式存储就无需一致。
三、填空题1、在带头结点的单链表L中，若要删除第一个元素，则需要执行下列三条语句：_______________；L→next＝U→next；free（U）。
2、在单链表L中，若要在指针P所指结点之后插入由指针S所指的结点，则需执行下列语句：S->next=P->next；______________；3、在带有头结点的单链表L中，第一个元素结点的指针是_____________。
4、双循环链表L中由指针P所指向的某结点为尾结点的条件是_______________。
1. 【严题集2.2①】在顺序表中插入或删除一个元素，需要平均移动表中一半元素，具体移动的元素个数与表长和该元素在表中的位置有关。
2.线性表中结点的集合是有限的，结点间的关系是一对一的。
3. 向一个长度为n的向量的第i个元素(1≤i≤n+1)之前插入一个元素时，需向后移动n-i+1 个元素。
4. 向一个长度为n的向量中删除第i个元素(1≤i≤n)时，需向前移动 n-i 个元素。
5. 在顺序表中访问任意一结点的时间复杂度均为 O(1) ，因此，顺序表也称为随机存取的数据结构。
6. 【严题集2.2①】顺序表中逻辑上相邻的元素的物理位置必定相邻。
单链表中逻辑上相邻的元素的物理位置不一定相邻。
7. 【严题集2.2①】在单链表中，除了首元结点外，任一结点的存储位置由其直接前驱结点的链域的值指示。
8．在n个结点的单链表中要删除已知结点*p，需找到它的前驱结点的地址，其时间复杂度为O（n）。
1、设有两个单链表L和L1，各结点结构如下：试画出该链表的结构图，并编写算法，判断单链表L1是否与单链表L相同，相同返回1，不同返回0。
五、简答题1. 【严题集2.3②】试比较顺序存储结构和链式存储结构的优缺点。
在什么情况下用顺序表比链表好？答：①顺序存储时，相邻数据元素的存放地址也相邻（逻辑与物理统一）；要求内存中可用存储单元的地址必须是连续的。
优点：存储密度大（＝1？），存储空间利用率高。
缺点：插入或删除元素时不方便。
②链式存储时，相邻数据元素可随意存放，但所占存储空间分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针优点：插入或删除元素时很方便，使用灵活。
缺点：存储密度小（<1），存储空间利用率低。
顺序表适宜于做查找这样的静态操作；链表宜于做插入、删除这样的动态操作。
若线性表的长度变化不大，且其主要操作是查找，则采用顺序表；若线性表的长度变化较大，且其主要操作是插入、删除操作，则采用链表。
2 .【严题集2.1①】描述以下三个概念的区别：头指针、头结点、首元结点（第一个元素结点）。
在单链表中设置头结点的作用是什么？答：首元结点是指链表中存储线性表中第一个数据元素a的结点。
为了操作方便，通常在链1表的首元结点之前附设一个结点，称为头结点，该结点的数据域中不存储线性表的数据元素，其作用是为了对链表进行操作时，可以对空表、非空表的情况以及对首元结点进行统一处理。
头指针是指向链表中第一个结点（或为头结点或为首元结点）的指针。
若链表中附设头结点，则不管线性表是否为空表，头指针均不为空。
否则表示空表的链表的头指针为空。
这三个概念对单链表、双向链表和循环链表均适用。
是否设置头结点，是不同的存储结构表示同一逻辑结构的问题。
头结点头指针首元结点简而言之，头指针是指向链表中第一个结点（或为头结点或为首元结点）的指针；头结点是在链表的首元结点之前附设的一个结点；数据域内只放空表标志和表长等信息（内放头指针？那还得另配一个头指针）的结点。
首元素结点是指链表中存储线性表中第一个数据元素a1。