数据结构与算法(线性表)练习题
三、写一个算法合并两个已排序的线性表。（用两种方法：数组表示的线性表（顺序表）和指针表示的线性表（链表）） 要求：1、定义线性表节点的结构，并定义节点的型和位置的型。 2、定义线性表的基本操作 3、在1，2的基础上，完成本题。 4、在main 函数中进行测试：先构建两个有序的线性表，然后合并这两个线性表。
四、已知一个单向链表，试给出复制该链表的算法。
要求：1、定义线性表的节点的结构以及节点的型和位置的型。 2、定义线性表的基本操作
3、在1，2的基础上，完成本题。
4、在main 函数中进行测试：先构建一个线性表，并定义一个空线性表，然后进行复制。
五、写出从一个带表头的单链表中删除其值等于给定值x 的结点的算法函数： int delete(LIST &L, int x);如果x 在该链表中，则删除对应结点，并返回其在链表中的位置（逻辑位置，第一个结点的逻辑位置为1），否则返回-1。 要求：1、定义线性表的节点的结构以及节点的型和位置的型。
2、定义线性表的基本操作
3、在1，2的基础上，完成本题。
4、在main 函数中进行测试：先构建一个线性表，然后调用函数删除值等于给定值的节点。
六、写出一个将两个静态链表（属于同一个存储池）合并的算法函数：
void Merge(cursor M, cursor N); 合并的方法是将N 链表中的所有结点添加到M 链表的后面，并将N 链表的表头结点添加到空闲结点链表中。 要求：1、定义静态链表的结点的结构以及结点的型SPACE 以及位置（position ）和游标（cursor ）的型。 2、定义静态链表的基本操作：void Initialize(); 初始化，将所有存储池中的结点设置为空闲；cursor GetNode(); 从空闲链中获取一个结点；void FreeNode(cursor q); 将结点q 加入到空闲链； void Insert ( elementtype x, position p, cursor M ); 在链表M 中的位置为p 的元素后面添加一个值为x 的结点；void Delete (cursor M, position p ); 在链表M 中删除位置为p 的元素的后一个元素。 3、在1、2的基础上完成本题。
4、在main 函数中进行测试：先构建一个存储池，然后在该存储池中创建两个静态
表，最后将这两个静态表合并。
七、利用指针表示的线性表(链表)表示一个多项式，并实现两个多项式的相加和相乘运算。假设多项式形式为：11
11...)(e
e m e m x a x a t a x A m
m +++=
--
其中，系数a i ≠0，指数e i 满足e m >e m-1>…>e 2>e 1>=0。 要求：1、定义多项式每一项的结构。 2、定义两个多项式的相加和相乘运算函数。 3、在main 函数中，构建两个多项式，并测试相加和相乘运算。
八、试编写一个整数进制转换的通用函数convert(int num, STACK S, int n)，要求将整数m 转换为n进制数，n进制数的各位依次存放在栈S中。并在主函数中进行测试。
要求：1、定义栈以及栈的型。
2、定义栈的各种操作。
3、实现函数convert。
4、在main函数中，通过调用函数convert将num的n进制数存放到一个栈中，并通过出栈的方法输出该n进制数
九、设有一个循环队列Queue，只有头指针front，不设尾指针，另设一个含有元素个数的计数器count，试写出相应的判断队列空、判断队列满、出队算法和入队算法。
要求：
1、定义相应的循环队列的型（只有头指针，没有尾指针，但有一个元素个数的计数器）；
2、定义该队列的四个算法：判断队列空、判断队列满、出队算法和入队算法；
3、在main函数验证算法的正确性。
十、设主串T=“abcaabbabcabaacbacba“，模式为p=“abcabaa”。
1、计算模式p的nextval函数值
2、不写算法，只画出利用KMP算法进行模式匹配时，每一趟的匹配过程。
要求：
1、写出模式p的nextval值；
2、画出KMP算法的每一趟匹配过程（可参照教材P61从第8行开始的内容）；
3、不需要编写程序。
十一、假设表达式中允许包含三种括号：圆括号、方括号和大括号。设计一个算法采用顺序栈（用数组表示的栈）判断表达式中的括号是否正确配对。
要求：
1、定义栈以及栈的型，栈中所存放元素的类型为字符型，定义枚举类型Boolean，其中两个元素分别为TRUE和FALSE。
2、定义栈的各种操作。
3、定义函数Boolean check(char *s); 判断s中的括号是否正确配对，如果正确配对，返回TRUE，否则返回FALSE。
4、在主函数中验证所编写函数的正确性。
十二、设有一个带头结点的双向链表h，设计一个算法用于查找第一个元素之为x的结点，并将其与其前驱结点进行交换。
要求：
1、定义带头结点的双向链表的型DLIST。
2、定义双向链表DLIST的基本操作。
3、定义函数int swap(elementtype x, DLIST &h)，查找第一个元素之为x的结点，如果在链表中存在元素值为x的结点，并其与其前驱结点进行交换，并返回1，否则返回0。
4、在主函数中测试所编写函数的正确性。
十三、试编写一个求三元组顺序表示的稀疏矩阵对角线元素之和的算法
十四、当具有相同行值和列值的稀疏矩阵A 和B 均以三元组顺序表方式存储时，试写出矩阵相加的算法，其结果存放在以行逻辑链接顺序表方式存储的矩阵C 中。
十五、设有一个稀疏矩阵：
?
?
?
???
????
??
???
??
??
?--00060
0002000700005000000000810030000000
040
1、写出三元组顺序表存储表示
2、写出十字链表存储的顺序表示
十六、画出广义表LS=(( ), (e), (a, (b, c, d)))的头尾链表存储结构(类似于教材P70图2-27.9)。 要求：按照教材中的事例画出相应的图形，不需要编程。 其中第一个节点如下：
十七、试编写求广义表中原子元素个数的算法。 要求：
1、定义广义表的节点的型；
2、定义广义表的基本操作；
3、定义本题要求的函数int elements(listpointer L)；函数返回值为广义表中原子的个数。例如，广义表(a, b, c, d)原子的个数为4，而广义表(a, (a, b), d, e, ((i, j), k))中院子的个数为3。 提示：先利用基本操作Cal(L)获得表头，判断表头是不是原子，再利用基本操作Cdr(L)获得除第一个元素外的其他元素所形成的表L1，利用递归的方法求L1中原子的个数。
要求：
1、上述作业要求在单独完成；
2、完成后，于规定期限内提交到ftp 服务器的相应目录中中，注意，在提交时将所编写的程序统一拷贝到一个Word 文件中，文件名格式为“学号+姓名” 三（数组表示） #include
position End(LIST L)//线性表长度
{
return (https://www.360docs.net/doc/4a8394102.html,st+1);
}
void Insert(Elementtype x,position p,LIST&L) {
position q;
if(https://www.360docs.net/doc/4a8394102.html,st>=maxlength-1)
cout<<"list is full"< else if((p>https://www.360docs.net/doc/4a8394102.html,st+1)||(p<1)) cout<<"position does not exit"< else { for(q=https://www.360docs.net/doc/4a8394102.html,st;q>=p;q--) { L.elements[q+1]=L.elements[q]; } https://www.360docs.net/doc/4a8394102.html,st=https://www.360docs.net/doc/4a8394102.html,st+1; L.elements[p]=x; } } void Delete(position p,LIST &L) { position q; if((p>https://www.360docs.net/doc/4a8394102.html,st)||(p<1)) cout<<"position does not exist"< else { https://www.360docs.net/doc/4a8394102.html,st=https://www.360docs.net/doc/4a8394102.html,st-1; for(q=p;q<=https://www.360docs.net/doc/4a8394102.html,st;q++) L.elements[q]=L.elements[q+1]; } } position Locate(Elementtype x,LIST L) { position q; for(q=1;q<=https://www.360docs.net/doc/4a8394102.html,st;q++) if(L.elements[q]==x) return q; return(https://www.360docs.net/doc/4a8394102.html,st+1); } void merge(LIST&L,LIST&L1,LIST&L2) { position p=0,p1,p2; position len1=End(L1); position len2=End(L2); https://www.360docs.net/doc/4a8394102.html,st=len1+len2-1; for(p1=0;p1 { L.elements[p]=L1.elements[p1]; p++; } p--; for(p2=0;p2 L.elements[p]=L2.elements[p2]; p++; } p--; } void read(LIST &L) { cout< cout<<"请输入线性表长度"< cin>>https://www.360docs.net/doc/4a8394102.html,st; for(int i=0;i { cin>>L.elements[i]; } } void write(LIST &L) { for(int i=0;i { cout< } cout< } int main() { LIST L,L1,L2; read(L1); write(L1); read(L2); write(L2); merge(L,L1,L2); write(L); } 数据结构三（指针） #include using namespace std; typedef int Elementtype; struct celltype{ Elementtype element; celltype *next; }; typedef celltype *LIST; typedef celltype *position; position End(LIST L) { position p; p=L; while(p->next!=NULL) { p=p->next; } return p; } void Insert(Elementtype x,position p) { position q; q=new celltype; q->element=x; q->next=p->next; p->next=q; } void Delete(position p)//删除p的下一个节点{ position q; if(p->next!=NULL) { q=p->next; p->next=q->next; delete q; } } position Locate(Elementtype x,LIST L) { position p; p=L; while(p->next!=NULL) { if(p->next->element==x) return p; else p=p->next; } return p; } position MakeNull(LIST&L) { L=new celltype; L->next=NULL; return L; } void merge(LIST&L,LIST&L1,LIST&L2) { position p,p1,p2; for(p1=L1;p1;p1=p1->next) { p=new celltype; p->element=p1->element; if(L==0) { L=p; p2=p; } else { p2->next=p; p2=p; } } p2->next=NULL; for(p1=L2;p1;p1=p1->next) { p=new celltype; p->element=p1->element; if(L==0) { L=p; p2=p; } else { p2->next=p; p2=p; } } p2->next=NULL; } void Read(LIST &L) { position p1,p2; // p1=new celltype; cout<<"请输入数据以-1结束"< for(;;) { p1=new celltype; cin>>p1->element; if(p1->element==-1) break; if(L==0) { L=p1; p2=p1; } else { p2->next=p1; p2=p1; } } p2->next=NULL; } void write(LIST&L) { position p; p=L; for(;p;p=p->next) { cout< } cout< } int main() { LIST L=NULL,L1=NULL,L2=NULL; Read(L1); write(L1); Read(L2); write(L2); merge(L,L1,L2); write(L); } 数据结构四 #include using namespace std; typedef int Elementtype; struct celltype{ Elementtype element; celltype *next; }; typedef celltype *LIST; typedef celltype *position; position End(LIST L) { position p; p=L; while(p->next!=NULL) { p=p->next; } return p; } void Insert(Elementtype x,position p)//节点插p节点之后{ position q; q=new celltype; q->element=x; q->next=p->next; p->next=q; } void Delete(position p)//删除P节点的下一个节点 { position q; if(p->next!=NULL) { q=p->next; p->next=q->next; delete p; } } position Locate(Elementtype x,LIST L) { position p; p=L; while(p->next!=NULL) { if(p->next->element==x) return p; else p=p->next; } return p; } position MakeNull(LIST &L) { L=new celltype; L->next=NULL; return L; } void Copy(LIST &L1,LIST &L2) { position p1,p2,p3; for(p2=L2;p2;p2=p2->next) { p1=new celltype; p1->element=p2->element; if(L1==0) { L1=p1; p3=p1; } else { p3->next=p1; p3=p1; } } p3->next=NULL; } void Read(LIST &L) { position p1,p2; p1=new celltype; cout<<"请输入数据以-1结束"< for(;;) { p1=new celltype; cin>>p1->element; if(p1->element==-1) break; if(L==0) { L=p1; p2=p1; } else { p2->next=p1; p2=p1; } } p2->next=NULL; } void Write(LIST &L) { position p=L; for(;p;p=p->next) { cout< } cout< } int main() { LIST L1=NULL,L2=NULL; Read(L2); Write(L2); Copy(L1,L2); Write(L1); } 数据结构五 #include using namespace std; typedef int Elementtype; struct celltype{ Elementtype element; celltype *next; }; typedef celltype *LIST; typedef celltype *position; position End(LIST L) { position p; p=L; while(p->next!=NULL) p=p->next; return p; } void Insert(Elementtype x,position p)//插入到P后面的一个节点{ position q; q->element=x; q->next=p->next; p->next=q; } void Delete(position p)//删除P后面一个节点 { position q; if(p->next!=NULL) { q=p->next; p->next=q->next; delete q; } } int Delete(LIST &L,int x) { position p=L; int count=1; if(p->element==x) { return count; p=p->next; } while(p->next!=NULL) { count++; if(p->next->element==x) { if(p->next->next!=NULL) { position q; q=p->next; p->next=q->next; delete q; return count; } else { delete p->next; p->next=NULL; return count; } } else p=p->next; } return -1; } position Locate(Elementtype x,LIST L) { position p=L; while(p->next!=NULL) { if(p->next->element==x) { return p; } else p=p->next; } return p; } position MakeNull(LIST&L) { L=new celltype; L->next=NULL; return L; } void Read(LIST &L) { position p1,p2; p1=new celltype; cout<<"请输入数据以-1结束"< for(;;) { p1=new celltype; cin>>p1->element; if(p1->element==-1) break; if(L==0) { L=p1; p2=p1; } else { p2->next=p1; p2=p1; } } p2->next=NULL; } void Write(LIST &L) { position p=L; for(;p;p=p->next) { cout< } cout< } int main() { LIST L1=NULL; Read(L1); Write(L1); cout< cout< Write(L1); } 数据结构六 #include using namespace std; #define maxsize 100 typedef int Elementtype; typedef struct{ Elementtype element; int next; }spacestr;//节点类型 spacestr SPACE[maxsize];//存储池 typedef int position,cursor; cursor available;//游标变量，标识线性表 void Initialize() { int j; for(j=0;j { SPACE[j].next=j+1;//链接池中节点 } SPACE[j].next=-1; available=0;//标识线性表，将所有存储池中的节点设置为空闲，avaailable为头节点不利用 } cursor GetNode()//从空闲链中获取一个节点 { position p; if(SPACE[available].next==-1) p=-1; else { p=SPACE[available].next; SPACE[available].next=SPACE[p].next; } return p; } void FreeNode(cursor q)//将结点q加入到空闲链 { SPACE[q].next=available; available=q; } void Insert(Elementtype x,position p,cursor M)//在链表M中的位置为p的元素后面添加一个值为x的结点 { position q; q=GetNode(); SPACE[q].element=x; SPACE[q].next=SPACE[p].next; SPACE[p].next=q; } void Delete(cursor M,position p)//在链表M中删除位置为P的元素的后一个元素{ position q; q=GetNode(); if(SPACE[p].next!=-1) { if(SPACE[SPACE[p].next].next!=-1) { q=SPACE[p].next; SPACE[p].next=SPACE[q].next; FreeNode(q); } else { q=SPACE[p].next; FreeNode(q); } } } /*合并:将N链表中的所有结点添加到M链表的后面， 并将N链表的表头结点添加到空闲结点链表中。*/ void Merge(cursor M,cursor N) { position p=M; position q=N; while(SPACE[p].next!=-1) p=SPACE[p].next; SPACE[p].next=SPACE[q].next; position r=available; SPACE[N].next=r; available=N; } void Input(cursor M)//创建静态链表 { Elementtype x; cursor p=0; cout<<"请输入静态链表的值以-1结束"< while(1) { cin>>x; if(x!=-1) { Insert(x,p,M); p=SPACE[p].next; } else { SPACE[p].element=-1; p=-1; break; } } } void Output(cursor M) { position p; p=M; while(p!=-1) { cout< p=SPACE[p].next; } cout< } int main() { // spacestr s; Initialize(); // position p=GetNode(); SPACE[0].element = 2; SPACE[0].next = 6; SPACE[1].element = 4; SPACE[1].next = 3; SPACE[2].next = 4; SPACE[3].element = 8; SPACE[3].next = -1; SPACE[4].element = 10; SPACE[4].next = 7; SPACE[5].next = 0; SPACE[6].element = 16; SPACE[6].next = 1; SPACE[7].element = 18; SPACE[7].next = 9; SPACE[8].element = 20; SPACE[8].next = -1; SPACE[9].element = 22; SPACE[9].next = 8; available = 10; cursor M = 2; cursor N = 5; Output(M); Output(N); Merge(M, N); Output(M); Delete(M,3); Insert(34,3,M); Output(M); return 0; } 数据结构七 #include using namespace std; struct PolyNode{ int coef;//系数 int expn;//指数 PolyNode *next; }; typedef PolyNode *LIST; typedef PolyNode *position; void Input(LIST &L,int n) { position p1,p2; cout<<"输入数据系数和指数(并且以指数从大到小方式输入)"< for(int i=0;i { p1=new PolyNode; cin>>p1->coef>>p1->expn; if(L==0) { L=p1; p2=p1; } else { p2->next=p1; p2=p1; } } p2->next=NULL; } void Output(LIST&L) { position p; p=L; for(;p;p=p->next) { cout<<"+"< } cout< } void Plus(LIST &L,LIST &L1,LIST &L2) { position p,p1=L1,p2=L2,pp; while(p1!=NULL||p2!=NULL) { p=new PolyNode; if(p1==NULL&&p2!=NULL) { p->coef=p2->coef; p->expn=p2->expn; if(L==0) { L=p; pp=p; } else { pp->next=p; pp=p; } p2=p2->next; } if(p1!=NULL&&p2==NULL) { p->coef=p1->coef; p->expn=p1->expn; if(L==0) { L=p; pp=p; } else { pp->next=p; pp=p; } p1=p1->next; } else { if(p1->expn>p2->expn) { p->coef=p1->coef; p->expn=p1->expn; if(L==0) { L=p; pp=p; } else { pp->next=p; pp=p; } p1=p1->next; } if(p1->expn { p->coef=p2->coef; p->expn=p2->expn; if(L==0) { L=p; pp=p; } else { pp->next=p; pp=p; } p2=p2->next; } else { p->coef=(p1->coef)+(p2->coef); p->expn=p1->expn; if(L==0) { L=p; 数据结构练习题1 指导老师：常璐璐 姓名：邢莉彬 学校：滨州学院 院系：信息工程学院软件技术 填空题 1. 对于一个n个结点的单链表，在表头插入元素的时间复杂度为_____O(1)_____，在表尾插入元素的时间复杂度为_____O(n)_____。 2. 删除非空线性链表中由q所指的链结点（其直接前驱结点由r指出）的动作时执行语句___r->link=q->link_______和______free(q)____。 结点结构为 typedef struct Node{ int value; node * link; }node; 3. 非空线性链表中，若要在由p所指的链结点后面插入新结点q，则应执行语句____ q->link=p->link;______和_____ p->link=q;_____。 结点结构为 typedef struct Node{ int value; node* link; }node; 4. 线性表L=（a1,a2,…,an）用数组表示，假定删除表中任一元素的概率相同，则删除一个元素平均需要移动元素的个数是_____(n-1)/2_____。 5. 在一个长度为n的顺序表中第i个元素（1≤i≤n）之前插入一个元素时，需向后移动_____ n-i+1_____ 个元素。 6.在具有n个链结点的链表中查找一个链结点的时间复杂度为O(_______n___)。 7. 线性表中的插入、删除操作，在顺序存储方式下平均移动近一半的元素，时间复杂度为_____O（n）_____；而在链式存储方式下，插入和删除操作的时间复杂度都是____O(1)______ 。 8. 若某线性表采用顺序存储结构，每个元素占4个存储单元，首地址为100，则第10个元素的存储地址为____136______。 选择题 1. 对于一个带头结点的单链表，头指针为head，判定该表为空的条件是________B__。 A. head==NULL B. head->next==NULL C. head->next==head D. head!=NULL 2. 将长度为m的线性链表链接在长度为n的线性链表之后的过程的时间复杂度若采用大O形式表示，则应该是______B____。 A．O(m) B．O(n) C．O(m+n) D．O(m-n) 3.在包含1000个数据元素的线性表中，实现如下4个操作所需要的执行时间最长的是______A____ 。 第2章线性表 一选择题 下列程序段的时间复杂度为（ C ）。 for( int i=1;i<=n;i++) for( int j=1;j<= m; j++) A[i][j] = i*j ; A. O(m2) B. O(n2) C. O(m*n) D. (m+n) 下面关于线性表的叙述中，错误的是哪一个？（B ） A．线性表采用顺序存储，必须占用一片连续的存储单元。 B．线性表采用顺序存储，便于进行插入和删除操作。 C．线性表采用链接存储，不必占用一片连续的存储单元。 D．线性表采用链接存储，便于插入和删除操作。 线性表是具有n个（ C ）的有限序列（n>0）。 A．表元素B．字符C．数据元素D．数据项 若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算，则利用（ A ）存储方式最节省时间。 A．顺序表B．双链表C．带头结点的双循环链表D．单循环链表 某线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素，则采用（ D ）存储方式最节省运算时间。 A．单链表B．仅有头指针的单循环链表 C．双链表D．仅有尾指针的单循环链表 设一个链表最常用的操作是在末尾插入结点和删除尾结点，则选用( D )最节省时间。A. 单链表 B.单循环链表 C. 带尾指针的单循环链表 D.带头结点的双循环链表 若某表最常用的操作是在最后一个结点之后插入一个结点或删除最后一个结点。则采用（ D ）存储方式最节省运算时间。 A．单链表B．双链表C．单循环链表D．带头结点的双循环链表 链表不具有的特点是（ B ） A．插入、删除不需要移动元素B．可随机访问任一元素 C．不必事先估计存储空间D．所需空间与线性长度成正比 下面的叙述不正确的是（B,C ） A．线性表在链式存储时，查找第i个元素的时间同i的值成正比 B. 线性表在链式存储时，查找第i个元素的时间同i的值无关 C. 线性表在顺序存储时，查找第i个元素的时间同i 的值成正比 D. 线性表在顺序存储时，查找第i个元素的时间同i的值无关 若长度为n的线性表采用顺序存储结构，在其第i个位置插入一个新元素的算法的时间复杂度为（ C ）(1<=i<=n+1)。 A. O(0) B. O(1) C. O(n) D. O(n2) 对于顺序存储的线性表，访问结点和增加、删除结点的时间复杂度为（C ）。 A．O(n) O(n) B. O(n) O(1) C. O(1) O(n) D. O(1) O(1) 线性表（a1,a2,…,an）以链接方式存储时，访问第i位置元素的时间复杂性为（ C ）A．O（i）B．O（1）C．O（n）D．O（i-1） 循环链表H的尾结点P的特点是（A ）。 A．P->next=H B．P->next= H->next C．P=H D．P=H->next 完成在双循环链表结点p之后插入s的操作是（D ）； 第1章绪论 习题 1．简述下列概念：数据、数据元素、数据项、数据对象、数据结构、逻辑结构、存储结构、抽象数据类型。2．试举一个数据结构的例子，叙述其逻辑结构和存储结构两方面的含义和相互关系。 3．简述逻辑结构的四种基本关系并画出它们的关系图。 4．存储结构由哪两种基本的存储方法实现 5．选择题 （1）在数据结构中，从逻辑上可以把数据结构分成（）。 A．动态结构和静态结构B．紧凑结构和非紧凑结构 C．线性结构和非线性结构D．内部结构和外部结构 （2）与数据元素本身的形式、内容、相对位置、个数无关的是数据的（）。 A．存储结构B．存储实现 C．逻辑结构D．运算实现 （3）通常要求同一逻辑结构中的所有数据元素具有相同的特性，这意味着（）。 A．数据具有同一特点 B．不仅数据元素所包含的数据项的个数要相同，而且对应数据项的类型要一致 C．每个数据元素都一样 D．数据元素所包含的数据项的个数要相等 （4）以下说法正确的是（）。 A．数据元素是数据的最小单位 B．数据项是数据的基本单位 C．数据结构是带有结构的各数据项的集合 D．一些表面上很不相同的数据可以有相同的逻辑结构 （5）以下与数据的存储结构无关的术语是（）。 A．顺序队列B.链表C.有序表D.链栈 （6）以下数据结构中，（）是非线性数据结构 A．树B．字符串C．队D．栈 6．试分析下面各程序段的时间复杂度。 （1）x=90;y=100; while(y>0) if(x>100) {x=x-10;y--;} elsex++; （2）for(i=0;i 第二章线性表练习题 一、选择题 1.线性表是具有n个的有限序列。 A、表元素 B、字符 C、数据元素 D、数据项 E、信息项 2.线性表的静态链表存储结构与顺序存储结构相比优点是。 A、所有的操作算法实现简单 B、便于随机存储 C、便于插入和删除 D、便于利用零散的存储器空间 3.若长度为n的线性表采用顺序存储结构，在其第i个位置插入一个新元素算法的时间复杂度为。 A、O(log2n) B、O(1) C、O(n) D、O(n2) 4.（1）静态链表既有顺序存储的特点，又有动态链表的优点。所以，它存取表中第i个元素的时间与i无关； （2）静态链表中能容纳元素个数的最大数在定义时就确定了，以后不能增加；（3）静态链表与动态链表在元素的插入、删除上类似，不需做元素的移动。 以上错误的是。 A、（1）、（2） B、（1） C、（1）、（2）、（3） D、（2） 6.在双向链表存储结构中，删除p所指的结点时须修改指针。 A、p－＞next－＞prior=p－＞prior; p－＞prior－＞next=p－＞next; B、p－＞next=p－＞next－＞next;p－＞next－＞prior=p; C、p－＞prior－＞next=p;p－＞prior=p－＞prior－＞prior; D、p－＞prior=p－＞next－＞next;p－＞next=p－＞prior－＞prior; 7.在双向循环链表中，在P指针所指的结点后插入q所指向的新结点，其修改指针的操作是。 A、p－＞next=q; q－＞prior=p;p－＞next－＞prior=q;q－＞next=q; B、p－＞next=q;p－＞next－＞prior=q;q－＞prior=p;q－＞next=p－＞next; C、q－＞prior=p; q－＞next=p－＞next; p－＞next－＞prior=q; p－＞next=q; D、q－＞next=p－＞next;q－＞prior=p;p－＞next=q;p－＞next=q; 8.将两个各有n个元素的有序表归并成一个有序表，其最少的比较次数是。 A、 n b、2n－1 c、2n d、n－1 9.在一个长度为n的顺序表中，在第i个元素（1≤i≤n+1）之前插入一个新元素时须向后移动个元素。 A、n－i B、n－i+1 C、n－i－1 D、i 10.线性表L=(a1，a2,……an)，下列说法正确的是。 A、每个元素有有一个直接前驱和一个直接后继 B、线性表中至少有一个元素 C、表中诸元素的排列必须是由小到大或由大到小。 D、除第一个和最后一个元素外，其余每个元素都有一个且仅有一个直接前驱和直接后继。 11.对单链表表示法，以下说法错误的是。 A、数据域用于存储线性表的一个数据元素 B、指针域(或链域)用于存放一指向本结点所含数据元素的直接后继所在结点的指针 C、所有数据通过指针的链接而组织成单链表 D、NULL称为空指针，它不指向任何结点只起标志作用 第2章线性表 一选择题 1．下述哪一条是顺序存储结构的优点？（） A．存储密度大 B．插入运算方便 C．删除运算方便 D．可方便地用于各种逻辑结构的存储表示 2．下面关于线性表的叙述中，错误的是哪一个？（） A．线性表采用顺序存储，必须占用一片连续的存储单元。 B．线性表采用顺序存储，便于进行插入和删除操作。 C．线性表采用链接存储，不必占用一片连续的存储单元。 D．线性表采用链接存储，便于插入和删除操作。 3．线性表是具有n个（）的有限序列（n>0）。 A．表元素 B．字符 C．数据元素 D．数据项 E．信息项 4．若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算，则利用（）存储方式最节省时间。 A．顺序表 B．双链表 C．带头结点的双循环链表 D．单循环链表 5. 链表不具有的特点是（） A．插入、删除不需要移动元素 B．可随机访问任一元素 C．不必事先估计存储空间 D．所需空间与线性长度成正比 6. 下面的叙述不正确的是（） A．线性表在链式存储时，查找第i个元素的时间同i的值成正比 B. 线性表在链式存储时，查找第i个元素的时间同i的值无关 C. 线性表在顺序存储时，查找第i个元素的时间同i 的值成正比 D. 线性表在顺序存储时，查找第i个元素的时间同i的值无关 7. 若长度为n的线性表采用顺序存储结构，在其第i个位置插入一个新元素的算法的时间复杂度为（）(1<=i<=n+1)。 A. O(0) B. O(1) C. O(n) D. O(n2) 8. 对于顺序存储的线性表，访问结点和增加、删除结点的时间复杂度为（）。 A．O(n) O(n) B. O(n) O(1) C. O(1) O(n) D. O(1) O(1) 9．线性表（ a1,a2,…,an）以链接方式存储时，访问第i位置元素的时间复杂性为（）A．O（i） B．O（1） C．O（n） D．O（i-1） 10．在单链表指针为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; 11．对于一个头指针为head的带头结点的单链表，判定该表为空表的条件是（）A．head==NULL B．head→next==NULL C．head→next==head D．head!=NULL 二、判断 1. 链表中的头结点仅起到标识的作用。( ) 2. 顺序存储结构的主要缺点是不利于插入或删除操作。( ) 3．线性表采用链表存储时，结点和结点内部的存储空间可以是不连续的。( ) 4．顺序存储方式插入和删除时效率太低，因此它不如链式存储方式好。( ) 5. 对任何数据结构链式存储结构一定优于顺序存储结构。( ) 6．集合与线性表的区别在于是否按关键字排序。( ) 7. 线性表的特点是每个元素都有一个前驱和一个后继。( ) 一、判断题 1．线性表的逻辑顺序与存储顺序总是一致的。(FALSE) 2．顺序存储的线性表可以按序号随机存取。(TRUE) 3．顺序表的插入和删除一个数据元素，每次操作平均只有近一半的元素需要移动。（TRUE） 4．线性表中的元素可以是各种各样的，但同一线性表中的数据元素具有相同的特性，因此是属于同一数据对象。（TRUE） 5．在线性表的顺序存储结构中，逻辑上相邻的两个元素在物理位置上并不一定紧邻。（FALSE） 6．在线性表的链式存储结构中，逻辑上相邻的元素在物理位置上不一定相邻。（TRUE）7．线性表的链式存储结构优于顺序存储结构。（FALSE） 8．在线性表的顺序存储结构中，插入和删除时，移动元素的个数与该元素的位置有关。（TRUE） 9．线性表的链式存储结构是用一组任意的存储单元来存储线性表中数据元素的。（TRUE）10．在单链表中，要取得某个元素，只要知道该元素的指针即可，因此，单链表是随机存取的存储结构。（FALSE） 二、单选题、(请从下列A，B，C，D选项中选择一项) 11．线性表是( ) 。 (A) 一个有限序列，可以为空；(B) 一个有限序列，不能为空； (C) 一个无限序列，可以为空；(D) 一个无序序列，不能为空。 答：A 12．对顺序存储的线性表，设其长度为n，在任何位置上插入或删除操作都是等 概率的。插入一个元素时平均要移动表中的（）个元素。 (A) n/2 (B) (n+1)/2 (C) (n –1)/2 (D) n 答：A 13．线性表采用链式存储时，其地址( D ) 。 (A) 必须是连续的；(B) 部分地址必须是连续的； (C) 一定是不连续的；(D) 连续与否均可以。 答：D 14．用链表表示线性表的优点是（）。 (A)便于随机存取 (B)花费的存储空间较顺序存储少 (C)便于插入和删除 (D)数据元素的物理顺序与逻辑顺序相同 答：C 15. 某链表中最常用的操作是在最后一个元素之后插入一个元素和删除最后一个元素，则采用( )存储方式最节省运算时间。 (A)单链表 (B)双链表 (C)单循环链表 习 9解答 判断题： 1．用向量和单链表表示的有序表均可使用折半查找方法来提高查找速度。 答：FALSE (错。链表表示的有序表不能用折半查找法。) 2.有n 个数据放在一维数组A[1..n]中，在进行顺序查找时，这n 个数的排列有序或无序其平均查找长度不同。 答：FALSE (错。因顺序查找既适合于有序表也适合于无序表；对这两种表，若对于每个元素的查找概率相等，则顺序查找的ASL 相同，并且都是(n+1)/2；对于查找概率不同的情况，则按查找概率由大到小排序的无序表其ASL 要比有序表的ASL 小。) 3.折半查找是先确定待查有序表记录的范围，然后逐步缩小范围，直到找到或找不到该记录为止。( ) 答：TRUE 4.哈希表的查找效率主要取决于哈希表哈希表造表时选取的哈希函数和处理冲突的方法。 答：TRUE 5.查找表是由同一类型的数据元素(或记录)构成的集合。 答：TRUE 单选题： 6.对于18个元素的有序表采用二分(折半)查找，则查找A[3]的比较序列的下标为( )。 A. 1、2、3 B. 9、5、2、3 C. 9、5、3 D.9、4、2、3 答：D (第一次??2/)181(+ = 9,第二次??2/)81(+ = 4，第三次??2/)31(+ = 2, (第四次??2/)33(+ = 3，故选D. 7. 顺序查找法适合于存储结构为____________的线性表。 A.散列存储 B.顺序存储或链式存储 C.压缩存储 D.索引存储 答：B 8.对线性表进行二分查找时，要求线性表必须( )。 A ．以顺序方式存储 B. 以链接方式存储 C ．以顺序方式存储，且结点按关键字有序排序 D. 以链接方式存储，且结点按关键字有序排序 答：C 9.设哈希表长m=14，哈希函数为H(k) = k MOD 11。表中已有4个记录(如下图 第2章线性表习题参考答案 习题二 一、选择题 1. 链式存储结构的最大优点是（ D ）。 A.便于随机存取 B.存储密度高 C.无需预分配空间 D.便于进行插入和删除操作 2. 假设在顺序表{a0,a1,……,an－1}中，每一个数据元素所占的存储单元的数目为4，且第0 个数据元素的存储地址为100，则第7个数据元素的存储地址是（ D ）。 A. 106 B. 107 C.124 D.128 3. 在线性表中若经常要存取第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(log2n) C. O(n) D. O(n2) 7. 要将一个顺序表{a0,a1,……,an-1}中第i个数据元素 ai(0≤i≤n-1)删除，需要移动（ B ） 个数据元素。 A. i B. n-i-1 C. n-i D. n-i+1 8. 在带头结点的双向循环链表中的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); 线性表 一、选择题 1.线性表是（ A ） A．一个有限序列，可以为空B．一个有限序列，不可以为空 C．一个无限序列，可以为空D．一个无限序列，不可以为空 2.一维数组与线性表的特征是（ C ）。 A．前者长度固定，后者长度可变B．两者长度均固定 C．后者长度固定，前者长度可变D．两者长度均可变 3.用单链表方式存储的线性表，存储每个结点需要两个域，一个数据域，另一个是( B ). A．当前结点所在地址域B．指针域 C．空指针域D．空闲域 4.用链表表示线性表的优点是（ B ）。 A．便于随机存取 B．便于进行插入和删除操作 C．占用的存储空间较顺序表少 D．元素的物理顺序与逻辑顺序相同 5.在具有 n 个结点的单链表中，实现__A _的操作，其算法的时间复杂度都是O（n）。 A．遍历链表和求链表的第i个结点 B．在地址为P的结点之后插入一个结点 C．删除开始结点 D．删除地址为P的结点的后继结点 6.下面关于线性表的叙述中，错误的是（ B ）。 A．线性表采用顺序存储必须占用一片连续的存储单元 B．线性表采用顺序存储便于进行插入和删除操作 C．线性表采用链式存储不必占用一片连续的存储单元 D．线性表采用链式存储便于进行插入和删除操作 7.已知单链表的每个结点包括一个指针域next，它指向该结点的后继结点。现要将指针 q 指向的新结点插入到指针 p 指 向的结点之后，下面的操作序列中正确的是（ C ）。 A . q = p->next; p->next = q->next ; B . p->next = q->next; q = p->next ; C . q->next = p->next; p->next = q ; D . p->next = q; q->next = p->next ; 第2章习题 (1) 第2章习题 2.1若将顺序表中记录其长度的分量listlen改为指向最后一个元素的位置last，在实现各基本运算时需要做那些修改？ 【解】 //用线性表最后一个元素的下标last代替listLen实现顺序表 #define MAXLEN 100 typedef int elementType; typedef struct sllLast { elementType data[MAXLEN]; int last; }seqList; //初始化 void initialList(seqList &S) { https://www.360docs.net/doc/4a8394102.html,st=-1; } //求表长度 int listLength(seqList S) { return https://www.360docs.net/doc/4a8394102.html,st+1; } //按序号取元素 bool getElement(seqList S,int i,elementType &x) { if(i<1 || i>https://www.360docs.net/doc/4a8394102.html,st+1) //i为元素编号，有效范围在https://www.360docs.net/doc/4a8394102.html,st+1之间 return false; else { x=S.data[i-1]; return true; } } //查找元素x，成功：返回元素编号；失败：返回0 int listLocate(seqList S,elementType x) { int i; for(i=0;i<=https://www.360docs.net/doc/4a8394102.html,st;i++) { if(S.data[i]==x) return i+1; //找到，转换为元素编号输出} return 0; } //插入元素 int listInsert(seqList &S,elementType x, int i) { int k; if(https://www.360docs.net/doc/4a8394102.html,st>MAXLEN-1) return 0; //表满，返回0 else if(i<1 || i>https://www.360docs.net/doc/4a8394102.html,st+2) return 1; //插入位置查处范围，返回1 else { for(k=https://www.360docs.net/doc/4a8394102.html,st;k>=i-1;k--) S.data[k+1]=S.data[k]; S.data[i-1]=x; https://www.360docs.net/doc/4a8394102.html,st++; return 2; } } //删除元素 int listDelete(seqList &S,int i) { int k; if(https://www.360docs.net/doc/4a8394102.html,st==-1) return 0; //空表，返回0 else if(i<1 || i>https://www.360docs.net/doc/4a8394102.html,st+1) return 1; //删除元素编号超出范围，返回1 else 精心整理 第1章绪论 习题 1．简述下列概念：数据、数据元素、数据项、数据对象、数据结构、逻辑结构、存储结构、抽象数据类型。2．试举一个数据结构的例子，叙述其逻辑结构和存储结构两方面的含义和相互关系。 3．简述逻辑结构的四种基本关系并画出它们的关系图。 4．存储结构由哪两种基本的存储方法实现？ 5 A 6 {x=x-10;y--;} elsex++; （2）for(i=0;i （4）i=1; while(i<=n) i=i*3; （5）x=0; for(i=1;i （8）将两个各有n个元素的有序表归并成一个有序表，其最少的比较次数是（）。 A．nB．2n-1 C．2nD．n-1 （9）在一个长度为n的顺序表中，在第i个元素（1≤i≤n+1）之前插入一个新元素时须向后移动（）个元素。 A．n-i B．n-i+1 C．n-i-1D．i (10)线性表L=(a1，a2,……a n)，下列说法正确的是（）。 A．每个元素都有一个直接前驱和一个直接后继 B．线性表中至少有一个元素 C．表中诸元素的排列必须是由小到大或由大到小 D．除第一个和最后一个元素外，其余每个元素都有一个且仅有一个直接前驱和直接后继。 (11)若指定有n个元素的向量，则建立一个有序单链表的时间复杂性的量级是（）。 2 , pa=La->next;pb=Lb->next; Lc=pc=La;//用La的头结点作为Lc的头结点 while(pa&&pb){ if(pa->data 一、火车出栈序列 （train.pas） 【题目描述】 输入n（n列火车),输出火车出栈的所有可能顺序。 【输入样例】 3 【输出样例】 3 2 1 2 3 1 2 1 3 1 3 2 1 2 3 【数据规模】 3<=n<=12 二、括号匹配 （LongestRegularBracketsSequence.pas） 【题目描述】 对一个由(，)，[，]括号组成的字符串，求出其中最长的括号匹配子串。具体来说，满足如下条件的字符串称为括号匹配的字符串：1．（），[]是括号匹配的字符串 2．若A是括号匹配的串,则(A),[A]是括号匹配的字符串 3．若A,B是括号匹配的字符串，则AB也是括号匹配的字符串。例如，(),[],([]),()()都是括号匹配的字符串，而][,[()],(]则不是。 字符串A的子串是指由A中连续若干个字符组成的字符串。 例如：A,B,C,ABC,CAB,ABCABC都是ABCABC的子串空串是任何字符串的子串。 【输入格式】 输入一行，为一个仅由()[]组成的非空字符串。 【输出格式】 输入也仅有一行，为最长的括号匹配子串。若有相同长度的子串， 输出位置靠前的子串。 【数据规模】 对20%的数据，字符串长度<=100； 对50%的数据，字符串长度<=10,000； 对100%的数据，字符串长度<=1,000,000； 三、马的最短步数 （horse.pas） 【题目描述】 求马在棋盘上从某个起点到某个终点的最少步数。 【输入格式】 第一行，n，m，表示棋盘有n行m列；(2 一、判断题 1. 线性表的逻辑顺序与存储顺序总是一致的。(FALSE) 2. 顺序存储的线性表可以按序号随机存取。(TRUE) 3.顺序表的插入和删除一个数据元素，每次操作平均只有近一半的元素需要移动。TRUE) 4.线性表中的元素可以是各种各样的，但同一线性表中的数据元素具有相同的特性，因此是属于同一数据对象。(TRUE) 5，在线性表的顺序存储结构中，逻辑上相邻的两个元素在物理位置上并不一定紧邻。(FALSE ) 6.在线性表的链式存储结构中，逻辑上相邻的元素在物理位置上不一定相邻。(TRUE) 7.线性表的链式存储结构优于顺序存储结构。(FALSE ) 8. 在线性表的顺序存储结构中，插入和删除时，移动元素的个数与该元素的位置有关。(TRUE) 9.线性表的链式存储结构是用一组任意的存储单元来存储线性表中数据元素的。(TRUE) 10.在单链表中，要取得某个元素，只要知道该元素的指针即可，因此，单链表是随机存取的存储结构。(FALSE ) 二．选择题 11．线性表是()。 (A)一个有限序列，可以为空； (B)一个有限序列，不能为空； (C)一个无限序列，可以为空； (D)一个无序序列，不能为空。答：A 12．对顺序存储的线性表，设其长度为n，在任何位置上插入或删除操作都是等概率的。插入一个元素时平均要移动表中的（）个元素。 (A)n/2(B)(n+1)/2(C)(n–1)/2(D)n答：A 13．线性表采用链式存储时，其地址()。 (A)必须是连续的；(B)部分地址必须是连续的；(C)一定是不连续的；(D)连续与否均可以。答：D 14．用链表表示线性表的优点是（）。 (A)便于随机存取 (B)花费的存储空间较顺序存储少 (C)便于插入和删除 (D)数据元素的物理顺序与逻辑顺序相同答：C 15.单链表中，增加一个头结点的目的是为了（）。 第2章线性表练习题答案 一、填空 1. 向一个长度为n的向量的第i个元素(1≤i≤n+1)之前插入一个元素时，需向后移动n-i+1 个元素。 2. 向一个长度为n的向量中删除第i个元素(1≤i≤n)时，需向前移动n-i 个元素。 3. 在顺序表中访问任意一结点的时间复杂度均为O(1)，因此，顺序表也称为随机存取的数据结构。 4. 在单链表中，除了首元结点外，任一结点的存储位置由其直接前驱结点的链域的值指示。 5．在n个结点的单链表中要删除已知结点*p，需找到它的前驱结点的地址，其时间复杂度为O（n）。 二、判断正误 （×）1. 链表的每个结点中都恰好包含一个指针。 答：错误。链表中的结点可含多个指针域，分别存放多个指针。例如，双向链表中的结点可以含有两个指针 域，分别存放指向其直接前趋和直接后继结点的指针。 （×）2. 链表的物理存储结构具有同链表一样的顺序。错，链表的存储结构特点是无序，而链表的示意图有序。（×）3. 链表的删除算法很简单，因为当删除链中某个结点后，计算机会自动地将后续的各个单元向前移动。错，链表的结点不会移动，只是指针内容改变。 （×）4. 线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。 错，混淆了逻辑结构与物理结构，链表也是线性表！且即使是顺序表，也能存放记录型数据。 （×）5. 顺序表结构适宜于进行顺序存取，而链表适宜于进行随机存取。 错，正好说反了。顺序表才适合随机存取，链表恰恰适于“顺藤摸瓜” （×）6. 顺序存储方式的优点是存储密度大，且插入、删除运算效率高。 错，前一半正确，但后一半说法错误，那是链式存储的优点。顺序存储方式插入、删除运算效率较低， 在表长为n的顺序表中，插入和删除一个数据元素，平均需移动表长一半个数的数据元素。 （×）7. 线性表在物理存储空间中也一定是连续的。 错，线性表有两种存储方式，顺序存储和链式存储。后者不要求连续存放。 （×）8. 线性表在顺序存储时，逻辑上相邻的元素未必在存储的物理位置次序上相邻。 错误。线性表有两种存储方式，在顺序存储时，逻辑上相邻的元素在存储的物理位置次序上也相邻。（×）9. 顺序存储方式只能用于存储线性结构。 错误。顺序存储方式不仅能用于存储线性结构，还可以用来存放非线性结构，例如完全二叉树是属于 非线性结构，但其最佳存储方式是顺序存储方式。 （×）10. 线性表的逻辑顺序与存储顺序总是一致的。 错，理由同7。链式存储就无需一致。 三、单项选择题 （C）1．数据在计算机存储器内表示时，物理地址连续，数据间的逻辑关系依靠其物理地址间的连续性来表达，称之为： （A）存储结构（B）逻辑结构（C）顺序存储结构（D）链式存储结构（ B ）2.一个向量第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是（A）110 （B）108 （C）100 （D）120 （A）3. 在n个结点的顺序表中，算法的时间复杂度是O（1）的操作是： （A）访问第i个结点（1≤i≤n）和求第i个结点的直接前驱（2≤i≤n） （B）在第i个结点后插入一个新结点（1≤i≤n） （C）删除第i个结点（1≤i≤n） （D）将n个结点从小到大排序 （ B ）4. 向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变，平均要移动个元素（A）8 （B）63.5 （C）63 （D）7 《数据结构》习题集 第一章序论 思考题： 1.1简述下列术语：数据、数据元素、数据对象、数据结构、存储结构、数据类型、抽象数据类型 作业题： 1.2设有数据结构（D，R），其中 D={d1, d2, d3, d4 } R={r1, r2} r1={ (5) x=n; y=0; //n是不小于1的常数 while(x>=(y+1)*(y+1)){ △y++; } (6) x=91; y=100; while ( y>0 ) { △if(x>100) { x-=10; y--; } else x++ ; } (7) for( i=0; i 第3章栈和队列练习题答案 一、填空题 1. 线性表、栈和队列都是线性结构，可以在线性表的任何位置插入和删除元素；对于栈只能在栈顶插入和删除元素；对于队列只能在队尾插入和队首删除元素。 2. 栈是一种特殊的线性表，允许插入和删除运算的一端称为栈顶。不允许插入和删除运算的一端称为栈底。 3. 队列是被限定为只能在表的一端进行插入运算，在表的另一端进行删除运算的线性表。 二、判断正误 （√）1. 栈是一种对所有插入、删除操作限于在表的一端进行的线性表，是一种后进先出型结构。（√）2. 对于不同的使用者，一个表结构既可以是栈，也可以是队列，也可以是线性表。 正确，都是线性逻辑结构，栈和队列其实是特殊的线性表，对运算的定义略有不同而已。 （×）3. 栈和队列是一种非线性数据结构。 错，他们都是线性逻辑结构，栈和队列其实是特殊的线性表，对运算的定义略有不同而已。 （√）4. 栈和队列的存储方式既可是顺序方式，也可是链接方式。 （√）5. 两个栈共享一片连续内存空间时，为提高内存利用率，减少溢出机会，应把两个栈的栈底分别设在这片内存空间的两端。 （×）6. 队是一种插入与删除操作分别在表的两端进行的线性表，是一种先进后出型结构。 错，后半句不对。 （×）7. 一个栈的输入序列是12345，则栈的输出序列不可能是12345。 错，有可能。 三、单项选择题 （B）1.栈中元素的进出原则是 Ａ．先进先出Ｂ．后进先出Ｃ．栈空则进Ｄ．栈满则出 （C）2.若已知一个栈的入栈序列是1，2，3，…，n，其输出序列为p1，p2，p3，…，pn，若p1=n，则pi为 Ａ．i Ｂ．n-i Ｃ．n-i+1 Ｄ．不确定 解释：当p1=n，即n是最先出栈的，根据栈的原理，n必定是最后入栈的（事实上题目已经表明了），那么输入顺序必定是1，2，3，…，n，则出栈的序列是n，…，3，2，1。 （若不要求顺序出栈，则输出序列不确定） （D）3．数组Ｑ［ｎ］用来表示一个循环队列，ｆ为当前队列头元素的前一位置，ｒ为队尾元素的位置，假定队列中元素的个数小于ｎ，计算队列中元素的公式为 （Ａ）r－f; （Ｂ）（n＋f－r）% n; （Ｃ）n＋r－f; （Ｄ）（n＋r－f）% n E：①1 ②2 ③3 ④0 四、阅读理解 1.【严题集3.3②】写出下列程序段的输出结果（栈的元素类型SElem Type为char）。 void main( ){ Stack S; Char x,y; InitStack(S); x=’c’;y=’k’; 复习题集─参考答案 一判断题 （√）1. 在决定选取何种存储结构时，一般不考虑各结点的值如何。 （√）2. 抽象数据类型与计算机部表示和实现无关。 （×）3. 线性表采用链式存储结构时，结点和结点部的存储空间可以是不连续的。 （×）4. 链表的每个结点中都恰好包含一个指针。 （×）5.链表的删除算法很简单，因为当删除链中某个结点后，计算机会自动地将后续的各个单元向前移动。（×）6. 线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。 （×）7. 顺序表结构适宜于进行顺序存取，而链表适宜于进行随机存取。 （×）8. 线性表在物理存储空间中也一定是连续的。 （×）9. 顺序存储方式只能用于存储线性结构。 （√）10.栈是一种对所有插入、删除操作限于在表的一端进行的线性表，是一种后进先出型结构。 （√）11.对于不同的使用者，一个表结构既可以是栈，也可以是队列，也可以是线性表。 （√）12.栈是一种对所有插入、删除操作限于在表的一端进行的线性表，是一种后进先出型结构。 （√）13.两个栈共享一片连续存空间时，为提高存利用率，减少溢出机会，应把两个栈的栈底分别设在这片存空间的两端。 （×）14.二叉树的度为2。 （√）15.若二叉树用二叉链表作存贮结构，则在n个结点的二叉树链表中只有n—1个非空指针域。 （×）16.二叉树中每个结点的两棵子树的高度差等于1。 （√）17.用二叉链表法存储包含n个结点的二叉树，结点的2n个指针区域中有n+1个为空指针。 （√）18.具有12个结点的完全二叉树有5个度为2的结点。 （√）19.二叉树的前序遍历序列中，任意一个结点均处在其孩子结点的前面。 （×）20.在冒泡法排序中，关键值较小的元素总是向前移动，关键值较大的元素总是向后移动。 （×）21.计算机处理的对象可以分为数据和非数据两大类。[计算机处理的对象都是数据] （×）22.数据的逻辑结构与各数据元素在计算机中如何存储有关。 （×）23.算法必须用程序语言来书写。 （×）24.判断某个算法是否容易阅读是算法分析的任务之一。 （×）25.顺序表是一种有序的线性表。[任何数据结构才用顺序存储都叫顺序表] （√）26.分配给顺序表的存单元地址必须是连续的。 （√）27.栈和队列具有相同的逻辑特性。[它们的逻辑结构都是线性表] （√）28.树形结构中每个结点至多有一个前驱。 （×）29.在树形结构中，处于同一层上的各结点之间都存在兄弟关系。 （×）30.如果表示图的邻接矩阵是对称矩阵，则该图一定是无向图。 （×）31.如果表示图的邻接矩阵是对称矩阵，则该图一定是有向图。 （×）32.顺序查找方法只能在顺序存储结构上进行。 （×）33.折半查找可以在有序的双向链表上进行。 《数据结构》 第二章线性表习题 一、单项选择题 1. 线性表是________。 A．一个有限序列，可以为空B．一个有限序列，不可以为空 C．一个无限序列，可以为空D．一个无限序列，不可以为空 2. 在一个长度为n的顺序表中删除第i个元素(0<=i<=n)时，需向前移动个元素。 A．n-i B．n-i+l C．n-i-1 D．i 3. 线性表采用链式存储时，其地址________。 A．必须是连续的B．一定是不连续的 C．部分地址必须是连续的D．连续与否均可以 4. 从一个具有n个结点的单链表中查找其值等于x的结点时，在查找成功的情况下，需平均比较________个元素结点。 A．n/2 B．n C．（n+1）/2 D．（n-1）/2 5. 在双向循环链表中，在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数据结构线性表习题1
线性表练习题(答案)
数据结构与算法习题及答案
第2章线性表习题解析(答)
数据结构练习题-线性表
线性表练习题答案
数据结构与算法复习题10(C语言版)
第2章线性表习题参考答案
数据结构-线性表-习题
第2章线性表习题解答
数据结构与算法习题及答案
线性表练习题
数据结构_线性表练习题
线性表练习题答案
数据结构习题
栈和队列练习题答案
数据结构与算法复习题及参考答案
最新《数据结构》 第二章 线性表习题