南工大第二章线性表.docx
《南工大第二章线性表.docx》由会员分享，可在线阅读，更多相关《南工大第二章线性表.docx（55页珍藏版）》请在冰豆网上搜索。
南工大第二章线性表
数据结构与算法上机作业
第二章线性表
一、选择题
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个结点的顺序表上做插入结点操作，需平均移动的结点数目为
d。
A.nB.（n-1）/2C.n/2D.（n+1）/2
5、在一个长度为n的顺序存储的线性表中查找值为x的元素时，平均查找长度（及x同元素的平均比较次数，假定查找每个元素的概率都相等）为b。
A.nB.n/2C.（n+1）/2D.（n-1）/2
6、在顺序表中，只要知道d，就可以求出任一结点的存储地址。
A.基地址B.结点大小C.向量大小D.基地址和结点大小
7、将两个各有n个元素的有序表归并为一个有序表，其最少的比较次数是a。
A.nB.2n-1C.2nD.n-1
8、线性表采用链表存储时其存储地址要求d。
A.必须是连续的B.部分地址必须是连续的
C.必须是不连续的D.连续的和不连续的都可以
9、下面关于线性表的描述中，错误的是d。
A.线性表采用顺序存储，必须占用一片连续的存储单元
B.线性表采用顺序存储，便于进行插入和删除操作
C.线性表采用链式存储，不必占用一片连续的存储单元
D.线性表采用链式存储，便于插入和删除操作
10、向具有n个结点的有序单链表中插入一个新结点并仍然有序的时间复杂度是b
A.O
（1）B.O（n）C.O（n2）D.O（log2n）
11、在一个带头结点的单链表HL中，若要向表头插入一个由指针p指向的结点，则执行的语句是B。
A.HL=p;p->next=HL;B.p->next=HL;HL=p;
C.p->next=HL;p=HL;D.p->next=HL->next;HL->next=p;
12、在一个单链表HL中，若要删除由指针q所指向结点的后继结点，则执行的语句是C。
A.p=q->next;p->next=q->next;
B.p=q->next;q->next=p;
C.p=q->next;q->next=p->next;
D.q->next=q->next->next;q->next=q;
13、设有编号为1,2,3,4的4辆列车，顺序进入一个栈结构的站台，下列不可能的出栈顺序为D。
A.1234B.1243C.1324D.1423
14、4个元素按A,B,C,D顺序进入S栈，执行两次Pop（S,x）运算后，栈顶元素的值是B。
A.AB.BC.CD.D
15、从一个栈顶指针为top的链栈中删除一个结点时，用x保存被删除的结点，应执行下列
D命令。
A.x=top;top=top->next;B.top=top->next;x=top->data;
C.x=top->data;D.x=top->data;top=top->next;
16、向顺序栈中输入元素时B。
A.先存入元素，后移动栈顶指针B.先移动栈顶指针，后存入元素
C.谁先谁后无关紧要D.同时进行
17、设有一个顺序栈，元素A,B,C,D,E,F依次进栈，如果6个元素出栈的顺序是B,D,C,F,E,A，则栈的容量至少为A。
A.3B.4C.56.6
18、设已将元素A,B,C依次入栈，元素D正等待进栈。
那么下列4个序列中不可能出现的出栈顺序为A。
A.CADBB.CBDAC.CDBAD.DCBA
19、栈和队列的相同之处是C。
A.元素的进出满足先进后出B.元素的进出满足后进先出
C.只允许在端点进行插入和删除操作D.无共同点
20、设栈S和队列Q的初始状态为空,元素e1，e2，e3，e4，e5和e6依次通过栈，一个元素出栈后即进入队列Q,若6个元素出队的序列是e2，e4，e3，e6，e5，e1，则栈S的容量至少应该是C。
A.6B.4C.3D.2
21、队列通常采用的两种存储结构是（A）。
A.顺序存储结构和链式存储结构B.散列方式和索引方式
C.链表存储结构和线性存储结构D.线性存储结构和非线性存储结构
22、循环队列SQ队满的条件是B。
A.SQ->rear==SQ->frontB.（SQ->rear+1）%MAXLEN==SQ->front
C.SQ->rear+2==SQL->frontD.（SQ->rear+2）%MAXLEN==SQL->front
23、若用一个大小为6的数组来实现循环队列，且当前front和rear的值分别为3和0，当从队列中删除一个元素，再加入两个元素后，front和rear的值分别为B。
A.5和1B.4和2C.2和4D.1和5
24、链栈与顺序栈相比，有一个较为明显的优点是A。
A.通常不会出现满栈的情况B.通常不会出现栈空的情况
C.插入操作更加方便D.删除操作更加方便
25、设用一个大小为M=60的顺序表A[M]表示一个循环队列，如果当前的尾指针rear=32，头指针front=15，则当前循环队列的元素的个数为C。
A.42B.17C.18D.41
26、串是一种特殊的线性表，其特殊性体现在D。
A.可以顺序存储B.数据元素是一个字符
C.可以链式存储D.数据元素可以是多个字符
27、设主串的长度为n，模式串的长度为m，则串匹配的KMP算法的时间复杂度为C。
A.O（m）B.O（n）C.O（m+n）D.O（m×n）
28、已知串S=“abab”，其Next数组值为B。
A.0123B.0121C.0112D.0122
29、若字符串“ABCDEFG”采用不带表头的链式存储，每个结点保存一个字符。
假设每个字符占用1个字节，每个指针占用两个字节，则该字符串的存储密度为D。
A.20%B.40%C.50%D.33.3%
30、在双向链表中，在指针p所指的结点前插入一个指针q所指向的结点，操作是A。
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->Next=q;
31、已知循环队列存储在一维数组A[0…n-1]中，且队列非空时front和rear分别指向对头元素和队尾元素，且要求第一个进入队列的元素存储在A[0]处，则初始时front和rear的值分别是D。
A.0,0B.0,n-1C.n-1,0D.n-1,n-1
32、某队列允许在两端进行入队操作，但仅允许在一端进行出队操作（称为输出受限的双端队列），若a,b,c,d,e元素依次进队，则不可能得到的顺序是C。
A.bacdeB.dbaceC.dbcaeD.ecbad
33、在双向链表中间插入一个结点时，需要修改D个指针域。
A.1B.2C.3D.4
34、在按行优先顺序存储的三元组表中，下述陈述错误的是D。
A.同一行的非零元素，是按列号递增次序存储的
B.同一列的非零元素，是按行号递增次序存储的
C.三元组表中三元组行号是非递减的
D.三元组表中三元组列号是非递减的
35、在稀疏矩阵的三元组表示法中，每个三元组表示D。
A.矩阵中非零元素的值
B.矩阵中数据元素的行号和列号
C.矩阵中数据元素的行号、列号和值
D.矩阵中非零数据元素的行号、列号和值
36、对特殊矩阵采用压缩存储的目的主要是为了C。
A.表达变得简单B.对矩阵元素的存取变得简单
C.去掉矩阵中的多余元素C.减少不必要的存储空间
37、广义表是线性表的推广，它们之间的区别在于A。
A.能否使用子表B.能否使用原子项
C.表的长度D.是否能为空
38、已知广义表（a,b,c,d）的表头是A，表尾是D。
A.aB.（）C.（a,b,c,d）D.（b,c,d）
39、下面说法不正确的是A。
A.广义表的表头总是一个广义表B.广义表的表尾总是一个广义表
C.广义表难以用顺序存储结构表示D.广义表可以是一个多层次的结构
40、若广义表A满足Head（A）=Tail（A），则A为C。
A.（）B.（（））C.（（）,（））D.（（）,（）,（））
二、填空题
1、线性表中结点的集合是有限的，结点之间的关系是一对一关系。
2、顺序表中访问任一个结点的时间复杂度为O
（1）。
3、线性表中第一个结点没有直接前驱，称为头结点。
4、在一个长度为n的顺序表中删除第i个元素，要移动n-i个元素。
5、在一个长度为n的顺序表中，如果要在第i个元素前插入一个元素，要后移n-i+1个元素，在插入操作中，移动元素的均值为（n+1）/2。
6、根据线性表的链式存储结构中每一个结点包含的指针个数，将线性链表分成单向链表和
双向链表。
7、链式存储的特点是利用指针来表示数据元素之间的逻辑关系。
8、静态链表（线性表的游标实现）是指用游标/数组下标表示单链表的指针。
9、在静态链表中，一般都有一个变量available表示的结点链，其中的结点为空闲节点。
10、在栈中，可进行插入和删除操作的一端称栈顶。
11、在进栈运算时，应先判别栈是否为满。
在出栈运算时应先判别栈是否为空。
当栈中元素为n个时，进栈运算时发生上溢，则说明该栈的最大容量为n。
12、设有一空栈，现有输入序列为1,2,3,4,5，经过push,push,pop,push,pop,push,push,pop,pop之后，输出序列为push。
13、对于循环向量的循环队列，求队列长度的公式为（rear-front+n+1）%n。
14、栈的逻辑特点是先进后出。
队列的逻辑特点是先进先出。
两者的共同特点是只允许在它们的端点出插入和删除数据元素，区别是栈在顶点进行插入和删除，而队列在队首进行删除，在队尾进行插入。
15、链队列LQ为空时，LQ->front->next=NULL/LQ->rear.
16、在一个链队列中，若队首指针为front，队尾指针为rear，则判断该队列只有一个结点的条件为front-rear=1/front->next==rear。
17、设串S=“Ilikecomputer”，T=“com”，则Length（S）=14。
Index（S,T）=6。
18、在KMP算法中，next[j]只与主窜S串有关，而与子串无关。
19、字符串“ababaab“的Next数组值是0121301。
20、稀疏矩阵一般压缩存储的方式有三种，分别是三元组存储，行指针链表、和十字链表。
21、二维数组M中每个元素的长度是3字节，行下标i从0~7，列下标j从0～9，从首地址&M[0][0]开始连续存放在存储器中。
若按行优先的方式存放，元素M[7][5]的起始地址为
SA+225；若按列优先方式存放，元素M[7][5]的起始地址为SA+141。
22、广义表（a,（a,b）,d,e,（（i,j）,k））的长度是6，深度是3。
23、设广义表A（（（）,（a,（b）,c））），则Cal（Cdr（Cal（Cdr（Cal（A））））=（b）
三、写一个算法合并两个已排序的线性表。
（用两种方法：
数组表示的线性表（顺序表）和指针表示的线性表（链表））
要求：
1、定义线性表节点的结构，并定义节点的型和位置的型。
2、定义线性表的基本操作
3、在1，2的基础上，完成本题。
4、在main函数中进行测试：
先构建两个有序的线性表，然后合并这两个线性表。
#include
usingnamespacestd;
intmain（）
{
inta[10]={0,1,2,3,4};
intb[5]={5,6,7,8,9};
for（inti=5;i<10;i++）
{
a[i]=b[i-5];
}
for（inti=0;i<10;i++）
{
cout<}
system（"pause"）;
return0;
}
#include
usingnamespacestd;
structListNode
{
intm_nValue;
ListNode*m_pNext;
};
//合并两个有序链表,非递归方法
ListNode*MergeTwoList（ListNode*pListOneHead,ListNode*pListTwoHead）
{
if（pListOneHead==NULL）
{
returnpListTwoHead;
}
if（pListTwoHead==NULL）
{
returnpListOneHead;
}
ListNode*pNode1=pListOneHead;
ListNode*pNode2=pListTwoHead;
ListNode*pMergeListHead=NULL;
ListNode*pCurLastNode=NULL;
if（pNode1->m_nValuem_nValue）
{
pMergeListHead=pListOneHead;
pNode1=pNode1->m_pNext;
pCurLastNode=pMergeListHead;
}
else
{
pMergeListHead=pListTwoHead;
pNode2=pNode2->m_pNext;
pCurLastNode=pMergeListHead;
}
while（pNode1!
=NULL&&pNode2!
=NULL）
{
if（pNode1->m_nValuem_nValue）
{
pCurLastNode->m_pNext=pNode1;
pCurLastNode=pNode1;
pNode1=pNode1->m_pNext;
}
else
{
pCurLastNode->m_pNext=pNode2;
pCurLastNode=pNode2;
pNode2=pNode2->m_pNext;
}
if（pNode1==NULL）
{
pCurLastNode->m_pNext=pNode2;
}
if（pNode2==NULL）
{
pCurLastNode->m_pNext=pNode1;
}
}
returnpMergeListHead;
}
//创建一个链表，输入从头到尾结点的值，输入-1表示结束
voidCreateList（ListNode*&pHead）
{
ListNode*pListNode=NULL;
ListNode*pCurLastNode=NULL;
boolisHead=true;
while
（1）
{
if（isHead）
{
pHead=newListNode（）;
cin>>pHead->m_nValue;
if（pHead->m_nValue==-1）
{
pHead=NULL;
break;
}
pHead->m_pNext=NULL;
isHead=false;
pCurLastNode=pHead;
}
else
{
pListNode=newListNode（）;
cin>>pListNode->m_nValue;
if（pListNode->m_nValue==-1）
{
break;
}
pListNode->m_pNext=NULL;
pCurLastNode->m_pNext=pListNode;
pCurLastNode=pListNode;
}
}
}
//从头到尾打印链表
voidPrintList（ListNode*&pHead）
{
if（pHead!
=NULL）
{
ListNode*pCur=pHead;
while（pCur!
=NULL）
{
cout<m_nValue<<"";
pCur=pCur->m_pNext;
}
cout<}
else
{
cout<<"链表为空！
"<}
}
intmain（intargc,intargv[]）
{
ListNode*pList1Head=NULL;
CreateList（pList1Head）;
PrintList（pList1Head）;
ListNode*pList2Head=NULL;
CreateList（pList2Head）;
PrintList（pList2Head）;
ListNode*pMergeListHead=MergeTwoList（pList1Head,pList2Head）;
if（pMergeListHead!
=NULL）
{
cout<m_nValue<}
PrintList（pMergeListHead）;
system（"pause"）;
return0;
}
四、用STL中的vector定义一个对象vec，在vec中添加若干个元素，然后对这些元素进行排序（可以采用任意一种排序方法），并输出排序后的元素。
#include
#include
#include
//先自定义一个结构体
structTest{
intmember1;
intmember2;
};
//自定义排序函数
boolSortByM1（constTest&v1,constTest&v2）//注意：
本函数的参数的类型一定要与vector中元素的类型一致
{
returnv1.member1}
voidMyPushback（std:
:
vector&vecTest,constint&m1,constint&m2）
{
Testtest;
test.member1=m1;
test.member2=m2;
vecTest.push_back（test）;
}
voidPrintVector（std:
:
vector&vec）
{
/*
插一句，
vec.begin（）对应的位置是向量的第一个位置，
vec.end（）对应的是vector中的最后的一个元素位置的后面的一个位置（我认为，实际上是一个无效位置）
文档上的定义：
Returnsaniteratorreferringtothepast-the-endelementinthevectorcontainer.
*/
for（std:
:
vector:
:
iteratorit=vec.begin（）;it!
=vec.end（）;it++）
{
std:
:
cout<member1<<'\t'<member2<:
endl;
}
}
intmain（）
{
std:
:
vectorvecTest;
MyPushback（vecTest,9,1）;
MyPushback（vecTest,8,2）;
MyPushback（vecTest,7,3）;
MyPushback（vecTest,6,4）;
MyPushback（vecTest,5,5）;
MyPushback（vecTest,4,6）;
MyPushback（vecTest,3,7）;
MyPushback（vecTest,2,8）;
MyPushback（vecTest,1,9）;
//排序之前
std:
:
cout<<"BeforeSort:
"<:
endl;
PrintVector（vecTest）;
std:
:
cout<<"对向量中的所有元素按member1进行升序排列:
"<:
endl;
std:
:
sort（vecTest.begin（）,vecTest.end（）,SortByM1）;
PrintVector（vecTest）;
升级会员 