第2章线性表(课堂作业)
第二章线性表习题及答案
第二章线性表习题及答案一、基础知识题2.1 试描述头指针、头结点、开始结点的区别、并说明头指针和头结点的作用。
答：始结点是指链表中的第一个结点，也就是没有直接前趋的那个结点。
链表的头指针是一指向链表开始结点的指针(没有头结点时)，单链表由头指针唯一确定，因此单链表可以用头指针的名字来命名。
头结点是我们人为地在链表的开始结点之前附加的一个结点。
有了头结点之后，头指针指向头结点，不论链表否为空，头指针总是非空。
而且头指针的设置使得对链表的第一个位置上的操作与在表其他位置上的操作一致(都是在某一结点之后)。
2.2 何时选用顺序表、何时选用链表作为线性表的存储结构为宜?答：在实际应用中，应根据具体问题的要求和性质来选择顺序表或链表作为线性表的存储结构，通常有以下几方面的考虑：1.基于空间的考虑。
当要求存储的线性表长度变化不大，易于事先确定其大小时，为了节约存储空间，宜采用顺序表；反之，当线性表长度变化大，难以估计其存储规模时，采用动态链表作为存储结构为好。
2.基于时间的考虑。
若线性表的操作主要是进行查找，很少做插入和删除操作时，采用顺序表做存储结构为宜；反之，若需要对线性表进行频繁地插入或删除等的操作时，宜采用链表做存储结构。
并且，若链表的插入和删除主要发生在表的首尾两端，则采用尾指针表示的单循环链表为宜。
2.3 在顺序表中插入和删除一个结点需平均移动多少个结点?具体的移动次数取决于哪两个因素?答：在等概率情况下，顺序表中插入一个结点需平均移动n/2个结点。
删除一个结点需平均移动(n-1)/2个结点。
具体的移动次数取决于顺序表的长度n以及需插入或删除的位置i。
i 越接近n则所需移动的结点数越少。
2.4 为什么在单循环链表中设置尾指针比设置头指针更好?答：尾指针是指向终端结点的指针，用它来表示单循环链表可以使得查找链表的开始结点和终端结点都很方便，设一带头结点的单循环链表，其尾指针为rear，则开始结点和终端结点的位置分别是rear->next->next 和rear, 查找时间都是O(1)。
第2章线性表习题参考答案资料
习题二参考答案一、选择题1. 链式存储结构的最大优点是( D )。
A. 便于随机存取B.存储密度高C.无需预分配空间D.便于进行插入和删除操作2. 假设在顺序表｛a o,a i,……，a n—1｝中，每一个数据元素所占的存储单元的数目为4,且第0个数据元素的存储地址为100,则第7个数据元素的存储地址是( D )。
A. 106B. 107C.124D.1283. 在线性表中若经常要存取第i个数据元素及其前趋，则宜采用( A )存储方式。
A.顺序表B.带头结点的单链表C.不带头结点的单链表D.循环单链表4. 在链表中若经常要删除表中最后一个结点或在最后一个结点之后插入一个新结点，则宜采用( C )存储方式。
A.顺序表B.用头指针标识的循环单链表C.用尾指针标识的循环单链表D.双向链表5. 在一个单链表中的p和q两个结点之间插入一个新结点，假设新结点为S,则修改链的java语句序列是(D )。
A. s.setNext(p); q.setNext(s);B. p.setNext(s.getNext()); s.setNext(p);C. q.setNext(s.getNext()); s.setNext(p);D. p.setNext(s); s.setNext(q);6. 在一个含有n个结点的有序单链表中插入一个新结点，使单链表仍然保持有序的算法的时间复杂度是(C )。
A. O(1)B. O(log 2n)C. O(n)D. O(n2)7. 要将一个顺序表｛a0,a 1,……，a n-J中第i个数据元素a (0 < i < n-1)删除，需要移动(B )个数据元素。
A. iB. n-i-1C. n-iD. n-i+18. 在带头结点的双向循环链表中的p结点之后插入一个新结点s，其修改链的java语句序列是(D )。
A. p.setNext(s); s.setPrior(p); p.getNext().setPrior(s);s.setNext(p.getPrior());B. p.setNext(s); p.getNext().setPrior(s); s.setPrior(p);s.setNext(p.getNext());C. s.setPrior(p); s.setNext(p.getNext()); p.setNext(s);p.getNext().setPrior(s);D. s.setNext(p.getNext()); s.setPrior(p); p.getNext().setPrior(s);p.setNext(s);9. 顺序表的存储密度是(B ),而单链表的存储密度是( A )。
第二章线性表作业参考答案
第二章线性表作业参考答案第二章线性表2.2 何时选用顺序表、何时选用链表作为线性表的存储结构为宜?答：在实际应用中，应根据具体问题的要求和性质来选择顺序表或链表作为线性表的存储结构，通常有以下几方面的考虑：1.基于空间的考虑。
当要求存储的线性表长度变化不大，易于事先确定其大小时，为了节约存储空间，宜采用顺序表；反之，当线性表长度变化大，难以估计其存储规模时，采用动态链表作为存储结构为好。
2.基于时间的考虑。
若线性表的操作主要是进行查找，很少做插入和删除操作时，采用顺序表做存储结构为宜；反之，若需要对线性表进行频繁地插入或删除等的操作时，宜采用链表做存储结构。
并且，若链表的插入和删除主要发生在表的首尾两端，则采用尾指针表示的单循环链表为宜。
2.6 下述算法的功能是什么?LinkList Demo(LinkList L){ // L 是无头结点单链表ListNode *Q,*P;if(L&&L->next){Q=L;L=L->next;P=L;while (P->next) P=P->next;P->next=Q; Q->next=NULL;}return L;}// Demo答：该算法的功能是：将开始结点摘下链接到终端结点之后成为新的终端结点，而原来的第二个结点成为新的开始结点，返回新链表的头指针。
2.9 设顺序表L是一个递增有序表，试写一算法，将x插入L中，并使L仍是一个有序表。
答：因已知顺序表L是递增有序表，所以只要从顺序表终端结点（设为i位置元素）开始向前寻找到第一个小于或等于x的元素位置i后插入该位置即可。
在寻找过程中，由于大于x的元素都应放在x之后，所以可边寻找，边后移元素，当找到第一个小于或等于x的元素位置i时，该位置也空出来了。
算法如下：#define ListSize 100 // 假定表空间大小为100typedef int DataType;//假定DataType的类型为int型typedef struct{DataType data[ListSize];// 向量data用于存放表结点int length; // 当前的表长度} Seqlist;//以上为定义表结构void InsertIncreaseList( Seqlist *L , Datatype x ){int i;if ( L->length>=ListSize)Error(“overflow");for ( i=L -> length ; i>0 && L->data[ i-1 ] > x ; i--)L->data[ i ]=L->data[ i ] ; // 比较并移动元素L->data[ i ] =x;L -> length++;}2.13 设 A和B是两个单链表，其表中元素递增有序。
第二章课后作业答案
第二章线性表习题(答案)1.描述以下三个概念的区别：头指针，头结点，首元素结点。
首元结点是指链表中存储线性表中第一个数据元素a1的结点。
为了操作方便，通常在链表的首元结点之前附设一个结点，称为头结点，该结点的数据域中不存储线性表的数据元素，其作用是为了对链表进行操作时，可以对空表、非空表的情况以及对首元结点进行统一处理。
头指针是指向链表中第一个结点（或为头结点或为首元结点）的指针。
若链表中附设头结点，则不管线性表是否为空表，头指针均不为空。
否则表示空表的链表的头指针为空。
2.填空：（1）在顺序表中插入或删除一个元素，需要平均移动一半元素，具体移动的元素个数与插入或删除的位置有关。
（2）在顺序表中，逻辑上相邻的元素，其物理位置也相邻。
在单链表中，逻辑上相邻的元素，其物理位置不一定相邻。
（3）在带头结点的非空单链表中，头结点的存储位置由头指针指示，首元素结点的存储位置由头结点的next域指示，除首元素结点外，其它任一元素结点的存储位置由其直接前趋的next域指示。
3．已知L是无表头结点的单链表，且P结点既不是首元素结点，也不是尾元素结点。
按要求从下列语句中选择合适的语句序列。
a. 在P结点后插入S结点的语句序列是：（4）、（1）。
b. 在P结点前插入S结点的语句序列是：（7）、（11）、（8）、（4）、（1）。
c. 在表首插入S结点的语句序列是：（5）、（12）。
d. 在表尾插入S结点的语句序列是：（11）、（9）、（1）、（6）。
供选择的语句有：（1）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;4.设线性表存于a[n]中且递增有序。
《数据结构》吕云翔编著第2章线性表习题解答
《数据结构》吕云翔编著第2章线性表习题解答数据结构第2章线性表习题解答一、习题解答1. 假设有一个线性表L={a1, a2, ..., an}，设计一种算法，将线性表的所有元素逆置。
解答：可以使用两个指针i和j，分别指向线性表的第一个元素和最后一个元素，然后交换这两个指针所指向的元素，接着i向后移动一个单位，j向前移动一个单位，再次交换他们所指向的元素。
依次类推，直到i和j指针相遇为止。
这样就完成了线性表的逆置。
2. 设线性表L={a1, a2, ..., an}，设计一个算法，删除其中所有值为x 的元素。
解答：可以使用一个指针i遍历线性表，当遇到一个元素值等于x 时，将该元素删除，同时将后面的元素依次前移一位。
直到整个线性表遍历完毕。
3. 设有两个线性表LA={a1, a2, ..., am}和LB={b1, b2, ..., bn}，其中元素递增有序排列。
设计一个算法，将LA和LB合并成一个新的线性表LC，且元素递增有序排列。
解答：可以使用两个指针i和j分别指向LA和LB的第一个元素，并且使用一个指针k指向LC的最后一个元素。
比较LA[i]和LB[j]的大小，将较小的元素插入到LC的末尾，然后相应指针后移一位，直到其中一个指针到达对应线性表的末尾。
最后，将剩余的元素插入到LC的末尾，即可得到合并后的线性表LC。
4. 设线性表L={a1, a2, ..., an}，设计一个算法，找出其中最大的元素以及最大元素的位置。
解答：可以使用一个变量max记录当前遍历到的最大元素，初始化为L[0]，同时使用变量position记录最大元素的位置，初始值也为0。
然后遍历整个线性表，若遇到L[i]大于max，则更新max为L[i]，同时更新position为i。
遍历完毕后，max就是最大元素，position就是最大元素的位置。
5. 在线性表L={a1, a2, ..., an}中，设计一个算法，找出倒数第k个位置上的元素。
数据结构课后习题答案第二章 线性表
数据结构课后习题答案第二章线性表线性表是数据结构中最基本、最常用的一种数据结构，它按照线性的顺序存储数据元素，具有访问方便、插入和删除操作简单等特点。
第二章的习题主要涉及线性表的基本概念、顺序表、链表以及线性表的应用等内容。
以下是对第二章习题的详细解答。
1. 题目：给定一个具有n（1≤n≤10）个整数的一个线性表，设计一个时间复杂度为O(n)的算法，判断其中是否存在相同的元素。
解答：我们可以基于哈希表实现该算法。
首先创建一个哈希表，用于存储每个整数对应的出现次数。
然后遍历线性表中的每个元素，将其作为键，出现次数作为值存入哈希表中。
在遍历的同时，判断当前元素是否已经在哈希表中存在，若存在则说明存在相同的元素，算法结束；若不存在，则继续遍历下一个元素。
最终，如果遍历完所有元素都没有找到相同的元素，则可以得出结论线性表中不存在相同的元素。
2. 题目：设计一个算法，将一个线性表L（已知长度为n）中所有元素逆置。
解答：我们可以使用两个指针，一个指向线性表的首元素，另一个指向线性表的尾元素，然后交换两个指针所指向的元素，然后将指针向中间移动，继续进行交换操作，直到两个指针相遇为止。
通过这样的操作，就可以将线性表中所有元素逆置。
3. 题目：设计一个算法，将一个顺序表L的所有元素逆置，并将逆置后的顺序表存放到一个新的顺序表中。
解答：首先创建一个新的顺序表R，将L中的元素逆序遍历并依次插入到R中即可实现逆置。
具体过程为，遍历L中的每个元素，依次将其插入到R的首位置。
经过遍历后，R中的元素顺序和L中的元素顺序完全相反，即实现了逆置操作。
4. 题目：设计一个算法，删除一个单链表中所有值为x的节点。
解答：我们可以使用两个指针，一个指向当前节点，另一个指向当前节点的前一个节点。
遍历链表时，判断当前节点的值是否为x，若是，则将当前节点的前一个节点的指针指向当前节点的下一个节点，然后删除当前节点。
若不是，则继续遍历下一个节点。
第二章线性表作业参考答案PPT课件
else
while(p->data<=maxk && p!=NULL) { r=p; //删除链结点p
p=p->next;
free(r);
} q->next=p; //删除若干链结点后，重新建立链接
}// DELmink_maxk
2020/10/13
7
作业2.2
设线性表A=(a1,a2,…,an)，B=(b1,b2,…,bm)， 试写一个按下列规则合并A、B为线性表C的 算法，即使得
C=(a1,b1,a2,b2,…,am,bm,bm+1,…,bn) 当m<=n 或 C=(a1,b1,a2,b2,…,an,bn,an+1,…,am) 当m>n
线性表A、B和C均为单链表作存储结构，且C表 利用A表和B表中的结点空间构表。注意：单 链表的长度值m和n均未显式存储。
2020/10/13
8
算法：
status COMBINE(linklist A, linklist B, linklist &C) {
C=A; a=A->next; b=B->next;
if(j==B.length) //表示A.elem[i]不在B中，将其放到 C中
C.elem[k++]=A.elem[i]; } C.length=k; }
2020/10/13
3
作业1.2 试写一个算法，实现顺序表的就地 逆置。
数据结构课后习题答案第2章
第 2 章线性表2005-07-14第 2 章线性表课后习题讲解1. 填空⑴在顺序表中，等概率情况下，插入和删除一个元素平均需移动（）个元素，具体移动元素的个数与（）和（）有关。
【解答】表长的一半，表长，该元素在表中的位置⑵顺序表中第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的存储地址是（）。
【解答】108【分析】第5个元素的存储地址=第1个元素的存储地址＋(5－1)×2=108⑶设单链表中指针p 指向结点A，若要删除A的后继结点（假设A存在后继结点），则需修改指针的操作为（）。
【解答】p->next=(p->next)->next⑷单链表中设置头结点的作用是（）。
【解答】为了运算方便【分析】例如在插入和删除操作时不必对表头的情况进行特殊处理。
⑸非空的单循环链表由头指针head指示，则其尾结点（由指针p所指）满足（）。
【解答】p->next=head【分析】如图2-8所示。
⑹在由尾指针rear指示的单循环链表中，在表尾插入一个结点s的操作序列是（）；删除开始结点的操作序列为（）。
【解答】s->next =rear->next; rear->next =s; rear =s;q=rear->next->next; rear->next->next=q->next; delete q;【分析】操作示意图如图2-9所示：⑺一个具有n个结点的单链表，在指针p所指结点后插入一个新结点的时间复杂度为（）；在给定值为x的结点后插入一个新结点的时间复杂度为（）。
【解答】Ο(1)，Ο(n)【分析】在p所指结点后插入一个新结点只需修改指针，所以时间复杂度为Ο(1)；而在给定值为x的结点后插入一个新结点需要先查找值为x的结点，所以时间复杂度为Ο(n)。
⑻可由一个尾指针唯一确定的链表有（）、（）、（）。
【解答】循环链表，循环双链表，双链表2. 选择题⑴线性表的顺序存储结构是一种（）的存储结构，线性表的链接存储结构是一种（）的存储结构。
线性表答案
第二章线性表答案(总8页)--本页仅作为文档封面，使用时请直接删除即可----内页可以根据需求调整合适字体及大小--数据结构与算法上机作业第二章线性表一、选择题1、若长度为n的线性表采用顺序存储结构，在其第i个位置插入一个新的元素算法的时间复杂度为 C 。
A. O(log2n)B. O(1)C. O(n)D. O(n2)2、以下关于线性表的说法中，不正确的是 C 。
A. 线性表中的数据元素可以是数字、字符、结构等不同类型B. 线性表中包含的数据元素个数不是任意的C. 线性表中的每一个结点都有且只有一个直接前驱和直接后继D. 存在这样的线性表：表中各结点都没有直接前驱和直接后继3、在有n个结点的顺序表上做插入、删除结点运算的时间复杂度为 B 。
A. O(1)B. O(n)C. O(n2)D. O(log2n)4、等概率情况下，在有n个结点的顺序表上做插入结点操作，需平均移动的结点数目为C 。
提示：插入的位置有n+1个，移动总数为：1+2+3+……+nA. nB. (n-1)/2C. n/2D. (n+1)/25、在一个长度为n的顺序存储的线性表中查找值为x的元素时，平均查找长度(及x同元素的平均比较次数，假定查找每个元素的概率都相等)为 C 。
A. nB. n/2C. (n+1)/2D. (n-1)/26、在顺序表中，只要知道 D ，就可以求出任一结点的存储地址。
A. 基地址B. 结点大小C. 向量大小D. 基地址和结点大小7、将两个各有n个元素的有序表归并为一个有序表，其最少的比较次数是A 。
A. nB. 2n-1C. 2nD. n-18、线性表采用链表存储时其存储地址要求 D 。
A. 必须是连续的B. 部分地址必须是连续的C. 必须是不连续的D. 连续的和不连续的都可以9、下面关于线性表的描述中，错误的是 B 。
A. 线性表采用顺序存储，必须占用一片连续的存储单元B. 线性表采用顺序存储，便于进行插入和删除操作C. 线性表采用链式存储，不必占用一片连续的存储单元D. 线性表采用链式存储，便于插入和删除操作10、向具有n个结点的有序单链表中插入一个新结点并仍然有序的时间复杂度是 BA. O(1)B. O(n)C. O(n2)D. O(log2n)11、在一个带头结点的单链表HL中，若要向表头插入一个由指针p指向的结点，则执行的语句是 D 。
第2章-线性表习题及参考答案
}
时间复杂度：O(elenum)
2、void ReElemDelete(SqList &A)
{
if (A.length<=1) return; //少于一个元素不处理
i=2; //从第2个以后的元素开始处理
j=1; //删除重复值后的表的最后一个元素的位置，初始的位置为1
while (i<A.length )
}
m=rand(); /* m取随机数*/
i=0; /*因为我没办法删除head指向的节点，只会删除head的下一节点，所以只能从0数起。*/
while(head->next!=head) /*当剩下最后一个人时，退出循环*/
{
if(i==m)
{
ptr=head->next; /* ptr记录数到m的那个人的位置*/
5．假设长度大于1的循环单链表中，既无头结点也无头指针，p为指向该链表中某一结点的指针，编写一个函数删除该结点的前趋结点。
五上机实习题目
1．Josephu问题
Josephu问题为：设编号为1，2，…n的n个人围坐一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到m的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。
第二章线性表习题
一判断题
1．线性表的逻辑顺序与存储顺序总是一致的。
2．顺序存储的线性表可以按序号随机存取。
3．顺序表的插入和删除操作不需要付出很大的时间代价，因为每次操作平均只有近一半的元素需要移动。
4．线性表中的元素可以是各种各样的，但同一线性表中的数据元素具有相同的特性，因此是属于同一数据对象。
数据结构第二章线性表作业习题及答案——北理工版
第二章（线性表）作业（参见《数据结构题集》第2章部分P13）一、在什么情况下用顺序表比链表好？（题集2.3）二、单选题：1、线性表的顺序存储是通过何种方式表示元素之间的逻辑关系。
①后继元素的地址②元素的存储顺序③左右孩子地址④后继元素的数组下标2、在线性表顺序存储结构中，在第I个元素之前插入新元素一般需要。
①移动元素②修改头指针③修改指针④申请新的结点空间3、在长度为n的顺序表的第I个元素之前插入一新元素的算法的时间复杂度为。
①O(n) ②O(1)③O(n2) ④O(Log2n)三、编写顺序表的判空操作算法。
四、编写顺序表求表长操作的算法。
五、已知L是带表头结点的非空单链表，且P结点既不是首元结点，也不是尾元结点，试从下列(1) ~ (14)提供的答案中选择合适的语句序列填空。
（题集2.7）a.删除P结点的直接后继结点的语句序列是_______ __________。
b.删除P结点的直接前驱结点的语句序列是_______________ __。
c.删除P结点的语句序列是_____________________________ _ _。
d.删除首元结点的语句序列是___________________________ __。
e.删除尾元结点的语句序列是____ _________________________。
(1)p = p->next;(2)p->next = p;(3)p->next = p->next->next;(4)p = p->next->next;(5)while ( p!=NULL ) p=p->next;(6)while ( q->next!=NULL ) { 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!=NULL ) p=p->next;(10)q=p;(11)q=p->next;(12)p=l;(13)l=l->next;(14)free(q);六、算法设计。
PTA 第二章 线性表作业及答案 数据结构平时作业
A. 38 B. 43 C. 26 D. 29
2、完成下列填空题（每空3分，共9分）。
1．在顺序表L中第i个位置上插入一个新的元素e：
Status ListInsert_Sq(SqList &L , int i , ET e){
}
for( j=L.length ; j>=i ; --j )
___L.elem[j]=L.elem[j-1]____；
L.elem[j]=e ;
++L.length_______；
return OK;
}
2.删除双向(DuLinkList L, DuLinkList p) {
}
for (k=0,i=0;i<A.length;i++)
{
if(A.data[i]==’#’) k++;
else A.data[i-k]= A.data[i];
}
A.length= A.length-k;
}
2.（15分）已知带头结点的单循环链表L，编写算法实现删除其中所有值为e的数据元素结点。
（要求：类型定义、算法描述和算法时间复杂度分析）
return;
p = L;
while (p->next != L)
{
if (p->next->data != e)
P = p->next;
else
{ q = p->next;p->next = q->next; free(q);｝
}
}
时间复杂度为O(n)。（2分）
第二章 线性表作业解答
第二章线性表作业1、简述下列概念的区别：头指针，头结点，首元结点（第一个元素结点）。
请理解，不必书写。
2、填空：（1）在顺序表中插入或删除一个元素，需要平均移动____个元素，具体移动的元素个数与______有关。
（2）顺序表中逻辑上相邻的元素的物理位置______紧邻。
单链表中逻辑上相邻的元素的物理位置______紧邻。
（3）单链表中，除了元首结点外，任一结点的存储位置由_____指示。
（4）在单链表中设置头结点的作用是_____。
3、简答：什么情况下用顺序表比链表好？请理解，不必书写。
4、已知L是无表头结点的单链表，且P结点既不是首元结点，也不是尾元结点，试从一下选项中选择合适的语句序列。
A、在P结点后插入S结点的语句序列是________B、在P结点后插入S结点的语句序列是________C、在表首插入S结点的语句序列是________D、在表尾插入S结点的语句序列是________（1）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->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;5、指出以下算法中的错误和低效（即费时）之处，并将其改写为一个既正确又高效的算法。
Status Delete K （SqList &a, int i, int k）{//本过程从顺序存储结构的线性表a//中删除第i个元素起的k个元素if (i<1‖k<0‖i+k>a.length) return INFEASIBLE //参数不合法else {for(count=1;count<k; count++) {// 删除一个元素for(j=a.length;j>=i+1; j--) a.elem[j-1]=a.elem[j];a.length--；}return OK ；} //DeleteK6、设顺序表va 中的数据元素递增有序，试写一算法，将x 插入到顺序表适当位置上，以保持该表的有序性。
数据结构练习题 第二章 线性表 习题及答案
while(________________)
{ p=p->next; j++; }
if(i==j) return(p);
else return(NULL);
}
26.以下为单链表的定位运算，分析算法，请在____处填上正确的语句。
int locate_lklist(lklist head,datatype x)
if(________)return(i);
else return(0);
}
15.对于顺序表的定位算法，若以取结点值与参数X的比较为标准操作，平均时间复杂性量级为________。求表长和读表元算法的时间复杂性为________。
16.在顺序表上，求表长运算LENGTH（L）可通过输出________实现，读表元运算
36．当且仅当两个串的______相等并且各个对应位置上的字符都______时，这两个串相等。一个串中任意个连续字符组成的序列称为该串的______串，该串称为它所有子串的______串。
37．串的顺序存储有两种方法：一种是每个单元只存一个字符，称为______格式，另一种是每个单元存放多个字符，称为______格式。
2.为了满足运算的封闭性，通常允许一种逻辑结构出现不含任何结点的情况。不含任何结点的线性结构记为______或______。
3.线性结构的基本特征是:若至少含有一个结点，则除起始结点没有直接______外，其他结点有且仅有一个直接______;除终端结点没有直接______外，其它结点有且仅有一个直接______.
① 数据元素 ② 数据项 ③ 数据 ④ 数据结构
4．顺序表是线性表的 （ ）
①链式存储结构 ②顺序存储结构 ③ 索引存储结构 ④ 散列存储结构
线性表课堂作业
线性表表示与实现作业一、关于线性表我们已经知道了哪些？（一）填空题1．当线性表的元素总数基本稳定，且很少进行插入和删除操作，但要求以最快的速度存取线性表中的元素时，应采用_______存储结构。
2．线性表L=（a1,a2,…,an）用数组表示，假定删除表中任一元素的概率相同，则删除一个元素平均需要移动元素的个数是________。
3．设单链表的结点结构为(data,next)，next为指针域，已知指针px指向单链表中data 为x的结点，指针py指向data为y的新结点 , 若将结点y插入结点x之后，则需要执行以下语句:_______； ______。
4．在单链表中设置头结点的作用是________。
5．对于一个具有n个结点的单链表，在已知的结点*p后插入一个新结点的时间复杂度为________,在给定值为x的结点后插入一个新结点的时间复杂度为________。
6．根据线性表的链式存储结构中每一个结点包含的指针个数，将线性链表分成________和_______；而又根据指针的连接方式，链表又可分成________和________。
7．在双向循环链表中,向p所指的结点之后插入指针f所指的结点，其操作是_______、_______、_______、________。
8．顺序存储结构是通过________表示元素之间的关系的;链式存储结构是通过________表示元素之间的关系的。
9. 循环单链表的最大优点是：________。
10. 带头结点的双循环链表L为空表的条件是：________。
（二）判断题1. 链表中的头结点仅起到标识的作用。
( )2. 顺序存储结构的主要缺点是不利于插入或删除操作。
( )3．线性表采用链表存储时，结点和结点内部的存储空间可以是不连续的。
( )4．顺序存储方式插入和删除时效率太低，因此它不如链式存储方式好。
( )5．顺序存储方式只能用于存储线性结构。
( )6．集合与线性表的区别在于是否按关键字排序。
数据结构第二章习题
第2章线性表一、单项选择题1．线性表是具有n个_________的有限序列。
A．表元素B．字符C．数据元素D．数据项2．线性表是_________。
A．一个有限序列，可以为空B．一个有限序列，不可以为空C．一个无限序列，可以为空D．一个无限序列，不可以为空3．线性表采用链表存储时，其地址_________。
A．必须是连续的B．一定是不连续的C．部分地址必须是连续的D．连续与否均可以4．链表不具备的特点是_________。
A．可随机访问任一结点B．插入删除不需要移动元素C．不必事先估计存储空间D．所需空间与其长度成正比5．设线性表有n个元素，以下操作中，_________在顺序表上实现比在链表上实现效率更高。
A．输出第i(1≤i≤n)个元素值B．交换第1个元素与第2个元素的值C．顺序输出这n个元素的值D．输出与给定值x相等的元素在线性表中的序号6．设线性表中有2n个元素，以下操作中，_________在单链表上实现要比在顺序表上实现效率更高。
A．删除指定的元素B．在最后一个元素的后面插入一个新元素C．顺序输出前k个元素D．交换第i个元素和第2n-i-1个元素的值(i=0,1…,n-1)7．如果最常用的操作是取第i个结点及其前驱，则采用_________存储方式最节省时间。
A．单链表B．双链表C．单循环链表D．顺序表8．与单链表相比，双链表的优点之一是_________。
A．插入和删除操作更简单B．可以进行随机访问C．可以省略表头指针或表尾指针D．访问前后相邻结点更灵活9．带头结点的单链表L为空的判定条件是_________。
A．L= =NULL B．L->next= =NULLC．L->next= =L D．L!=NULL10．在一个具有n 个结点的有序单链表中插入一个新结点并仍然保持有序的时间复杂度是_________。
A．O(1) B．O(n)C．O(n2) D．O(nlog2n)11．在一个长度为n(n>1)的带头结点的单链表h上，另设有尾指针r（指向尾结点），执行_________操作与链表的长度有关。
《数据结构》第二章线性表习题及参考答案
《数据结构》第二章线性表习题一、单项选择题1. 线性表是________。
A．一个有限序列，可以为空B．一个有限序列，不可以为空C．一个无限序列，可以为空D．一个无限序列，不可以为空2. 在一个长度为n的顺序表中删除第i个元素(0<=i<=n)时，需向前移动个元素。
A．n-i B．n-i+l C．n-i-1 D．i3. 线性表采用链式存储时，其地址________。
A．必须是连续的B．一定是不连续的C．部分地址必须是连续的D．连续与否均可以4. 从一个具有n个结点的单链表中查找其值等于x的结点时，在查找成功的情况下，需平均比较________个元素结点。
A．n/2 B．n C．（n+1）/2 D．（n-1）/25. 在双向循环链表中，在p所指的结点之后插入s指针所指的结点，其操作是____。
A． p->next=s; s->prior=p;p->next->prior=s; s->next=p->next;B． s->prior=p; s->next=p->next;p->next=s; p->next->prior=s;C． p->next=s; p->next->prior=s;s->prior=p; s->next=p->next;D． s->prior=p; s->next=p->next;p->next->prior=s; p->next=s;6. 设单链表中指针p指向结点m，若要删除m之后的结点（若存在），则需修改指针的操作为________。
A．p->next=p->next->next; B．p=p->next; C．p=p->next->next; D．p->next=p;7. 在一个长度为n的顺序表中向第i个元素(0< i<n+l )之前插入一个新元素时，需向后移动______个元素。
第2章线性表（课堂作业）
第2章线性表（课堂作业）第2章线性表1．下面关于线性表的叙述中，错误的是哪一个？（）A．线性表采用顺序存储，必须占用一片连续的存储单元。
B．线性表采用顺序存储，便于进行插入和删除操作。
C．线性表采用链接存储，不必占用一片连续的存储单元。
D．线性表采用链接存储，便于插入和删除操作。
2．线性表是具有n个（）的有限序列（n>0）。
A．表元素 B．字符 C．数据元素D．数据项 E．信息项3.线性表（a1,a2,…,an）以链接方式存储时，访问第i位置元素的时间复杂性为（）A．O（i） B．O（1） C．O（n） D．O（i-1）4.若长度为n的线性表采用顺序存储结构，在其第i个位置插入一个新元素的算法的时间复杂度为（）(1<=i<=n+1)。
A. O(0)B. O(1)C. O(n)D. O(n2)5. 对于顺序存储的线性表，访问结点和增加、删除结点的时间复杂度为（）。
A．O(n) O(n) B. O(n) O(1) C. O(1) O(n) D. O(1) O(1)6．对于一个头指针为head的带头结点的单链表，判定该表为空表的条件是（）A．head==NULL B．head→next==NULL C．head→next==head D．head!=NULL7.链表不具有的特点是（）A．可随机访问任一元素 B．插入、删除不需要移动元素C．不必事先估计存储空间 D．所需空间与线性长度成正比8.在双向链表指针p的结点前插入一个指针q的结点操作是（）。
A.p->Llink=q;q->Rlink=p;p->Llink->Rlink=q;q->Llink=q；B.p->Llink=q;p->Llink->Rlink=q;q->Rlink=p;q->Llink=p->L link;C. q->Llink=p->Llink;q->Rlink=q;p->Llink=q;p->Llink=q;D.q->Rlink=p;q->Llink=p->Llink;p->Llink->Rlink=q;p->Llink=q;9.在单链表指针为p的结点之后插入指针为s的结点，正确的操作是：（）。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
第2章线性表
1．下面关于线性表的叙述中，错误的是哪一个？（）A．线性表采用顺序存储，必须占用一片连续的存储单元。
B．线性表采用顺序存储，便于进行插入和删除操作。
C．线性表采用链接存储，不必占用一片连续的存储单元。
D．线性表采用链接存储，便于插入和删除操作。
2．线性表是具有n个（）的有限序列（n>0）。
A．表元素 B．字符 C．数据元素
D．数据项 E．信息项
3.线性表（ a1,a2,…,an）以链接方式存储时，访问第i位置
元素的时间复杂性为（）
A．O（i） B．O（1） C．O（n） D．O（i-1）
4.若长度为n的线性表采用顺序存储结构，在其第i个位置插
入一个新元素的算法的时间复杂度为（）(1<=i<=n+1)。
A. O(0)
B. O(1)
C. O(n)
D. O(n2)
5. 对于顺序存储的线性表，访问结点和增加、删除结点的时间
复杂度为（）。
A．O(n) O(n) B. O(n) O(1) C. O(1) O(n) D. O(1) O(1)
6．对于一个头指针为head的带头结点的单链表，判定该表为空
表的条件是（）
A．head==NULL B．head→next==NULL C．head→next==head D．head!=NULL
7.链表不具有的特点是（）
A．可随机访问任一元素 B．插入、删除不需要移动元素
C．不必事先估计存储空间 D．所需空间与线性长度成正比
8.在双向链表指针p的结点前插入一个指针q的结点操作是（）。
>Llink=q;q->Rlink=p;p->Llink->Rlink=q;q->Llink=q；
>Llink=q;p->Llink->Rlink=q;q->Rlink=p;q->Llink=p->Llink
;
C. q->Llink=p->Llink;q->Rlink=q;p->Llink=q;p->Llink=q;
>Rlink=p;q->Llink=p->Llink;p->Llink->Rlink=q;p->Llink=q
;
9.在单链表指针为p的结点之后插入指针为s的结点，正确的
操作是：（）。
A． s->next=p->next;p->next=s;
B． p->next=s;s->next=p->next;
C．p->next=s;p->next=s->next;
D． p->next=s->next;p->next=s;
10．对于一个头指针为head的带头结点的单链表，判定该表为
空表的条件是（）
A．head==NULL B．head→next==NULL C．head→next==head D．head!=NULL
答案：1. B 3. C 5. C
6. B 10. B
作业一
1．线性表有两种存储结构：一是顺序表，二是链表。
试问：（1）如果有 n个线性表同时并存，并且在处理过程中各表的长度会动态变化，线性表的总数也会自动地改变。
在此情况下，应选用哪种存储结构？为什么？
（2）若线性表的总数基本稳定，且很少进行插入和删除，但要求以最快的速度存取线性表中的元素，那么应采用哪种存储结构？为什么？
2．设双向循环链表中结点的数据域、前驱和后继指针域分别为data,pre和next,试写出在指针p 所指结点之前插入一s结点的C语言描述语句。
3．一线性表存储在带头结点的双向循环链表中，L为头指针。
如下算法：
（1）说明该算法的功能。
（2）在空缺处填写相应的语句。
void unknown (BNODETP *L)
{ …
p=L->next; q=p->next; r=q->next；
while (q!=L)
{ while (p!=L) && (p->data>q->data) p=p->prior；
q->prior->next=r；(1) ______；
q->next=p->next；q->prior=p；
(2) ______；(3) ______； q=r；p=q->prior；
(4) ______；
}
}
4．已知线性表（a1 a2 a3 …an）按顺序存于内存，每个元素都是整数，试设计用最少时间把所有值为负数的元素移到全部正数值元素前边的算法：例：（x,-x,-x,x,x,-x …x）变为（-x,-x,-x…x,x,x）。
答案：
1．（1）选链式存储结构。
它可动态申请内存空间，不受表长度（即表中元素个数）的影响，插入、删除时间复杂度为O（1）。
（2）选顺序存储结构。
顺序表可以随机存取，时间复杂度为O（1）。
2．在指针p所指结点前插入结点s的语句如下：
s->pre=p->pre; s->next=p; p->pre->next=s; p->pre=s;
3．1）本算法功能是将双向循环链表结点的数据域按值自小到大排序，成为非递减（可能包括数据域值相等的结点）有序双向循环链表。
2）(1)r->prior=q->prior;∥将q结点摘下，以便插入到适当位置。
(2)p->next->prior=q;∥（2）（3）将q结点插入
(3)p->next=q;
(4)r=r->next;或r=q->next;∥后移指针，再将新结点插入到适当位置。
4[题目分析]题目要求重排n个元素且以顺序存储结构存储的线性表，使得所有值为负数的元素移到正数元素的前面。
这可采用快速排序的思想来实现，只是提出暂存的第一个元素（枢轴）并不作为以后的比较标准，比较的标准是元素是否为负数。
int Rearrange（SeqList a; int n)
∥a是具有n个元素的线性表，以顺序存储结构存储，线性表的元素是整数。
本算法重排线性表a，
∥使所有值为负数的元素移到所有值为正数的数的前面。
{i=0; j=n-1; ∥ i,j为工作指针（下标），初始指向线性表a的第1个和第n个元素。
t=a[0]; ∥暂存枢轴元素。
while(i<j)
{while(i<j && a[j]>=0) j--; ∥若当前元素为大于等于零，则指针前移。
if(i<j){a[i]=a[j];i++;} ∥将负数前移。
while(i<j &&a[i]<0)i++; ∥当前元素为负数时指针后移。
if(i<j) a[j--]=a[i]; ∥正数后移。
}
a[i]=t; ∥将原第一元素放到最终位置。
}
[算法讨论] 本算法时间复杂度为O（n）。
算法只是按题目要求把正负数分开，如要求统计负数和大于等于零的个数，则最后以t来定。
如t为负数，则0至i共i+1个负数，n-1-i个正数（包括零）。
另外，题目并未提及零的问题，笔者将零放到正数一边。
对此问题的扩充是若元素包含正数、负数和零，并要求按负数、零、正数的顺序重排线性表，统计负数、零、正数的个数。