链表作业
数据结构第2章作业 线性表(答案)
第2章线性表班级学号__________-姓名一、判断正误（×）1. 链表的每个结点中都恰好包含一个指针。
链表中的结点可含多个指针域，分别存放多个指针。
例如，双向链表中的结点可以含有两个指针域，分别存放指向其直接前趋和直接后继结点的指针。
（×）2. 链表的物理存储结构具有同链表一样的顺序。
链表的存储结构特点是无序，而链表的示意图有序。
（×）3. 链表的删除算法很简单，因为当删除链中某个结点后，计算机会自动地将后续的各个单元向前移动。
链表的结点不会移动，只是指针内容改变。
（×）4. 线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。
混淆了逻辑结构与物理结构，链表也是线性表！且即使是顺序表，也能存放记录型数据。
（×）5. 顺序表结构适宜于进行顺序存取，而链表适宜于进行随机存取。
正好说反了。
顺序表才适合随机存取，链表恰恰适于“顺藤摸瓜”（×）6. 顺序存储方式的优点是存储密度大，且插入、删除运算效率高。
前一半正确，但后一半说法错误，那是链式存储的优点。
顺序存储方式插入、删除运算效率较低，在表长为n的顺序表中，插入和删除一个数据元素，平均需移动表长一半个数的数据元素。
（×）7. 线性表在物理存储空间中也一定是连续的。
线性表有两种存储方式，顺序存储和链式存储。
后者不要求连续存放。
（×）8. 线性表在顺序存储时，逻辑上相邻的元素未必在存储的物理位置次序上相邻。
线性表有两种存储方式，在顺序存储时，逻辑上相邻的元素在存储的物理位置次序上也相邻。
（×）9. 顺序存储方式只能用于存储线性结构。
顺序存储方式不仅能用于存储线性结构，还可以用来存放非线性结构，例如完全二叉树是属于非线性结构，但其最佳存储方式是顺序存储方式。
（后一节介绍）（×）10. 线性表的逻辑顺序与存储顺序总是一致的。
理由同7。
链式存储就无需一致。
南开24秋学期《数据结构》作业参考二
24秋学期《数据结构》作业参考1.一个向量第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是()选项A：110选项B：108选项C：100选项D：120参考答案：B2.数组Ｑ［ｎ］用来表示一个循环队列，ｆ为当前队列头元素的前一位置，ｒ为队尾元素的位置，假定队列中元素的个数小于ｎ，计算队列中元素的公式为选项A：r－f选项B：（n＋f－r）% n选项C：n＋r－f选项D：（n＋r－f）% n参考答案：D3.链表适用于()查找选项A：顺序选项B：二分法选项C：顺序，也能二分法选项D：随机参考答案：A4.二叉树是非线性数据结构，所以（）选项A：它不能用顺序存储结构存储选项B：它不能用链式存储结构存储选项C：顺序存储结构和链式存储结构都能存储选项D：顺序存储结构和链式存储结构都不能使用参考答案：C5.链表是一种采用存储结构存储的线性表选项A：顺序选项B：链式选项C：星式选项D：网状参考答案：B6.线性表Ｌ在（）情况下适用于使用链式结构实现。
选项A：需经常修改Ｌ中的结点值选项B：需不断对Ｌ进行删除插入选项C：Ｌ中含有大量的结点选项D：Ｌ中结点结构复杂参考答案：B7.对有n个记录的表作快速排序，在最坏情况下，算法的时间复杂度是()选项A：O(n)选项B：O(n2)选项C：O(nlog2n)选项D：O(n3)参考答案：B8.串是一种特殊的线性表，其特殊性体现在（）选项A：可以顺序存储选项B：数据元素是一个字符选项C：可以链式存储选项D：数据元素可以是多个字符参考答案：B9.广度优先遍历类似于二叉树的()选项A：先序遍历选项B：中序遍历。
数据结构第一次作业
第一行为第一个链表的各结点值，以空格分隔。
第二行为第二个链表的各结点值，以空格分隔。
【输出形式】
合并好的链表，以非降序排列，值与值之间以空格分隔。
【样例输入】
4 7 10 34
1 4 6 29 34 34 52
【样例输出】
1 4 6 7 10 29 34 52
【评分标准】
要使用链表实现，否则不能得分。
3.设n为大于1的正整数，计算机执行下面的语句时，带#语句的执行次数为n。
i=1;
j=0;
while(i+j<=n){
# if(i>j)
j++;
else
i++;
}
4.在具有n个链结点的链表中查找一个链结点的时间复杂度为O(n)。
5.下面程序段的时间复杂度为O(mn)。
for ( i = 0; i < n; i++ )
D.每个链结点有多少个直接后继结点，它就应该设置多少个指针域
8.将长度为m的线性链表链接在长度为n的线性链表之后的过程的时间复杂度若采用大O形式表示，则应该是B。
A．O(m) B．O(n) C．O(m+n) D．O(m-n)
9.在一个单链表中，若要在p所指向的结点之后插入一个新结点，则需要相继修改__个指针域
int time (int n) {
int count=0, x=2;
while ( x < n/2 ) {
x=2x;
count++;
}
return (count);
}
时间复杂度：O(logn)
count值：logn-2
数据结构作业2
一、判断题。
◆1、通常数组采用静态内存分配进行存储，链表采用动态内存分配进行存储。
（ V）◆2、链表在进行插入与删除操作时，根本就不需要移动数据元素。
（ X ）◆3、在查找结点时，双向链表比单链表较为迅速；在插入或删除一个具体结点时，双向链表比单链表较为费时。
（ V ）◆4、顺序存储的线性表可以按序号随机存取。
（ V ）●1、在有n个数据元素的链表中进行插入操作，在最坏情况下需要读取多少个元素？(A). 1 (B). n/2 (C). n (D). n/3●2、如下链表中，f为头指针，请问结点d的数据域如何表示？(A). ((f→next)→next)→data(B). ((f→next)→next)→next(C). (((f→next)→next)→next) →data(D). 以上都不是●3、在双向链表中，插入一个newnode在某node的右边，请在空格内选择正确的操作。
•Void dinsert (node_pointer node, node_pointer newnode)•{ newnode→Llink=node;• newnode→Rlink=node→Rlink;•( )=newnode;• node→Rlink=newnode; }(A). node→Rlink→Llink(B). node→Llink→Rlink(C). node→Llink(D). node→Llink→Llink●4、链表不具有的特点是什么？A. 可随机访问任一元素B.插入和删除时不需要移动元素C. 不必事先估计存储空间D. 所需空间与线性表的长度成正比●5、线性链表（动态）是通过什么方式表示元素之间的关系的？A.保存后继元素地址B. 元素的存储顺序C. 保存左、右孩子地址D. 保存后继元素的数组下标●6、设顺序表的每个元素占8个存储单元，第1个单元的存储地址是100，则第6个元素占用的最后一个存储单元的地址是什么？A. 139B. 140C. 147D. 148●7、设顺序表的长度为n，并设从表中删除元素的概率相等，则在平均情况下，从表中删除一个元素需移动的元素个数是什么？A. (n-1)/2B. n/2C. n(n-1)/2D. n(n+1)/2●8、在线性链表存储结构下，插入操作算法的操作如何？A. 需要判断是否表满B. 需要判断是否表空C. 不需要判断表满D. 需要判断是否表空和表满●9、带头结点的单链表head为空的判断条件是（）。
作业2及答案
作业2及答案1. 描述以下三个概念的区别:头指针,头结点,首元结点(第一个元素结点).答:图示如下:头结点:是一个结构体变量,但data 域不用于存储线性表中的数据,可以存储其他数据, 首元结点:即第一个元素结点,用于存储线性表中a1的结点.2. 填空题.(1) 在顺序表中插入或删除一个元素,需要平均移动大约一半元素,具体移动的元素个数与表长和插入位置有关.(2) 顺序表中逻辑上相邻的元素的物理位置一定紧邻.单链表中逻辑上相邻的元素的物理位置不一定紧邻.(3) 在单链表中,除了首元结点外,任一结点的存储位置由其直接前驱的next 域指示.(4) 在单链表中设置头结点的作用是方便操作.3. 在什么情况下用顺序表比链表好?答:在进行存取时用顺序表比链表好.4. 已知指针la 和lb 分别指向两个无头结点单链表中的首元结点.下列算法是从表la 中删除自第i 个元素起共len 个元素后,将它们插入到表lb 中第j 个元素之前,试问此算法是否正确？若有错,则请改正之.Status DeleteAndInsertSub(LinkedList la,LinkedList lb,int i ,int j ,int len){if (i<0||j<0||len<0) return INFEASIBLE;p=la; k=1;while(k<i) { p=p->next; k++; }q=p;while(k<=len) { q=q->next; k++; }s=lb; k=1;while(k<j){ s=s->next; k++; }s->next=p; q->next=s->next;return OK;}//DeleteAndInsertSub答案:此算法不正确.注意此题中的条件是,采用的存储结构(单链表)中无头结点,因此在写算法时,特别要注意空表和第一个结点的处理.算法中尚有其他类型的错误,如结点的计数,修改指针的次序,k 变量的初始化,插入和删除位置的定位等.此题的正确算法如下:Status DeleteAndInsertSub(LinkedList la, LinkedList lb, int i, int j, int len){ if(i<0 || j<0 || len<0) return INFEASIBLE;p=la; k=1; pre=NULL;while(p && k<i) { pre=p; p=p->next; k++; }if(!p) return INFEASIBLE;q=p; k=1;while(q && k<len) { q=q->next; k++; }if(!q) return INFEASIBLE;…头指针 头结点首元结点if(!pre) la=q->next;else pre->next=q->next;if(j=1) { q->next=lb; lb=p; }else { // j>=2s=lb; k=1;while(s && k<j-1) { s=s->next; k++; }if(!s) return INFEASIBLE;q->next=s->next; s->next=p;return OK;}} // DeleteAndInsertSub。
数据结构实践作业
数据结构作业利用单向链表数据结构完成对链表的如下操作:1、创建一条含整数结点的无序链表2、链表结点的输出3、链表结点的升序排序4、分别计算链表中奇数和偶数结点之和并输出5、释放链表具体要求将程序功能做成菜单，形式如下：1、创建一条含整数结点的无序链表2、链表结点的输出3、链表结点的升序排序4、分别计算链表中奇数和偶数结点之和并输出5、释放链表0、退出《数据结构》大作业1 总体要求将程序功能做成菜单，形式如下：（1）创建一条含整数结点的无序链表（2）链表结点的输出（3）链表结点的升序排序（4）分别计算链表中奇数和偶数结点之和并输出（5）释放链表2 开发环境软件环境：Window10，Visual Studio 20173 系统运行效果截图（1）主菜单：（2）创建一条含整数结点的无序链表：3,6,2,5,9（3）链表结点的输出（4）链表结点的升序排序（5）分别计算链表中奇数和偶数结点之和并输出（6）释放链表4 源程序#include<iostream>//头文件using namespace std;//节点数据结构定义struct node{int data;node *next;};//创建一条含整数结点的无序链表node *CreateLinkList(){node *p1, *p2, *head;int n;p2 = NULL;head = NULL;cout <<"正在创建一个无序链表\n";cout <<"请输入一个整数，以-1结束：";cin >> n;//循环输入一个整数，直到数值为-1结束，创建一条无序链表while (n != -1){p1 = new node;p1->data = n;//采用尾插法，新建一个结点并连接到链表尾部if (head == 0){head = p1; p2 = p1; //首结点的建立}else{p2->next = p1; p2 = p1;}cout <<"请输入一个整数，以-1结束：";cin >> n;}if (head != 0) //尾结点p2->next = 0;return(head);}//输出结点void PrintLinkList(const node *head){const node *p;p = head;while (p != NULL){cout <<" "<< (p->data);p = p->next;}cout << endl;}//升序排序void SortLinkList(node *head){node temp;node *p = NULL;node *q = NULL;//判断结点为空或者只有一个结点if (head == NULL || head->next == NULL){return;}//p->next!=NULL为链表倒数第2个结点for (p = head; p->next != NULL; p = p->next) {for (q = p->next; q != NULL; q = q->next){if (p->data > q->data) //升序{ //交换数据域temp.data = q->data;q->data = p->data;p->data = temp.data;}}}return;}//奇数结点和int OddSumLinkList(const node *head){int sum = 0;const node *p;p = head;while (p){//判断数值为是否奇数if (p->data % 2 != 0){sum = sum + p->data;}p = p->next;}return sum;}//偶数结点和int EvenSumLinkList(const node *head){int sum = 0;const node *p;p = head;while (p){//判断是否偶数if (p->data % 2 == 0){sum = sum + p->data; //偶数结点的数值累加}p = p->next;}return sum;}//释放链表void DeleteLinkList(node *head){node *p;while (head){p = head;head = head->next;delete p;}printf("释放成功\n");}void main(){node *head;head = NULL;int select;cout <<"************菜单************"<< endl;cout <<"输入对应选择，执行对应操作"<< endl;cout <<"1.创建一条含整数结点的无序链表"<< endl;cout <<"2.链表结点的输出"<< endl;cout <<"3.链表节点的升序排序"<< endl;cout <<"4.分别计算链表中奇数和偶数结点之和并输出"<< endl;cout <<"5.释放链表"<< endl;cout <<"0.退出"<< endl;while (1){cout <<"\n请输入选择：";cin >> select;switch (select) //判断选项，并执行对应的函数{case 1:{head = CreateLinkList();printf("无序链表创建完成\n");break;}case 2:{printf("输出链表中各结点数据：");PrintLinkList(head);break;}case 3:{SortLinkList(head);printf("升序后：");PrintLinkList(head);break;}case 4:{int oddsum;int evensum;oddsum = OddSumLinkList(head);evensum = EvenSumLinkList(head);printf("奇数和= %d，偶数和= %d\n", oddsum, evensum);break;}case 5:{DeleteLinkList(head);break;}case 0:{cout <<"退出"<< endl;exit(0);}default:{cout <<"输入选项有误，请重新输入："<< endl;break;}}}}。
数据结构第一次作业及答案--线性表
第一次作业------------线性表题目1、下列图1单链表执行R->data=P->next->data语句后，P->next->data值为A. 5B. 7C. 2D. 3题目2、在顺序表中，只要知道( )，就可在相同时间内求出任一结点的存储地址。
A. 向量大小B. 基地址和结点大小C. 结点大小D. 基地址题目3、非空的循环单链表head的尾节点（由r所指向）满足( )A. r->next=NULLB. r->next=headC. r=NULLD. r=head题目4、设线性表（a1,a2,a3···an）按顺序存储,且每个元素占有m个存储单元，则元素ai 的地址为A. LOC(a1) + i×m ，其中LOC(a1)表示元素a1的地址B. 元素ai的地址无法计算C. LOC(a1) + (i-1)×m，D. LOC(a1) + (i－2)×m题目5、在（）运算中，使用顺序表比链表好。
A. 根据元素值查找B. 插入C. 根据序号查找D. 删除题目6、在一个单链表中，若P所指结点不是最后结点，在P之后插入S所指结点A. P→next=S;S→next=PB. S→next=P→next; P=SC. S→next=P→next;P→next=SD. S→next=P;P→next=S题目7、在双向循环链表的*p结点之后插入*s结点的操作是A. s->prior=p; s->next=p->next; p->next=s; p->next->prior=s;B. s->prior=p; s->next=p->next; p->next->prior=s; p->next=s;C. p->next=s; s->prior=p; p->next->prior=s; s->next=p->nextD. p->next=s; p->next->prior=s; s->prior=p; s->next=p->next题目8、单链表表示的整数数列如下图，值P->next->next->data为:A. 47B. 93C. 19D. 64题目9、在一个具有n个结点的有序单链表中插入一个新结点并仍然有序的时间复杂度是( )。
东大22年春学期《数据结构Ⅱ》在线平时作业1【参考答案】
《数据结构Ⅱ》在线平时作业1-00001
试卷总分:100 得分:100
一、单选题 (共 20 道试题,共 100 分)
1.用二叉链表表示具有n个结点的二叉树时，值为空的指针域的个数为
A.n-1
B.n
C.n+l
D.2n
正确答案:C
2.已知含10个结点的二叉排序树是一棵完全二叉树，则该二叉排序树在等概率情况下查找成功的平均查找长度等于
A.1.0
B.2.9
C.3.4
D.5.5
正确答案:B
3.对长度为n的关键字序列进行堆排序的空间复杂度为
A.O（log2n）
B.O（1）
C.O（n）
D.O（n*log2n）
正确答案:B
4.已知含6个顶点(v0，v1，v2，v3，v4，v5)的无向图的邻接矩阵如图所示，则从顶点v0出发进行深度优先遍历可能得到的顶点访问序列为
A..(v0，v1，v2，v5，v4，v3)
B.(v0，v1，v2，v3，v4，v5)
C.(v0，v1，v5，v2，v3，v4)
D..(v0，v1，v4，v5，v2，v3)
正确答案:B
5.n个顶点的有向完全图中含有向边的数目最多为
A.n-1
B.n
C.n(n-1)/2
D.n(n-1)
正确答案:D
6.在以单链表为存储结构的线性表中，数据元素之间的逻辑关系用
A.数据元素的相邻地址表示
B.数据元素在表中的序号表示
C.指向后继元素的指针表示。
顺序表、链表题库
第三章顺序表一、填空1．若线性表最常用的操作是存取第i 个元素及其前驱元素的值，则采用（）存储结构最节省运算时间。
2．顺序存储结构的线性表中所有元素的地址（）连续。
3．顺序存储结构的线性表其物理结构与逻辑结构是（）的。
4．在具有n个元素的顺序存储结构的线性表任意一个位置中插入一个元素，在等概率条件下，平均需要移动（）个元素。
5．在具有n个元素的顺序存储结构的线性表任意一个位置中删除一个元素，在等概率条件下，平均需要移动（）个元素。
6．在具有n个元素的顺序存储结构的线性表中查找某个元素，平均需要比较（）次。
7．当线性表的元素基本稳定，且很少进行插入和删除操作，但要求以最快的速度存取线性表中第i个元素时，应采用( )存储结构。
8．顺序存储结构的线性表中，插入或删除某个元素时，元素移动的次数与其位置（）关。
（填有或无）。
9．顺序存储结构的线性表中，访问第i个元素与其位置（）关。
（填有或无）。
10．在具有n个元素的顺序存储结构的线性表中要访问第i个元素的时间复杂度是（）。
11．在顺序表L中的i个位置插入某个元素x，正常插入时，i位置以及i位置以后的元素需要后移，首先后移的是（）个元素。
12．要删除顺序表L中的i位置的元素x，正常删除时，i位置以后的元素需要前移，首先前移的是（）元素。
13．若顺序表中的元素是从1位置开始存放的，要在具有n个元素的顺序表中插入一个元素，合法的插入位置是（）。
14．若顺序表中的元素是从1位置开始存放的，要删除具有n个元素的顺序表中某个元素，合法的删除位置是（）。
15．在具有n个元素的顺序存储结构的线性表中删除某个元素的时间复杂度是（）。
16．在具有n个元素的顺序存储结构的线性表中插入某个元素的时间复杂度是（）。
17．在具有n个元素的顺序存储结构的线性表中要访问第i个元素的后继结点的时间复杂度是（）。
18．在具有n个元素的顺序存储结构的线性表中，若给定的是某个元素的关键字值，要访问该元素的其它信息的时间复杂度是（）。
C语言第2章上机及作业题
第二章上机及作业题第二章上机题用三种存储结构（顺序表，链表，静态链表）求解josuphu问题！1：顺序表#include<stdio.h>#define max 100typedef struct{int data[max];int length;}stack,*pstack;pstack Creat() /*顺序表初始化*/{pstack p;p=(pstack)malloc(sizeof(stack));if(p)p->length=0;return p;}void Creatstack(pstack p) /*创建一个顺序表*/{int i,l,x;printf("please stack's length:\n");scanf("%d",&l);p->length=l;printf("please enter a stack:\n");for(i=0;i<l;i++){scanf("%d",&x);p->data[i]=x;}}Deletes(pstack p,int x) /*删除指定位置的元素*/{int i;for(i=x;i<=p->length;i++){p->data[i]=p->data[i+1];}p->length--;}int josephus(pstack p) /*约瑟夫循环*/{int s1,i,s,m,w;printf("please enter start adress:\n");scanf("%d",&s);printf("please enter how long to out eachother:\n");scanf("%d",&m);if(!p->length){printf("empty!\n");return 0;}s1=s-1;printf("please answer:\n");for(i=p->length;i>0;i--){s1=(s1+m-1)%i;w=p->data[s1];printf("%4d",w);Deletes(p,s1);}return 1;}int main() /*主函数*/ {pstack Q;Q=Creat();Creatstack(Q);josephus(Q);getch();}2：链表解决#include<stdio.h>typedef struct node /*定义一个链表结构体*/ {int data;struct node *next;}list,*List;void Putlist(List L) /*输入一个链表*/{int x,i,length;List s;L=NULL;printf("please enter the length:\n");scanf("%d",&length);printf("please enter the list:\n");for(i=0;i<length;i++){s=(List)malloc(sizeof(list));scanf("%d",&x);s->data=x;s->next=L;L=s;}s->next=L;}void Dislist(List L) /*输出链表*/{List p=L->next;printf("%d",L->data);while(p!=L){printf("%3d",p->data);p=p->next;}printf("\n");}int josephs(List L) /*约瑟夫循环的计算*/ {int s,m,count;List p,pre;printf("start in:\n");scanf("%d",&s);printf("how often:\n");scanf("%d",&m);if(!L){printf("the list is empty!\n");return 0;}p=L;for(count=1;count<s;count++){p=p->next;}printf("put the answer:\n");while(p!=p->next){for(count=1;count<m;count++) {pre=p;p=p->next;}printf("%2d",p->data);pre->next=p->next;free(p);p=pre->next;}printf(" %d",p->data);free(p);return 1;}void main(){int x,i,length;List L,s,r;s=L=(List)malloc(sizeof(list)); printf("please enter the length:\n"); scanf("%d",&length);printf("please enter the list:\n"); scanf("%d",&x);L->data=x;for(i=0;i<length-1;i++){r=(List)malloc(sizeof(list)); scanf("%d",&x);r->data=x;s->next=r;s=s->next;}s->next=L;josephs(L);getch();}3：静态链表#include<stdio.h>#define MAXSIZE 100struct node{int number;int next;}string[MAXSIZE];int josephus(void) /*约瑟夫循环*/ {int total;int out;int start;int i,j=1;int flag=0;int current,front;printf("The total number is:");scanf("%d",&total);printf("The out number is:");scanf("%d",&out);printf("The starting number is:");scanf("%d",&start);if(out==1) return total;for(i=0;i<total;i++){string[i].number=i+1;string[i].next=i+1;}string[i-1].next=0;front=total-1;current=0;for(i=1;i<start;i++){front=string[front].next;current =string[current].next;}while(flag<total){if(j%out==0){string[front].next=string[current].next;current=string[front].next;j=1;flag++;}else{j++;front=string[front].next;current =string[current].next;}}return(string[current].number);}void main(){int t;t=josephus();printf("The last one is %d",t);getch();}第二章作业：1．已知递增有序的两个单链表A，B分别存储了一个集合。
数据结构作业题
1 简述下列术语：线性表，顺序表，链表。
答：线性表是最常用且最简单的一种数据结构，一个线性表是N个数据元素的有限序列。
顺序表是指用一组地址连续的储存单元依次存储线性表的数据元素。
用这种方法存储的线性表简称顺序表。
链表是用一组任意的存储单元存储线性表中的数据元素。
用这种方法存储的线性表简称线性链表。
2 何时选用顺序表，何时选用链表作为线性表的存储结构合适?各自的主要优缺点是什么?答：线性表的逻辑顺序与物理顺序一致;数据元素之间的关系是以元素在计算机内“物理位置相邻”来体现。
而存储链表中结点的一组任意的存储单元可以是连续的，也可以是不连续的，甚至是零散分布在内存中的任意位置上的。
链表中结点的逻辑顺序和物理顺序不一定相同。
3 在顺序表中插入和删除一个结点平均需要移动多少个结点?具体的移动次数取决于哪两个因素?答：在顺序表中插入和删除一个结点平均需要移动1个结点，具体移动次数取决于时间复杂和空间复杂程度。
4 链表所表示的元素是否有序?如有序，则有序性体现于何处?链表所表示的元素是否一定要在物理上是相邻的?有序表的有序性又如何理解?答：链表元素的有序并不一定是值得有序，而是逻辑次序上的有序；链表中的元素并不需要物理位置上相邻，因为其逻辑联系已经在结点中包括了。
5 设顺序表L是递增有序表，试写一算法，将x插入到L中并使L仍是递增有序表。
答：using System;using System.Collections.Generic;using System.Collections;using System.Text;namespace test{class arrlist_test{public static ArrayList a = new ArrayList();public static void main(){do{currency.write("请写入下一个值");a.Add(Console.ReadLine());a.Sort();}while(currency .choice ());for (int i = 0; i < a.Count; i++){Console.Write("\t" + a[i]);}}}}6 写一求单链表的结点数目ListLength(L)的算法。
链表的常见操作
链表的常见操作
链表是一种常见的数据结构，其存储元素的个数是不受限定的，当要添加更多元素时，存储的个数会随之增加。
链表的操作包括但不限于以下几种：
1. 创建：链表的创建包括初始化链表、分配内存空间等操作。
2. 插入：在链表的指定位置插入一个元素。
3. 删除：删除链表中的指定元素或删除链表的指定位置的元素。
4. 查找：查找链表中是否存在指定的元素，并返回该元素的位置或指针。
5. 修改：修改链表中指定位置的元素的值。
6. 遍历：按照某种顺序遍历链表，并对每个元素进行操作。
7. 排序：按照某种规则对链表中的元素进行排序。
8. 合并：将两个已排序的链表合并成一个新的已排序链表。
9. 反转：将链表中的元素顺序反转。
10. 判断：判断链表是否为空、是否为循环链表等。
以上是链表的一些常见操作，具体实现方式会因编程语言和具体需求而有所不同。
链表的操作(3)
●循环链表判断空循环表的条件：Head == Head->next;NULL==head->next;//判断单链表是否为空仅设尾指针的单循环表（1）保存ha的位置（2）B表的第一个元素连到A表的最后一个元素之后（3）释放hb（4）B表的最后一个元素指向ha（5）返回新循环表尾指针LinkList ConnectList_L(LinkList A, LinkList B){LinkList p=A->next;A->next=B->next->next;free(B->next);B->next=p;Return B;}●双向链表1.定义typedef struct Lnode{int data;Struct Lnode *next;Struct Lnode *prior;}Lnode, *LinkList;2.插入结点（1）生成一个新结点s（2）把p->prior赋给s->prior(3) 使p->->next指向s（4）s->next指向p（5）p->prior 指向sStatus DulListInsert(DulLinklist L, int i, ElemType e){…//寻址If(!(s=(DulLinkList)malloc(sizeof(DulNode))))Return ERROR;s->data=e;s->prior=p->prior;p->prior->next=s;s->next=p;p->prior=s;return ok;}3.删除e=p->data;p->prior->next=p->next;p->next->prior=p->prior;free(p);作业双链表的创建并打印Input:1020 30 40 50Output10 20 30 40 50 50 40 30 20 10链表的初始化用法：#include <malloc.h>或#include<stdlib.h>功能：用于向内存申请空间，分配长度为num_bytes字节的内存块说明：如果分配成功则返回指向被分配内存的指针，否则返回空指针NULL。
数据结构与算法第二章作业答案
方法一：
void Move_MAX(LinkList &L) {
q=L; p=L->next;
while(p) {
if(p->data＞q->data) q=p;
p=p->next;
}//while循环，q指向最大值结点
if(q!=L) {
s=L; while(s->next!=q) s=s->next;//s指向q的直接前驱
q－>next＝NULL
L
…
35
67
18
52
s
值最大的结点不是首元结点
90 ∧ 14
q
s->next=q->next
71
…
82 65 ^
r
r->next=q
L＝q－>next
L
…
135 ∧ 67
18
q
52
90
14
71
…
82 65 ^
r
q－>next＝NULL
r->next=q
值最大的结点是首元结点
}
r=L; while(r->next) r=r->next; //r指向表尾结点
if(q!=r) {//若q是表尾结点，算法结束
if(q!=L) { //q不是第一个结点
s->next=q->next; r->next=q; q->next=NULL;
}
else { //q是第一个结点
L=q->next;
5. 已知不带头结点的非空线性链表头指针为L，请写一 个算法，将该链表中数据域值最大的那个结点移到链 表的最末端。（作业）
作业三
作业三选择题1．线性表是( A )。
A．一个有限序列，可以为空 B. 一个有限序列，不能为空C. 一个无限序列，可以为空D. 一个无序序列，不能为空2．从一个具有n个结点的单链表中查找值为x的结点，在查找成功情况下，需平均比较( D )个结点。
A. nB. n/2C. (n-1)/2D. (n+1)/23．线性表采用链式存储时，其各元素存储地址( D )。
A.必须是连续的B.部分地址必须是连续的C.一定是不连续的D.连续与否均可以4．用链表表示线性表的优点是( C )。
A.便于随机存取B.花费的存储空间较顺序存储少C.便于插入和删除D.数据元素的物理顺序与逻辑顺序相同5．( D )插入、删除速度快，但不能随机存取。
A. 链表B. 顺序表C. 顺序有序表D.上述三项无法比较6．若希望从链表中快速确定一个结点的前驱，则链表最好采用( C )方式。
A. 单链表B. 循环单链表C. 双向链表D. 任意7．下面关于线性表的叙述错误的是( B )。
A. 线性表采用顺序存储，必须占用一片地址连续的单元B. 线性表采用顺序存储，便于进行插入和删除操作C. 线性表采用链式存储，不必占用一片地址连续的单元D. 线性表采用链式存储，便于进行插入和删除操作8．带头结点的单链表head为空的判定条件是( B )。
A. head==NULLB. head->next==NULLC. head->next==headD. head!=NULL 9．若某线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素，则采用( A )存储方式最节省运算时间。
A.单链表B.仅有头指针的单循环链表C. 双链表D.仅有尾指针的单循环链表10．在循环双链表的p所指结点之后插入s所指结点的操作是( D )。
A. p->next=s; s->prior=p; p->next->prior=s; s->next=p->next;B. p->next=s; p->next->prior=s; s->prior=p; s->next=p->next;C. s->prior=p; s->next=p->next; p->next=s; p->next->prior=s;D. s->prior=p; s->next=p->next; p->next->prior=s; p->next =s;填空题1．对于采用顺序存储结构的线性表，当随机插入一个数据元素时，平均移动表中n/2 元素；删除一个数据元素时，平均移动表中 n/2 元素。
《数据结构》第二版严蔚敏课后习题作业参考答案(1-7章)
第1章4．答案：（1）顺序存储结构顺序存储结构是借助元素在存储器中的相对位置来表示数据元素之间的逻辑关系，通常借助程序设计语言的数组类型来描述。
（2）链式存储结构顺序存储结构要求所有的元素依次存放在一片连续的存储空间中，而链式存储结构，无需占用一整块存储空间。
但为了表示结点之间的关系，需要给每个结点附加指针字段，用于存放后继元素的存储地址。
所以链式存储结构通常借助于程序设计语言的指针类型来描述。
5. 选择题(1)~(6)：CCBDDA\6．（1）O(1) （2）O(m*n) （3）O(n2)（4）O(log3n) （5）O(n2) （6）O(n)（第2章1．选择题（1）~（5）：BABAD （6）~（10）： BCABD （11）~（15）：CDDAC\2．算法设计题（1）将两个递增的有序链表合并为一个递增的有序链表。
要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。
表中不允许有重复的数据。
[题目分析]合并后的新表使用头指针Lc指向，pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点，从第一个结点开始进行比较，当两个链表La和Lb均为到达表尾结点时，依次摘取其中较小者重新链接在Lc表的最后。
如果两个表中的元素相等，只摘取La表中的元素，删除Lb表中的元素，这样确保合并后表中无重复的元素。
当一个表到达表尾结点，为空时，将非空表的剩余元素直接链接在Lc表的最后。
void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc){法设计题（1）将编号为0和1的两个栈存放于一个数组空间V[m]中，栈底分别处于数组的两端。
当第0号栈的栈顶指针top[0]等于-1时该栈为空，当第1号栈的栈顶指针top[1]等于m时该栈为空。
两个栈均从两端向中间增长。
试编写双栈初始化，判断栈空、栈满、进栈和出栈等算法的函数。
数据结构线性表习题
第二章作业题1．求单链表中当前结点的后继和前驱的时间复杂度分别是（）A．O（n）和O（1）B．O（1）和O（1）C．O（1）和O（n）D．O(n)和O（n）2．非空的单循环链表的头指针为head,尾指针为rear，则下列条件成立的是（）A．rear->next= =head B．rear->next->next= =headC．head->next= =rear D．head->next->next= =rear3．在带头结点的循环链表L中，结点的数据元素为整型，且按值递增有序存放。
给定两个整数a和b，且a<b，编写算法删除链表L中元素值大于a且小于b的所有结点。
4．在线性表的下列运算中，不．改变数据元素之间结构关系的运算是（）A．插入B．删除C．排序D．定位5.已知指针p和q分别指向某单链表中第一个结点和最后一个结点。
假设指针s指向另一个单链表中某个结点，则在s所指结点之后插入上述链表应执行的语句为( ) A.q->next=s->next；s->next=p； B.s->next=p；q->next=s->next；C.p->next=s->next；s->next=q；D.s->next=q；p->next=s->next；6．若线性表的插入和删除操作频繁地在表头或表尾位置进行，则更适宜采用的存储结构为（）A．无头结点的双向链表B．带尾指针的循环链表C．无头结点的单链表D．带头指针的循环链表7.在下列对顺序表进行的操作中，算法时间复杂度为O(1)的是（）A.访问第i个元素的前驱（1<ni≤）B.在第i个元素之后插入一个新元素(n1≤≤)iC.删除第i个元素(n≤)i1≤D.对顺序表中元素进行排序8.在链表的结点中，数据元素所占的存储量和整个结点所占的存储量之比称作________。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
一、选择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. 单链表 B.单循环链表 C. 带尾指针的单循环链表 D.带头结点的双循环链表7．若某表最常用的操作是在最后一个结点之后插入一个结点或删除最后一个结点。
则采用（）存储方式最节省运算时间。
A．单链表 B．双链表 C．单循环链表 D．带头结点的双循环链表8. 静态链表中指针表示的是（）.A．内存地址 B．数组下标 C．下一元素地址 D．左、右孩子地址9. 链表不具有的特点是（）A．插入、删除不需要移动元素 B．可随机访问任一元素C．不必事先估计存储空间 D．所需空间与线性长度成正比10. 下面的叙述不正确的是（）A．线性表在链式存储时，查找第i 个元素的时间同i 的值成正比B. 线性表在链式存储时，查找第i 个元素的时间同i 的值无关C. 线性表在顺序存储时，查找第i 个元素的时间同i 的值成正比D. 线性表在顺序存储时，查找第i 个元素的时间同i 的值无关13. 若长度为n 的线性表采用顺序存储结构，在其第i 个位置插入一个新元素的算法的时间复杂度为（）(1<=i<=n+1)。
A. O(0)B. O(1)C. O(n)D. O(n2)14. 对于顺序存储的线性表，访问结点和增加、删除结点的时间复杂度为（）。
A．O(n) O(n) B. O(n) O(1) C. O(1) O(n) D. O(1) O(1)15．线性表（ a1,a2,…,an）以链接方式存储时，访问第i 位置元素的时间复杂性为（）A．O（i） B．O（1） C．O（n） D．O（i-1）23．在双向链表指针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->Llink;C. q->Rlink=p;q->Llink=p->Llink;p->Llink->Rlink=q;p->Llink=q;D. q->Llink=p->Llink;q->Rlink=q;p->Llink=q;p->Llink=q;24．在单链表指针为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;25．对于一个头指针为head 的带头结点的单链表，判定该表为空表的条件是（）A．head==NULL B．head→next==NULL C．head→next==head D．head!=NULL二、判断1. 链表中的头结点仅起到标识的作用。
( )2. 顺序存储结构的主要缺点是不利于插入或删除操作。
( )3．线性表采用链表存储时，结点和结点内部的存储空间可以是不连续的。
( )4．顺序存储方式插入和删除时效率太低，因此它不如链式存储方式好。
( )5. 对任何数据结构链式存储结构一定优于顺序存储结构。
( )6．顺序存储方式只能用于存储线性结构。
( )7．集合与线性表的区别在于是否按关键字排序。
( )8. 所谓静态链表就是一直不发生变化的链表。
( )9. 线性表的特点是每个元素都有一个前驱和一个后继。
( )10. 取线性表的第i 个元素的时间同i 的大小有关. ( )11. 循环链表不是线性表. ( )12. 线性表只能用顺序存储结构实现。
( )13. 线性表就是顺序存储的表。
( )14．为了很方便的插入和删除数据，可以使用双向链表存放数据。
( )15. 顺序存储方式的优点是存储密度大，且插入、删除运算效率高。
( )16. 链表是采用链式存储结构的线性表,进行插入、删除操作时，在链表中比在顺序存储结构中效率高。
( )三、填空1．当线性表的元素总数基本稳定，且很少进行插入和删除操作，但要求以最快的速度存取线性表中的元素时，应采用_______存储结构。
2．线性表L=（a1,a2,…,an）用数组表示，假定删除表中任一元素的概率相同，则删除一个元素平均需要移动元素的个数是________。
3．设单链表的结点结构为(data,next)，next 为指针域，已知指针px 指向单链表中data 为x 的结点，指针py 指向data 为y 的新结点 , 若将结点y 插入结点x 之后，则需要执行以下语句:_______； ______;4．在一个长度为n 的顺序表中第i 个元素（1<=i<=n）之前插入一个元素时，需向后移动________个元素。
5．在单链表中设置头结点的作用是________。
【哈尔滨工业大学 2000 二、1（1 分）】6．对于一个具有n 个结点的单链表，在已知的结点*p 后插入一个新结点的时间复杂度为________,在给定值为x 的结点后插入一个新结点的时间复杂度为________。
7．根据线性表的链式存储结构中每一个结点包含的指针个数，将线性链表分成________和_______；而又根据指针的连接方式，链表又可分成________和________。
8．在双向循环链表中,向p 所指的结点之后插入指针f 所指的结点，其操作是_______、_______、_______、________。
9. 在双向链表结构中，若要求在p 指针所指的结点之前插入指针为s 所指的结点，则需执行下列语句：_______________________________________10．链接存储的特点是利用________来表示数据元素之间的逻辑关系。
11.顺序存储结构是通过________表示元素之间的关系的;链式存储结构是通过________表示元素之间的关系的。
12. 对于双向链表,在两个结点之间插入一个新结点需修改的指针共 ______个，单链表为_______个。
13. 循环单链表的最大优点是：________。
14. 已知指针p 指向单链表L 中的某结点，则删除其后继结点的语句是：________15. 带头结点的双循环链表L 中只有一个元素结点的条件是：________16. 在单链表L 中，指针p 所指结点有后继结点的条件是：__17.带头结点的双循环链表L 为空表的条件是：________。
18. 在单链表p 结点之后插入s 结点的操作是：_______。
30. 以下程序的功能是实现带附加头结点的单链表数据结点逆序连接，请填空完善之。
void reverse(pointer h)/* h 为附加头结点指针；类型pointer 同算法设计第3 题*/{ pointer p,q;p=h->next; h->next=NULL;while((1)________){q=p; p=p->next; q->next=h->next; h->next=(2)________; }}34. 一元稀疏多项式以循环单链表按降幂排列，结点有三个域，系数域coef ，指数域exp 和指针域 next；现对链表求一阶导数，链表的头指针为ha，头结点的exp 域为–1。
derivative(ha){ q=ha ; pa=ha->next;while( (1)_______){ if ( (2)____) { ( (3)__); free(pa); pa= ( (4) _); }else{ pa->coef ( (5) ___); pa->exp( (6)___); q=( (7) __);}pa=( (8)________);}}36．对单链表中元素按插入方法排序的C 语言描述算法如下，其中L 为链表头结点指针。
请填充算法中标出的空白处，完成其功能。
typedef struct node{int data; struct node *next;}linknode,*link;void Insertsort(link L){ link p,q,r,u;p=L->next; (1)______;while((2)________){ r=L; q=L->next;while((3)________&& q->data<=p->data) {r=q; q=q->next;}u=p->next; (4)______; (5)______; p=u;}}四、算法设计1．假设有两个按元素值递增次序排列的线性表，均以单链表形式存储。
请编写算法将这两个单链表归并为一个按元素值递减次序排列的单链表，并要求利用原来两个单链表的结点存放归并后的单链表。
8. 已知线性表（a1 a2 a3 …an）按顺序存于内存，每个元素都是整数，试设计用最少时间把所有值为负数的元素移到全部正数值元素前边的算法：例：（x,-x,-x,x,x,-x …x）变为（-x,-x,-x…x,x,x）。
13. 设单链表的表头指针为h，结点结构由data 和next 两个域构成，其中data 域为字符型。
写出算法dc(h,n),判断该链表的前n 个字符是否中心对称。
例如 xyx, xyyx 都是中心对称23．已知L 为没有头结点的的单链表中第一个结点的指针，每个结点数据域存放一个字符，该字符可能是英文字母字符或数字字符或其它字符，编写算法构造三个以带头结点的单循环链表表示的线性表，使每个表中只含同一类字符。