单链表完整算法
1. #include
2. #include
3.
4. typedef int ElemType;
5.
6. //定义结点类型
7. typedef struct Node {
8. ElemType data; //单链表中的数据域
9. struct Node *next; //单链表的指针域
10. }Node,*LinkedList;
11.
12.
13. //单链表的初始化
14.
15. LinkedList LinkedListInit() {
16. Node *L;
17. L = (Node *)malloc(sizeof(Node)); //申请结点空间
18. if(L == NULL) { //判断是否有足够的内存空间
19. printf("申请内存空间失败\n");
20. }
21. L->next = NULL; //将next设置为NULL,初始长度为0的单链表
22. return L;
23. }
24.
25.
26. //单链表的建立1，头插法建立单链表
27.
28. LinkedList LinkedListCreatH() {
29. Node *L;
30. L = (Node *)malloc(sizeof(Node)); //申请头结点空间
31. L->next = NULL; //初始化一个空链表
32.
33. ElemType x; //x为链表数据域中的数据
34. while(scanf("%d",&x) != EOF) {
35. Node *p;
36. p = (Node *)malloc(sizeof(Node)); //申请新的结点
37. p->data = x; //结点数据域赋值
38. p->next = L->next; //将结点插入到表头
L-->|2|-->|1|-->NULL
39. L->next = p;
40. }
41. return L;
42. }
43.
44.
45. //单链表的建立2，尾插法建立单链表
46.
47. LinkedList LinkedListCreatT() {
48. Node *L;
49. L = (Node *)malloc(sizeof(Node)); //申请头结点空间
50. L->next = NULL; //初始化一个空链表
51. Node *r;
52. r = L; //r始终指向终端结点，开始时指向头结点
53. ElemType x; //x为链表数据域中的数据
54. while(scanf("%d",&x) != EOF) {
55. Node *p;
56. p = (Node *)malloc(sizeof(Node)); //申请新的结点
57. p->data = x; //结点数据域赋值
58. r->next = p; //将结点插入到表头L-->|1|-->|2|-->NULL
59. r = p;
60. }
61. r->next = NULL;
62.
63. return L;
64. }
65.
66.
67. //单链表的插入，在链表的第i个位置插入x的元素
68.
69. LinkedList LinkedListInsert(LinkedList L,int i,ElemType x) {
70. Node *pre; //pre为前驱结点
71. pre = L;
72. int tempi = 0;
73. for (tempi = 1; tempi < i; tempi++) {
74. pre = pre->next; //查找第i个位置的前驱结点
75. }
76. Node *p; //插入的结点为p
77. p = (Node *)malloc(sizeof(Node));
78. p->data = x;
79. p->next = pre->next;
80. pre->next = p;
81.
82. return L;
83. }
84.
85.
86. //单链表的删除，在链表中删除值为x的元素
87.
88. LinkedList LinkedListDelete(LinkedList L,ElemType x)
89. {
90. Node *p,*pre; //pre为前驱结点，p为查找的结点。
91. p = L->next;
92. while(p->data != x) { //查找值为x的元素
93. pre = p;
94. p = p->next;
95. }
96. pre->next = p->next; //删除操作，将其前驱next指向其后继。
97. free(p);
98. return L;
99. }
100.
101.
102. int main() {
103. LinkedList list,start;
104. printf("请输入单链表的数据：");
105. list = LinkedListCreatH();
106. for(start = list->next; start != NULL; start = start->next) {
107. printf("%d ",start->data);
108. }
109. printf("\n");
110. int i;
111. ElemType x;
112. printf("请输入插入数据的位置：");
113. scanf("%d",&i);
114. printf("请输入插入数据的值：");
115. scanf("%d",&x);
116. LinkedListInsert(list,i,x);
117. for(start = list->next; start != NULL; start = start->next) {
118. printf("%d ",start->data);
119. }
120. printf("\n");
121. printf("请输入要删除的元素的值：");
122. scanf("%d",&x);
123. LinkedListDelete(list,x);
124. for(start = list->next; start != NULL; start = start->next) {
125. printf("%d ",start->data);
126. }
127. printf("\n");
128.
129. return 0;
130. }
单链表的基本操作实验报告
湖南第一师范学院信息科学与工程系实验报告课程名称：数据结构与算法成绩评定：实验项目名称：单链表的基本操作指导教师：学生姓名：沈丽桃学号： 10403080118 专业班级： 10教育技术实验项目类型：验证实验地点：科B305 实验时间： 2011 年 10 月20 日一、实验目的与要求：实验目的：实现线性链表的创建、查找、插入、删除与输出。
基本原理：单链表的基本操作二、实验环境：（硬件环境、软件环境）1.硬件环境：奔ⅣPC。
2.软件环境：Windows XP 操作系统，TC2.0或VC＋＋。
三、实验内容：（原理、操作步骤、程序代码等）#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct celltype{int element;struct celltype*next;};typedef int position;void main(){struct celltype*head,*p;int x,choice;void INSERT(int x,struct celltype*p);void LOCATE(int x,struct celltype*p);void DELETE(int x,struct celltype*p);p=(struct celltype*)malloc(sizeof(struct celltype));head=p;p->element=0;p->next=NULL;printf(“Please option:1:Insert 2:Locate 3:Delete\n”);printf(“Please choose:”);scanf(“%d”,&choice);switch(choice)case 1:printf(“Please input a node:”);scanf(“%d”,&x);p=head;INSERT(x,p);for(p=head;p!=NULL;p=p->next)printf(“%d”,p->element);printf(“\n”);break;case 2:printf(“Please input the data you want to locate:”); scanf(“%d”,&x);p=head;LOCATE(x,p);break;case 3:printf(“Please input the data you want to delete:”); scanf(“%d”,&x);DELETE(x,p);for(p=head;p!=NULL;p=p->next)printf(“%d”,p->next);printf(“\n”);break;}void INSERT(int x,struct celltype*p){struct celltype*t,*q;q=(struct celltype*)malloc(sizeof(struct celltype)); q->next=x;while((x>p->element)&&(p!=NULL)){t=p;p=p->next;}if((x>p->element)&&(p->next!=NULL)){p->next=q;q->next=NULL;}else{q->next=p;t->next=q;}}void LOCATE(int x,struct celltype*p){while(p->next!=NULL)if(p->next->element==x)printf(“the number %d is in %d\n”,x,p);else printf(“the number not exist!\n”);}void DELETE(int x,struct celltype*p){while((p->element!=x)&&(p->next!=NULL)){t=p;p=p->next;}if(p->element==x)t->next=p->next}error C2018:unknown character ’Oxal’error C2065:’Please’:undeclared identifiererror C4024:’printf’:different types for formal and actual parameter 1error C4047:’function’:’const*differs in levers of indirection from ’int’error C2146:syntaxerror:missing’)’before identifier’option’error C2017:illegal escape sequenceerror C2059:syntax error:’)’error C2143:syntax error:missing’)’before’%’出现了很多错误，主要是因为printf里的一对双引号不是英文状态下的。
算法设计题打印部分
算法设计题打印部分假设有两个按元素值递增次序排列的线性表均以单链表形式存储。
请编写算法将这两个单链表归并为一个按元素值递减次序排列的单链表并要求利用原来两个单链表的结点存放归并后的单链表。
【北京大学1998 三、1 5分】类似本题的另外叙述有1设有两个无头结点的单链表头指针分别为hahb链中有数据域data链域next两链表的数据都按递增序存放现要求将hb表归到ha表中且归并后ha仍递增序归并中ha表中已有的数据若hb中也有则hb中的数据不归并到ha中hb的链表在算法中不允许破坏。
【南京理工大学1997 四、315分】PROCEDURE mergehahb 2已知头指针分别为la和lb 的带头结点的单链表中结点按元素值非递减有序排列。
写出将la 和lb两链表归并成一个结点按元素值非递减有序排列的单链表其头指针为lc并计算算法的时间复杂度。
【燕山大学1998 五20分】 2. 图编者略中带头结点且头指针为ha和hb的两线性表A和B 分别表示两个集合。
两表中的元素皆为递增有序。
请写一算法求A和B的并集AUB。
要求该并集中的元素仍保持递增有序。
且要利用A和B的原有结点空间。
【北京邮电大学1992 二15分】类似本题的另外叙述有1 已知递增有序的两个单链表AB分别存储了一个集合。
设计算法实现求两个集合的并集的运算A:A∪B【合肥工业大学1999 五、18分】2已知两个链表A和B分别表示两个集合其元素递增排列。
编一函数求A与B的交集并存放于A链表中。
【南京航空航天大学2001 六10分】3设有两个从小到大排序的带头结点的有序链表。
试编写求这两个链表交运算的算法即L1∩L2。
要求结果链表仍是从小到大排序但无重复元素。
【南京航空航天大学1996 十一10分】4己知两个线性表A B均以带头结点的单链表作存储结构且表中元素按值递增有序排列。
设计算法求出A 与B的交集C要求C另开辟存储空间要求C同样以元素值的递增序的单链表形式存贮。
数据结构C语言版 线性表的单链表存储结构表示和实现
#include 〈stdio.h>＃include <malloc。
h>＃include 〈stdlib.h>/＊数据结构C语言版线性表的单链表存储结构表示和实现P28—31编译环境：Dev-C++ 4。
9。
9。
2日期：2011年2月10日＊/typedef int ElemType;// 线性表的单链表存储结构typedef struct LNode{ElemType data; //数据域struct LNode *next；//指针域}LNode, ＊LinkList；// typedef struct LNode *LinkList；// 另一种定义LinkList的方法// 构造一个空的线性表Lint InitList（LinkList ＊L){/＊产生头结点L，并使L指向此头结点,头节点的数据域为空，不放数据的。
void ＊malloc(size_t)这里对返回值进行强制类型转换了,返回值是指向空类型的指针类型.＊/（＊L）= (LinkList）malloc（sizeof（struct LNode) ）;if( ！(＊L）)exit（0）；// 存储分配失败(＊L)-〉next = NULL；// 指针域为空return 1；}// 销毁线性表L,将包括头结点在内的所有元素释放其存储空间。
int DestroyList（LinkList ＊L）｛LinkList q;// 由于单链表的每一个元素是单独分配的，所以要一个一个的进行释放while（＊L )｛q = (*L)—〉next;free（＊L ）；//释放*L = q;}return 1；｝/*将L重置为空表,即将链表中除头结点外的所有元素释放其存储空间，但是将头结点指针域置空，这和销毁有区别哦。
不改变L，所以不需要用指针。
*/int ClearList( LinkList L )｛LinkList p，q；p = L—〉next；// p指向第一个结点while( p ) // 没到表尾则继续循环｛q = p—>next;free( p )；//释放空间p = q；}L—>next = NULL; // 头结点指针域为空,链表成了一个空表return 1;}// 若L为空表（根据头结点L—〉next来判断，为空则是空表)，则返回1，// 否则返回0.int ListEmpty(LinkList L）{if（L—>next ) // 非空return 0;elsereturn 1；｝// 返回L中数据元素个数。
数据结构-链表
设顺序表L是一个递增有序表，试写一算法，将x插入L 设顺序表L是一个递增有序表，试写一算法，将x插入L中，并使 L仍是一个有序表。 因已知顺序表L 因已知顺序表L是递增有序表，所以只要从头找起找到第一个比 它大(或相等)的结点数据，把x 它大(或相等)的结点数据，把x插入到这个数所在的位置就是了。 算法如下： void InsertIncreaseList( Seqlist *L , Datatype x ) { int i; Lfor ( i=0 ; i < L -> length && L->data[ i ] < x ; i++) ; // 查找并比较 调用顺序表插入函数p24 ListInsert_sq ( L ，x , i ); // 调用顺序表插入函数p24 }
2.1 试描述头指针、头结点、开始结点的区别、并 试描述头指针、头结点、开始结点的区别、 说明头指针和头结点的作用。 说明头指针和头结点的作用。 2.2 何时选用顺序表、何时选用链表作为线性表的 何时选用顺序表、 存储结构为宜? 存储结构为宜 2.3 在顺序表中插入和删除一个结点需平均移动 多少个结点?具体的移动次数取决于哪两个因素? 多少个结点?具体的移动次数取决于哪两个因素? 2.4 为什么在单循环链表中设置尾指针比设置头 指针更好? 指针更好? 2.5 在单链表、双链表和单循环链表中，若仅知 道指针p 道指针p指向某结点，不知道头指针，能否将结点 从相应的链表中删去? *p从相应的链表中删去?若可以，其时间复杂度各 为多少? 为多少?
假设在长度大于1的单循环链表中，既无头结点也无头指针。s 假设在长度大于1的单循环链表中，既无头结点也无头指针。s为指向链 表中某个结点的指针，试编写算法删除结点* 表中某个结点的指针，试编写算法删除结点*s的直接前趋结点。 已知指向这个结点的指针是* 已知指向这个结点的指针是*s，那么要删除这个结点的直接前趋结点， 就只要找到一个结点，它的指针域是指向* 就只要找到一个结点，它的指针域是指向*s的，把这个结点删除就可以 了。 算法如下： void DeleteNode( ListNode *s) { //删除单循环链表中指定结点的直接前趋结点 //删除单循环链表中指定结点的直接前趋结点 ListNode *p, *q; p=s; p->nextwhile( p->next->next!=s) { q=p; / p=pp=p->next; } //删除结点 q->next=s; //删除结点 //释放空间 free(p); //释放空间 }
链表(单链表 双向循环)实验报告讲解
数据结构实验报告T1223-3-21余帅实验一实验题目：仅仅做链表部分难度从上到下1.双向链表，带表头，线性表常规操作。
2.循环表，带表头，线性表常规操作。
3.单链表，带表头，线性表常规操作。
实验目的：了解和掌握线性表的逻辑结构和链式存储结构，掌握单链表的基本算法及相关的时间性能分析。
实验要求：常规操作至少有：1.数据输入或建立2.遍历3.插入4.删除必须能多次反复运行实验主要步骤：1、分析、理解给出的示例程序。
2、调试程序，并设计输入数据，测试程序的如下功能：1.数据输入或建立2.遍历3.插入4.删除单链表示意图：headhead head 创建删除双向循环链表示意图：创建程序代码://单链表#include<iostream.h>#include<windows.h>const MAX=5;enum returninfo{success,fail,overflow,underflow,range_error}; int defaultdata[MAX]={11,22,33,44,55};class node{public:int data;node *next;};class linklist{private:node *headp;protected:int count;public:linklist();~linklist();bool empty();void clearlist();returninfo create(void);returninfo insert(int position,const int &item);returninfo remove(int position) ;returninfo traverse(void);};linklist::linklist(){headp = new node;headp->next = NULL;count=0;}linklist::~linklist(){clearlist();delete headp;}bool linklist::empty(){if(headp->next==NULL)return true;elsereturn false;}void linklist::clearlist(){node *searchp=headp->next,*followp=headp;while(searchp->next!=NULL){followp=searchp;searchp=searchp->next;delete followp;}headp->next = NULL;count = 0;}returninfo linklist::create(){node *searchp=headp,*newnodep;for(int i=0;i<MAX;i++){newnodep = new node;newnodep->data = defaultdata[i];newnodep->next = NULL;searchp->next = newnodep;searchp = searchp->next;count++;}searchp->next = NULL;traverse();return success;}returninfo linklist::insert(int position,const int &item) //插入一个结点{if(position<=0 || position>=count)return range_error;node *newnodep=new node,*searchp=headp->next,*followp=headp;for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}newnodep->data=item; //给数据赋值newnodep->next=followp->next; //注意此处的次序相关性followp->next=newnodep;count++; //计数器加一return success;}returninfo linklist::remove(int position) //删除一个结点{if(empty())return underflow;if(position<=0||position>=count+1)return range_error;node *searchp=headp->next,*followp=headp; //这里两个指针的初始值设计一前一后for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}followp->next=searchp->next; //删除结点的实际语句delete searchp; //释放该结点count--; //计数器减一return success;}returninfo linklist::traverse(void){node *searchp;if(empty())return underflow;searchp = headp->next;cout<<"连表中的数据为："<<endl;while(searchp!=NULL){cout<<searchp->data<<" ";searchp = searchp->next;}cout<<endl;return success;}class interfacebase{public:linklist listface; //定义一个对象Cskillstudyonfacevoid clearscreen(void);void showmenu(void);void processmenu(void);};void interfacebase::clearscreen(void){system("cls");}void interfacebase::showmenu(void){cout<<"================================"<<endl;cout<<" 功能菜单 "<<endl;cout<<" 1.创建链表 "<<endl;cout<<" 2.增加结点 "<<endl;cout<<" 3.删除结点 "<<endl;cout<<" 4.遍历链表 "<<endl;cout<<" 0.结束程序 "<<endl;cout<<"======================================"<<endl;cout<<"请输入您的选择：";}void interfacebase::processmenu(void){int returnvalue,item,position;char menuchoice;cin >>menuchoice;switch(menuchoice) //根据用户的选择进行相应的操作{case '1':returnvalue=listface.create();if(returnvalue==success)cout<<"链表创建已完成"<<endl;break;case '2':cout<<"请输入插入位置："<<endl;cin>>position;cout<<"请输入插入数据："<<endl;cin>>item;returnvalue = listface.insert(position,item);if(returnvalue==range_error)cout<<"数据个数超出范围"<<endl;elsecout<<"操作成功！！！"<<endl;break;case '3':cout<<"输入你要删除的位置："<<endl;cin>>position;returnvalue = listface.remove(position);if(returnvalue==underflow)cout<<"链表已空"<<endl;else if(returnvalue==range_error)cout<<"删除的数据位置超区范围"<<endl;elsecout<<"操作成功！！！"<<endl;break;case '4':listface.traverse();break;case '0':cout<<endl<<endl<<"您已经成功退出本系统，欢迎再次使用!!!"<<endl;system("pause");exit(1);default:cout<<"对不起，您输入的功能编号有错!请重新输入!!!"<<endl;break;}}void main(){interfacebase interfacenow;linklist listnow;system("color f0");interfacenow.clearscreen();while(1){interfacenow.showmenu();interfacenow.processmenu();system("pause");interfacenow.clearscreen();}}/* 功能：用双向循环链表存储数据1.创建链表2.增加结点3.删除结点4.遍历链表制作人：余帅内容：239行*/#include<iostream.h>#include<windows.h>const MAX=5;enum returninfo{success,fail,overflow,underflow,range_error}; int defaultdata[MAX]={11,22,33,44,55};class node{public:int data;node * next; //指向后续节点node * pre; //指向前面的节点};class linklist{private:node *headp;protected:int count;public:linklist();~linklist();bool empty();void clearlist();returninfo create(void);returninfo insert(int position,const int &item);returninfo remove(int position) ;returninfo traverse(void);};linklist::linklist(){headp = new node;headp->next = NULL;headp->pre = NULL;count=0;}linklist::~linklist(){clearlist();delete headp;}bool linklist::empty(){if(headp->next==NULL)return true;elsereturn false;}void linklist::clearlist(){node *searchp=headp->next,*followp=headp;while(searchp->next!=NULL){followp=searchp;searchp=searchp->next;delete followp;}headp->next = NULL;headp->pre = NULL;count = 0;}returninfo linklist::create(){node *searchp=headp,*newnodep;for(int i=0;i<MAX;i++){newnodep = new node;newnodep->data = defaultdata[i];newnodep->next = NULL;searchp->next = newnodep;newnodep->pre = searchp;searchp = searchp->next;count++;}searchp->next = headp;headp->pre = searchp;traverse();return success;}returninfo linklist::insert(int position,const int &item) //插入一个结点{if(position<=0 || position>count+1)return range_error;node *newnodep=new node;node *searchp=headp->next,*followp=headp;for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}newnodep->data=item; //给数据赋值newnodep->next = searchp;searchp->pre = newnodep;followp->next = newnodep;newnodep->pre = followp;count++; //计数器加一return success;}returninfo linklist::remove(int position) //删除一个结点{if(empty())return underflow;if(position<=0||position>=count+1)return range_error;node *searchp=headp->next,*followp=headp; //这里两个指针的初始值设计一前一后for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}followp->next=searchp->next; //删除结点的实际语句searchp->next->pre = followp;delete searchp; //释放该结点count--; //计数器减一return success;}returninfo linklist::traverse(void){node *searchp1,*searchp2;if(empty())return underflow;searchp1 = headp;searchp2 = headp;cout<<"连表中的数据为："<<endl;cout<<"从左至右读取：";while (searchp1->next!=headp ) {searchp1 = searchp1 ->next;cout << searchp1->data<<" ";}cout<<endl;cout<<"从右至左读取：";while (searchp2->pre!=headp ) {searchp2 = searchp2 ->pre;cout << searchp2->data<<" ";}cout<<endl;return success;}class interfacebase{public:linklist listface; //定义一个对象Cskillstudyonface void clearscreen(void);void showmenu(void);void processmenu(void);};void interfacebase::clearscreen(void){system("cls");}void interfacebase::showmenu(void){cout<<"================================"<<endl;cout<<" 功能菜单 "<<endl;cout<<" 1.创建链表 "<<endl;cout<<" 2.增加结点 "<<endl;cout<<" 3.删除结点 "<<endl;cout<<" 4.遍历链表 "<<endl;cout<<" 0.结束程序 "<<endl;cout<<"======================================"<<endl;cout<<"请输入您的选择：";}void interfacebase::processmenu(void){int returnvalue,item,position;char menuchoice;cin >>menuchoice;switch(menuchoice) //根据用户的选择进行相应的操作{case '1':returnvalue=listface.create();if(returnvalue==success)cout<<"链表创建已完成"<<endl;break;case '2':cout<<"请输入插入位置："<<endl;cin>>position;cout<<"请输入插入数据："<<endl;cin>>item;returnvalue = listface.insert(position,item);if(returnvalue==range_error)cout<<"数据个数超出范围"<<endl;elsecout<<"操作成功！！！"<<endl;break;case '3':cout<<"输入你要删除的位置："<<endl;cin>>position;returnvalue = listface.remove(position);if(returnvalue==underflow)cout<<"链表已空"<<endl;else if(returnvalue==range_error)cout<<"删除的数据位置超区范围"<<endl;elsecout<<"操作成功！！！"<<endl;break;case '4':listface.traverse();break;case '0':cout<<endl<<endl<<"您已经成功退出本系统，欢迎再次使用!!!"<<endl;system("pause");exit(1);default:cout<<"对不起，您输入的功能编号有错!请重新输入!!!"<<endl;break;}}void main(){interfacebase interfacenow;linklist listnow;system("color f0");interfacenow.clearscreen();while(1){interfacenow.showmenu();interfacenow.processmenu();system("pause");interfacenow.clearscreen();}}运行结果：1.创建链表：2.增加结点3．删除结点心得体会：本次实验使我们对链表的实质了解更加明确了，对链表的一些基本操作也更加熟练了。
数据结构实验报告-单链表
2016级数据结构实验报告实验名称：实验一线性表——题目1学生姓名：李文超班级：2015661131班内序号：15学号：2015522147日期：2016年11月13日1.实验要求实验目的：根据线性表的抽象数据类型的定义，选择下面任一种链式结构实现线性表，并完成线性表的基本功能。
线性表存储结构（五选一）：1、带头结点的单链表2、不带头结点的单链表3、循环链表4、双链表5、静态链表线性表的基本功能：1、构造：使用头插法、尾插法两种方法2、插入：要求建立的链表按照关键字从小到大有序3、删除4、查找5、获取链表长度6、销毁7、其他：可自行定义编写测试main()函数测试线性表的正确性。
2.程序分析2.1 存储结构单链表的存储：（1）链表用一组任意的存储单元来存放线性表的结点。
这组存储单元既可以是连续的，也可以是不连续的，甚至零散地分布在内存的某些位置。
（2）链表中结点的逻辑次序和物理次序不一定相同。
为了能正确表示结点间的逻辑关系，在存储每个元素值的同时，还要存储该元素的直接后继元素的位置信息，这个信息称为指针或链。
结点结构┌──┬──┐ data 域---存放结点值的数据域│data │next │ next 域---存放结点的直接后继的地址的指针域└──┴──┘单链表在内存中的存储示意地址 内存单元1000H头指针 1020H1080H10C0H2.2 关键算法分析1、关键算法：（1）头插法自然语言描述：a:在堆中建立新结点b:将a[i]写入到新结点的数据域c:修改新结点的指针域d:修改头结点的指针域。
将新结点加入链表中伪代码描述a:Node <T> * s=new Node <T>b:s->data=a[i]c:s->next=front->next;d:front->next=s（2）尾插法自然语言描述：a:在堆中建立新结点：b:将a[i]写入到新结点的数据域：c:将新结点加入到链表中d:修改修改尾指针伪代码描述a:Node <T> * s=new Node <T>b:s->data=a[i]c:r->next=s;d:r=s（3）遍历打印函数自然语言描述：a:判断该链表是否为空链表，如果是，报错b:如果不是空链表，新建立一个temp指针c:将temp指针指向头结点d:打印temp指针的data域e:逐个往后移动temp指针，直到temp指针的指向的指针的next域为空伪代码描述a: If front->next==NULL①Throw ”an empty list ”②Node<T>* temp=front->next;b:while(temp->next)c:cout<<temp->data<<" ";d:temp=temp->next;(4) 获取链表长度函数自然语言描述：a:判断该链表是否为空链表，如果是，输出长度0b:如果不是空链表，新建立一个temp指针，初始化整形数n为0c:将temp指针指向头结点d:判断temp指针指向的结点的next域是否为空，如果不是，n加一，否则return ne: 使temp指针逐个后移，重复d操作，直到temp指针指向的结点的next域为0，返回n伪代码描述a:if ront->next==NULLb:Node<T>* temp=front->next;c:while(temp->next)d:temp=temp->next;（5）析构/删除函数自然语言描述：a:新建立一个指针，指向头结点b:判断要释放的结点是否存在，c:暂时保存要释放的结点d:移动a中建立的指针e:释放要释放的指针伪代码描述a:Node <T> * p=frontb:while(p)c:front=pd:p=p->nexte:delete front（6）按位查找函数自然语言描述：a:初始化工作指针p和计数器j，p指向第一个结点，j=1b:循环以下操作，直到p为空或者j等于1①：p指向下一个结点②：j加1c:若p为空，说明第i个元素不存在，抛出异常d:否则，说明p指向的元素就是所查找的元素，返回元素地址伪代码描述a:Node <T> * p=front->next;j=1;b:while(p&&j!=1)①:p=p->next②:j++c:if(!p) throw ”error”d:return p（7）按位查找函数自然语言描述：a:初始化工作指针p和计数器j，p指向第一个结点，j=1b:循环以下操作，找到这个元素或者p指向最后一个结点①：判断p指向的结点是不是要查找的值，如果是，返回j，否则p指向下一个结点，并且j的值加一c:如果找到最后一个结点还没有找到要查找的元素，返回查找失败信息伪代码描述a:Node <T> * p=front->next;j=1;b:while(p)①: if(p->next==x) return jp=p->nextj++c:return “error”（8）插入函数自然语言描述：a:在堆中建立新结点b:将要插入的结点的数据写入到新结点的数据域c:修改新结点的指针域d:修改前一个指针的指针域，使其指向新插入的结点的位置伪代码描述a:Node <T> * s=new Node <T>;b:s-data=p->datac:s->next=p->nextd:p->next=se:p->data=x（9）删除函数自然语言描述：a:从第一个结点开始，查找要删除的位数i前一个位置i-1的结点b:设q指向第i个元素c:将q元素从链表中删除d:保存q元素的数据e:释放q元素伪代码描述a:q=p->nextb:p->next=q->nextc:x=q->datad:delete q2、代码详细分析（插入）：（1）从第一个结点开始，查找节点，使它的数据比x大，设p指向该结点：while (x>p->data) { p=p->next;}（2）新建一个节点s，把p的数据赋给s：s->data=p->data;（3）把s加到p后面：s->next=p->next; p->next=s;（4）p节点的数据用x替换：p->data=x;示意图如图所示xp->datas3、关键算法的时间复杂度：O（1)3.程序运行结果1. 流程图：2、结果截图3.测试结论：可以正确的对链表进行插入，删除，取长度，输出操作。
数据结构单链表实验报告
{
printf("删除结点的位置i不合理!");
return ERROR;
}
r=pre->next;
pre->next=pre->next->next; /*修改指针，删除结点r*/
返回值说明：返回ERROR插入失败，返回OK插入成功;
（5）按位置查找链表元素：int GetList(LinkList L,int i,int *e);
4.详细设计
void init_linklist(LinkList *l)/*对单链表进行初始化*/{
*l=(LinkList)malloc(sizeof(Node)); /*申请结点空间*/
(*l)->next=NULL; /*置为空表*/
}
void CreateFromHead(LinkList L)
{
Node *s;
charc;
intflag=1;
while(flag) /* flag初值为1，当输入"$"时，置flag为0，建表结束*/
{
c=getchar();
if(c!='$')
*e = r->data;
free(r); /*释放被删除的结点所占的内存空间*/
printf("成功删除结点!");
return OK;
}
intListLength(LinkList L)
/*求带头结点的单链表L的长度*/
(完整版)第三章单链表题目和答案
第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 、 1B、 2C、 3D、 4（ D ） 7、设一个链表最常用的操作是在末端插入结点和删除尾结点，则采纳最节俭时间。
数据结构c++顺序表、单链表的基本操作,查找、排序代码
} return 0; }
实验三 查找
实验名称： 实验3 查找 实验目的：掌握顺序表和有序表的查找方法及算法实现；掌握二叉排序 树和哈希表的构造和查找方法。通过上机操作,理解如何科学地组织信 息存储,并选择高效的查找算法。 实验内容：（2选1）内容1： 基本查找算法；内容2： 哈希表设计。 实验要求：1）在C++系统中编程实现；2）选择合适的数据结构实现查 找算法；3）写出算法设计的基本原理或画出流程图；4）算法实现代码 简洁明了；关键语句要有注释；5）给出调试和测试结果；6）完成实验 报告。 实验步骤： (1)算法设计 a.构造哈希函数的方法很多，常用的有(1)直接定址法(2)数字分析法;(3) 平方取中法;(4)折叠法;( 5)除留余数法;(6)随机数法；本实验采用的是除 留余数法:取关键字被某个不大于哈希表表长m的数p除后所得余数为哈 希地址 (2)算法实现 hash hashlist[n]; void listname(){ char *f; int s0,r,i; NameList[0].py="baojie"; NameList[1].py="chengቤተ መጻሕፍቲ ባይዱoyang"; ……………………………… NameList[29].py="wurenke"; for(i=0;i<q;i++){s0=0;f=NameList[i].py; for(r=0;*(f+r)!='\0';r++) s0+=*(f+r);NameList[i].k=s0; }} void creathash(){int i;
v[k-1]=v[k]; nn=nn-1; return ; } int main() {sq_LList<double>s1(100); cout<<"第一次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.ins_sq_LList(0,1.5); s1.ins_sq_LList(1,2.5); s1.ins_sq_LList(4,3.5); cout<<"第二次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.del_sq_LList(0); s1.del_sq_LList(2); cout<<"第三次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); return 0; } 运行及结果：
c语言单链表程序代码
c语言单链表程序代码单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。
单链表的优点在于插入和删除操作的效率高，但是访问任意节点的效率较低。
下面是一个简单的单链表程序代码：```c#include <stdio.h>#include <stdlib.h>struct Node {int data;struct Node* next;};void insert(struct Node** head, int data) {struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));newNode->data = data;newNode->next = *head;*head = newNode;}void printList(struct Node* head) {while (head != NULL) {printf("%d ", head->data);head = head->next;}printf("\n");}int main() {struct Node* head = NULL;insert(&head, 1);insert(&head, 2);insert(&head, 3);printList(head);return 0;}```这个程序定义了一个结构体`Node`，包含一个整型数据`data`和一个指向下一个节点的指针`next`。
`insert`函数用于在链表头部插入一个新节点，`printList`函数用于打印整个链表。
在`main`函数中，我们创建了一个空链表`head`，然后插入了三个节点，最后打印整个链表。
这个程序虽然简单，但是涉及到了单链表的基本操作。