数据结构线性表单链表的查找,插入,删除
实验01 线性表的基本操作
实验01 线性表的基本操作一、实验目的1. 了解线性表的结构特点及有关概念；2. 理解线性表的存储结构；3. 掌握顺序表及单链表的基本操作算法。
二、实验内容1、编写程序实现顺序表的各种基本运算：初始化、插入、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。
在此基础上设计一个主程序完成如下功能：（1）初始化顺序表L；（2）依次在表尾插入a，b，c，d，e五个元素；（3）输出顺序表L；（4）输出顺序表L的长度；（5）判断顺序表L是否为空；（6）输出顺序表L的第4个元素；（7）输出元素c的位置；（8）在第3个位置上插入元素f，之后输出顺序表L；（9）删除L的第2个元素，之后输出顺序表L；（10）销毁顺序表L。
2、编写程序实现单链表的各种基本运算：初始化、插入、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。
在此基础上设计一个主程序完成如下功能：（1）初始化单链表L；（2）依次在表尾插入a，b，c，d，e五个元素；（3）输出单链表L；（4）输出单链表L的长度；（5）判断单链表L是否为空；（6）输出单链表L的第4个元素；（7）输出元素c的位置；（8）在第3个位置上插入元素f，之后输出单链表L；（9）删除L的第2个元素，之后输出单链表L；（10）销毁单链表L。
三、实验要点及说明一．顺序表1.顺序表初始化:(1)为顺序表L动态分配一个预定大小的数组空间，使elem 指向这段空间的基地址。
(2)将表的当前长度设为0.2.顺序表的取值:(1)判断指定的位置序号i值是否合理（1<=i<=L.length），若不合理则返回ERROR.(2)若i值合理，则将i个数据元素L.elem[i]赋给参数e,通过e返回第i个数据元素的传值。
3.顺序表的查找:(1)从第一个元素起，依次和e相比较，若找到与e相等的元素L.elem[i]，则查找成功，返回该元素的序号i+1.(2)若查遍整个顺序表都没要找到，则查找失败，返回0.4．顺序表的插入:(1)判断插入位置i是否合法(i值的合法范围是1<=i<=n+1)，若不合法则返回值ERROR.(2)判断顺序表的存储空间是否已满，若满则返回值ERROR(3)将第n个至第i个位置的元素依次向后移动一个位置，空出第i个位置(i=n+1时无需移动)。
(完整版)数据结构线性表的主要程序代码
数据结构顺序表的主要代码（LIZHULIN）1．/***有头结点的单链表的初始化、建立（表头插入、表尾插入）、求长度、插入、删除、输出***//***********单链表的初始化、建立、输出*****************/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/****************单链表的初始化*************************/Initlist(LinkList *L){ /*动态申请存储空间*/L = (LinkList *)malloc(sizeof(struct Lnode));/*建立头结点*/L->next = NULL;}/*************建立一个带头结点的单链表，在表尾插入***************/Create_L(LinkList *L,int n){LinkList *p,*q; int i;Initlist(L); /*单链表初始化*/q=L;printf("input the value\n");for(i = n;i>0;--i){p = (LinkList*)malloc(sizeof(struct Lnode));scanf("%d",&p->data); /*输入元素值*/q->next = p;p->next = NULL;q=p;/*插入到表尾*/}} /* Create_L *//*************建立一个带头结点的单链表，在表头插入**************Create_L(LinkList *L,int n){LinkList *p; int i;Initlist(L); /*单链表初始化/*需要注意第一个数据插入时的情况/*Insert the Firset nodep = (LinkList*)malloc(sizeof(struct Lnode));printf("input the value\n");scanf("%d",&p->data); /*输入元素值L->next = p;p->next = NULL;/*将第二个及后面的数据插入for(i = n-1;i>0;--i){p = (LinkList*)malloc(sizeof(struct Lnode));printf("input a value\n");scanf("%d",&p->data); /*输入元素值p->next = L->next;L->next = p;/*插入到表头}} /* Create_L *//*************************求单链表的长度***********************/int Length_LinkList(LinkList *L){LinkList *p;int i=0;p=L->next;while(p!=NULL){i++;p=p->next;}return i;}/*Length_LinkList*//*************************在第i个结点前插入数据x *********************/ Insert_LinkList(LinkList *L, int i, int x){LinkList *p,*s;int j=0;p=L;/*寻找第i个结点*/while(j<i-1 && p!=NULL){++j;p=p->next;}if (!p) return 0;/*如果表长小于i，则无意义*//*插入元素x */s=(LinkList *)malloc(sizeof(struct Lnode));s->data=x;s->next=p->next;p->next=s;}/*********************删除第i个元素，并用y将其值返回************************/ int Delete_LinkList(LinkList *L, int i){LinkList *p,*q;int y;int j=0;p=L;/*寻找第i个结点*/while(j<i-1 && p!=NULL){++j;p=p->next;}if (!p) return 0;/*如果表长小于i，则无意义*/q=p->next;y=q->data;p->next=q->next;free(q) ;return y;} /*Delete_LinkList*//*******************单链表值的输出****************/void display(LinkList *L) /*字母链表的输出*/{LinkList *p;p=L->next;while (p!=NULL){printf("%d ",p->data);p=p->next;}}/*************主程序**********************/ main(){LinkList *L;int len;int n=0;int x=15;int y;int i=4;L = (LinkList*)malloc(sizeof(struct Lnode));/*L->data = 0;*/L->next =NULL;printf("input the length of L ,n\n");scanf("%d",&n);printf("\n");Create_L(L,n);Insert_LinkList(L, i, x);/* y=Delete_LinkList(L,i);printf("the delete elment is y=%d\n",y);len=Length_LinkList(L);printf("the length of L is %d",len);*/display(L);getch();}2．/***无头结点的单链表建立、插入、求长度、插入、删除、输出*****/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/*************Create ***************/Link_Creat(LinkList *L,int n){LinkList *q,*p;int i;printf("input the data\n");scanf("%d",&L->data);p=L;for(i=2; i<=n;i++){q=(LinkList *)malloc(sizeof(struct Lnode));scanf("%d",&q->data);p->next=q;q->next=NULL;p=q;}}/**************OutPut*********************/Link_Display(LinkList *L){LinkList *p;p=L;while(p!=NULL){printf("%d ",p->data);p=p->next;}}/***************Main()**************************/main(){LinkList *L;int n;L=(LinkList *)malloc(sizeof(struct Lnode));L->data=0;L->next=NULL;printf("Please input the length of LinkList, n\n");scanf("%d",&n);Link_Creat(L,n);Link_Display(L);getch();}3．/*********顺序表的建立、查找、插入运算********/#include <stdio.h>#include <stdlib.h>typedef int datatype;#define list_maxsize 20/********* define for node struct ************/typedef struct{datatype data[list_maxsize];int length;}SqList;/********** InitList ************/void InitList(SqList *L){L->length = 0;}/*******Creat SqList********/void Create_SqList(SqList *L){int i=0;InitList(L);printf("input SqList.data\n");scanf("%d",&L->data[0]);while(L->data[i]!=-1){++i;scanf("%d",&(L->data[i]));}L->length = i;}/********* the length of SqList****************/int ListLength(SqList *L){return L->length;}/************ GetElem L->data[i]************/int GetElem(SqList *L, int i){if(i<1 || i>L->length){ printf("Position Error");return;}elsereturn L->data[i-1];}/**************** Output the SqList**************/ void Display_SqList(SqList *L){int i,n;n=ListLength(L);printf("the length is %d ",n);for(i=0;i<n;i++)printf("%d ", L->data[i]);}/****************Main()**************************/ main(){SqList *L;/*printf("input the length of SqList\n");scanf("%d",&len);*/Create_SqList(L);Display_SqList(L);getch();}4．/*********顺序表的归并运算********/#include <stdio.h>#include <stdlib.h>typedef int datatype;#define list_maxsize 20/********* define for node struct ************/typedef struct{datatype data[list_maxsize];int length;}SqList;/********** InitList ************/void InitList(SqList *L){L->length = 0;}/************ Creat SqList*************/void Create_SqList(SqList *L){int i=0;InitList(L);printf("input the data of SqList\n");scanf("%d",&L->data[0]);while(L->data[i]!=-1){++i;scanf("%d",&(L->data[i]));}L->length = i;}/********* the length of SqList****************/int ListLength(SqList *L){return L->length;}/************ GetElem L->data[i]************/int GetElem(SqList *L, int i){if(i<1 || i>L->length){ printf("Getelem Position Error");return;}return L->data[i-1];}/************ Insert Operation *********/void ListInsert(SqList *L,int i, int x){SqList *q, *p;if(i<1 || i>L->length){printf("the insert position error");return ;}q = &(L->data[i-1]); /*q为插入位置*/for(p=&(L->data[L->length-1]); p>=q; --p)*(p+1) = *p;L->data[i-1] = x;++L->length;}/********* LA and LB Merged LC ***************/ void MergeList(SqList *LA,SqList *LB,SqList *LC) {int La_len,Lb_len,ai,bj;int i,j;int k;i=j=1;InitList(LC);La_len = ListLength(LA);Lb_len = ListLength(LB);LC->length = La_len+Lb_len;/*for(k=0;k<LC->length;k++)LC->data[k] = 0; */k=0;while((i<=La_len)&&(j<=Lb_len)){ai= GetElem(LA, i);bj= GetElem(LB, j);if(ai<bj){++k;ListInsert(LC,k,ai);++i;}elseif(ai==bj){++k;ListInsert(LC,k,ai);++k;ListInsert(LC,k,bj);++i;++j;}else{++k;ListInsert(LC,k,bj);++j;}}while(i<=La_len){/*Append the residual node into LA */ai= GetElem(LA, i);++i;++k;ListInsert(LC,k,ai);}while(j<=Lb_len){/*Append the residual node into LA */bj= GetElem(LB, j);++j;++k;ListInsert(LC,k,bj);}LC->length = La_len+Lb_len;}/**************** Output the SqList**************/ void Display_SqList(SqList *L){int i,n;n=ListLength(L);printf("the length is %d ",n);for(i=0;i<n;i++)printf("%d ", L->data[i]);}/****************Main()**************************/ main(){SqList *LA , *LB, *LC;Create_SqList(LA);Create_SqList(LB);MergeList(LA,LB,LC);Display_SqList(LC);getch();}5．/**** 用带头结点的循环单链表解决约瑟夫问题***********/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/****************单链表的初始化*************************/Initlist(LinkList *L){ /*动态申请存储空间*/L = (LinkList *)malloc(sizeof(struct Lnode));/*建立头结点*/L->next = L;}/*************建立一个带头结点的循环单链表，数据值为1,2,3,...n,在表尾插入***************/Create_L(LinkList *L,int n){LinkList *p; int i;Initlist(L); /*单链表初始化p=L;for(i = n;i>0;--i){q = (LinkList*)malloc(sizeof(struct Lnode));q->data = i; /*输入元素值p->next =qq->next = L;/*插入到表尾}} /* Create_L *//*******************单链表值的输出****************/void display(LinkList *L) /*字母链表的输出*/{LinkList *p;p=L->next;while (p->next!=L){printf("%d ",p->data);p=p->next;}}/*************主程序**********************/ main(){LinkList *L;int n;L = (LinkList*)malloc(sizeof(struct Lnode));/*L->data = 0;*/L->next =L;printf("input the length of L ,n\n");scanf("%d",&n);printf("\n");Create_L(L,n);display(L);getch();}6．/******** 无头结点的循环单链表的建立**************/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/*************Create ***************/Link_Creat(LinkList *L,int n){LinkList *q,*p;int i;printf("input the data\n");scanf("%d",&L->data);p=L;for(i=2; i<=n;i++){q=(LinkList *)malloc(sizeof(struct Lnode));scanf("%d",&q->data);p->next=q;q->next=NULL;p=q;}p->next = L;/*尾结点指向第一个结点*/}/**************OutPut*********************/Link_Display(LinkList *L){LinkList *p;p=L;printf("%d ",p->data);p=p->next;while(p->next !=L){printf("%d ",p->data);p=p->next;}}/***************Main()**************************/ main(){LinkList *L;int n;L=(LinkList *)malloc(sizeof(struct Lnode));L->data=0;L->next=NULL;printf("Please input the length of LinkList, n\n");scanf("%d",&n);Link_Creat(L,n);Link_Display(L);getch();}。
数据结构-线性表输入,输出,插入,删除,查找
创建一个线性表实现输入，输出，插入，删除，定位。
（注意：不论在调用哪个函数前，都要先使L.elem=a，就是使指针elem回到数组a的首地址。
）#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量#define LISTINCREMENT 10 //线性表存储空间的分配增量#define OK 1#define ERROR 0#define OVERFLOW -2typedef int ElemType; //接下来ElemType代表的就是inttypedef int Status; //Status也代表intint i,*p,*q; //p，q都是指针类型ElemType e;typedef struct{ElemType *elem; //定义成指针类型//存储空间基址int length; //当前长度int listsize; //当前分配的存储容量(以sizeof(ElemType)为单位) }SqList;//***********************构建空的线性表*************************// Status InitList_Sq(SqList &L) //构建一个空的线性表L{L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L.elem) exit(OVERFLOW); //存储分配失败L.length=0; //空表长度为0L.listsize=LIST_INIT_SIZE; //初始存储容量return OK;}//**************************线性表输入函数*********************//void input(SqList &L) //输入函数{scanf("%d",L.elem); //要先输入一个，不然一开始就是0，无法进行循环while(*L.elem) // 加*是因为elem是指针，加之后才代表值{L.elem++; //输入后指针后移L.length++; //表长加1scanf("%d",L.elem); //循环中也要再输入}}//**************************线性表打印函数********************//void print(SqList &L) //输出函数{int n;for(n=0;n<L.length;n++){printf("%d\t",*L.elem);L.elem++; //输出后指针后移}}//***********线性表插入函数（在第i个位置插入一个数据e）*************// Status ListInsert_Sq(SqList &L,int i,ElemType e)//插入函数{//在顺序线性表L中第i个位置之前插入新的元素e//i的合法值为1<=i<=ListLength.Sq(L)+1Status *newbase;指针类型。
线性表的存储结构定义及基本操作
一、实验目的：. 掌握线性表的逻辑特征. 掌握线性表顺序存储结构的特点，熟练掌握顺序表的基本运算. 熟练掌握线性表的链式存储结构定义及基本操作. 理解循环链表和双链表的特点和基本运算. 加深对顺序存储数据结构的理解和链式存储数据结构的理解，逐步培养解决实际问题的编程能力二、实验内容：（一）基本实验内容（顺序表）：建立顺序表，完成顺序表的基本操作：初始化、插入、删除、逆转、输出、销毁, 置空表、求表长、查找元素、判线性表是否为空；1．问题描述：利用顺序表,设计一组输入数据（假定为一组整数），能够对顺序表进行如下操作：. 创建一个新的顺序表，实现动态空间分配的初始化；. 根据顺序表结点的位置插入一个新结点(位置插入)，也可以根据给定的值进行插入(值插入)，形成有序顺序表；. 根据顺序表结点的位置删除一个结点(位置删除)，也可以根据给定的值删除对应的第一个结点，或者删除指定值的所有结点(值删除)；. 利用最少的空间实现顺序表元素的逆转；. 实现顺序表的各个元素的输出；. 彻底销毁顺序线性表，回收所分配的空间；. 对顺序线性表的所有元素删除，置为空表；. 返回其数据元素个数；. 按序号查找，根据顺序表的特点，可以随机存取，直接可以定位于第i 个结点，查找该元素的值，对查找结果进行返回；. 按值查找，根据给定数据元素的值，只能顺序比较，查找该元素的位置，对查找结果进行返回；. 判断顺序表中是否有元素存在，对判断结果进行返回；. 编写主程序，实现对各不同的算法调用。
2．实现要求：对顺序表的各项操作一定要编写成为C（C++）语言函数，组合成模块化的形式，每个算法的实现要从时间复杂度和空间复杂度上进行评价；. “初始化算法”的操作结果：构造一个空的顺序线性表。
对顺序表的空间进行动态管理，实现动态分配、回收和增加存储空间；. “位置插入算法”的初始条件：顺序线性表L 已存在，给定的元素位置为i，且1≤i≤ListLength(L)+1 ；操作结果：在L 中第i 个位置之前插入新的数据元素e，L 的长度加1；. “位置删除算法”的初始条件：顺序线性表L 已存在，1≤i≤ListLength(L) ；操作结果：删除L 的第i 个数据元素，并用e 返回其值，L 的长度减1 ；. “逆转算法”的初始条件：顺序线性表L 已存在；操作结果：依次对L 的每个数据元素进行交换，为了使用最少的额外空间，对顺序表的元素进行交换；. “输出算法”的初始条件：顺序线性表L 已存在；操作结果：依次对L 的每个数据元素进行输出；. “销毁算法”初始条件：顺序线性表L 已存在；操作结果：销毁顺序线性表L；. “置空表算法”初始条件：顺序线性表L 已存在；操作结果：将L 重置为空表；. “求表长算法”初始条件：顺序线性表L 已存在；操作结果：返回L 中数据元素个数；. “按序号查找算法”初始条件：顺序线性表L 已存在，元素位置为i，且1≤i≤ListLength(L)操作结果：返回L 中第i 个数据元素的值. “按值查找算法”初始条件：顺序线性表L 已存在，元素值为e；操作结果：返回L 中数据元素值为e 的元素位置；. “判表空算法”初始条件：顺序线性表L 已存在；操作结果：若L 为空表，则返回TRUE，否则返回FALSE；分析: 修改输入数据，预期输出并验证输出的结果，加深对有关算法的理解。
线性表的插入和删除(数据结构)
电子信息工程学系实验报告——适用于计算机课程课程名称：Array实验项目名称：线性表的插入和删除实验时间： 2012、3、班级：计应102 姓名：学号：实验目的:熟悉掌握线性表的基本操作在顺序存储结构和链式存储结构上的实现，并熟悉其各自的优缺点及适用性。
实验环境:C—Free5.0实验内容及过程:题目1：编写程序实现下列的要求：(1) 设数据元素为整数，实现这样的线性表的顺序存储表示。
(2) 键盘输入10个数据元素，利用顺序表的基本操作，建立该表。
(3) 利用顺序表的基本操作，找出表中的最大的和最小的数据元素（用于比较的数据元素为整数）。
(4) * 若数据元素为学生成绩（含姓名、成绩等字段），重新编程，实现上面的要求。
要求尽可能少地修改前面的程序来得到新程序。
（这里用于比较的字段为分数）题目2：编写程序实现下列的要求：(1) 设学生成绩表中的数据元素为学生成绩（含姓名、成绩字段），实现这样的线性表的链式存储表示。
(2) 键盘输入若干个数据元素（用特殊数据来标记输入数据的结束），利用链表的基本操作（前插或后插算法），建立学生成绩单链表。
(3) 键盘输入关键字值x，打印出表中所有关键字值<=x的结点数据。
（用于比较的关键字字段为分数）。
(4) 输入关键字值x，删除表中所有关键字值<=x的结点。
（用于比较的关键字字段为分数）。
实验结果及分析：题目一：（4）：题目二：实验心得：通过这次的实验，对线性表和单链表的创建和修改有了初步的认识，和同学的讨论互相弥补了不足，相信在未来的学习中会有更大的收获。
附录：题目一代码：#include "stdio.h"#include "conio.h"typedef int datatype;struct seqlist{int maxnum;int n;datatype *element;};typedef struct seqlist *Pseqlist;Pseqlist creatnulllist_seq(int m) /* 建立空的顺序表*/{Pseqlist p=(Pseqlist)malloc(sizeof(struct seqlist));if(p!=NULL){p->element=(datatype *)malloc(sizeof(datatype)*m);if(p->element!=NULL){p->maxnum=m;p->n=0;}else free(p);}printf("out of space");return NULL;}Pseqlist init_seq(Pseqlist p,int n) /* 初始化空的顺序表，即填充数据，顺序表的实际元素个数n 由参数提供*/{int i;printf("input the element of seqlist:");for(i=0;i<n;i++)scanf("%d",&p->element[i]);p->n=n;return(p);}int insertpost_seq(Pseqlist p,int i,datatype x) /* 在i之后插入一个元素x */{int j;if(p->n>=p->maxnum){printf("overflow");return(0);}if(i<0 || i>p->n ){printf("not exist");return(0);}for(j=p->n-1; j>=i+1; j--)p->element[j+1]=p->element[j];p->element[i+1]=x;p->n++;return(1);}void print(Pseqlist p) /* 打印顺序表中的元素*/{int i;for(i=0;i<p->n;i++)int FinMax(Pseqlist p){int max=p->element[0];int i;for(i=1;i<p->n;++i){if(max<p->element[i])max=p->element[i];}return max;}int FinMin(Pseqlist p){int min=p->element[0];int i;for(i=1;i<p->n;++i){if(min>p->element[i])min=p->element[i];}return min;}main(){Pseqlist p;int m,n,i,x,k;printf("input the size of seqlist m:"); /* 输入顺序表的最大空间m，建立空的顺序表*/ scanf("%d",&m);p=creatnulllist_seq(m);printf("input the real number of seqlist n(n<m):"); /* 输入顺序表的实际长度n，初始化顺序表*/ scanf("%d",&n);p=init_seq(p,n);/* 输出插入之前顺序表的元素*/ print(p);printf("\n");printf("input i,x:");scanf("%d%d",&i,&x); /* k的值用来表示是否插入成功*/k=insertpost_seq(p,i,x);if(k==1) print(p); /* 如果插入成功，输出插入之后顺序表的元素*/ printf("\nmax:%d,min:%d\n",FinMax(p),FinMin(p));}题目一的（4）的代码：#include "stdio.h"#include "conio.h"//typedef int datatype;typedef struct student{int score;char name[30];}datatype;struct seqlist{int maxnum;int n;datatype *element;};typedef struct seqlist *Pseqlist;Pseqlist creatnulllist_seq(int m) /* 建立空的顺序表*/{Pseqlist p=(Pseqlist)malloc(sizeof(struct seqlist));if(p!=NULL){p->element=(datatype *)malloc(sizeof(datatype)*m);if(p->element!=NULL){p->maxnum=m;p->n=0;return(p);}else free(p);}printf("out of space");return NULL;}Pseqlist init_seq(Pseqlist p,int n) /* 初始化空的顺序表，即填充数据，顺序表的实际元素个数n 由参数提供*/{int i;printf("输入10个分数:输入10个名字：");for(i=0;i<n;i++)scanf("%d%s",&p->element[i].score,p->element[i].name);return(p);}int insertpost_seq(Pseqlist p,int i,datatype x) /* 在i之后插入一个元素x */ {int j;if(p->n>=p->maxnum){printf("overflow");return(0);}if(i<0 || i>p->n ){printf("not exist");return(0);}i-=2;for(j=p->n-1; j>=i+1; j--)p->element[j+1]=p->element[j];p->element[i+1]=x;p->n++;return(1);}int FinMax(Pseqlist p){int max=p->element[0].score;int i;for(i=1;i<p->n;++i){if(max<p->element[i].score)max=p->element[i].score;}return max;}int FinMin(Pseqlist p){int min=p->element[0].score;int i;for(i=1;i<p->n;++i){if(min>p->element[i].score)min=p->element[i].score;}return min;void print(Pseqlist p) /* 打印顺序表中的元素*/{int i;for(i=0;i<p->n;i++)printf("姓名：%s 分数：%d",p->element[i].name,p->element[i].score);}main(){Pseqlist p;int m,n,i,x,k;datatype aa;printf("input the size of seqlist m:"); /* 输入顺序表的最大空间m，建立空的顺序表*/scanf("%d",&m);p=creatnulllist_seq(m);printf("input the real number of seqlist n(n<m):"); /* 输入顺序表的实际长度n，初始化顺序表*/ scanf("%d",&n);p=init_seq(p,n);/* 输出插入之前顺序表的元素*/ print(p);printf("\n");printf("input i,x.score,:");scanf("%d%d%s",&i,&aa.score,); /* k的值用来表示是否插入成功*/ k=insertpost_seq(p,i,aa);if(k==1) print(p);/* 如果插入成功，输出插入之后顺序表的元素*/printf("\n%d %d",FinMax(p),FinMin(p));printf("分别是最大的和最小的数据");getch();}题目二代码：/* 线性表的单链表表示：类型和界面函数定义*/#include <stdio.h>/* 定义链接表元素类型。
实验报告1
实验一创建链表和链表操作一、实验目的掌握线性表的基本操作：插入、删除、查找、以及线性表合并等操作在顺序存储结构和链式存储结构上的实现。
二、实验内容：1. 创建单链表2．在链表上进行插入、删除操作；3．设计一个程序，用两个单链表分别表示两个集合，并求出这两个集合的并集。
四、测试数据：∙（3，9，5，6，11，8）；在5之前插入4，7，并删除11∙求集合{1，12，8，6，4，9}和{2，5，12，7，4}的并集五、概要设计：本操作应完成如下功能：（1）创建链表说明：分配一定的空间，根据给定的链表长度输入值，创建链表。
（2）合并链表说明：将两个链表合并为一个链表只需修改链表头、尾指针即可实现。
（3）在链表中插入值说明：将给定的值插入到指定位置上，只需修改插入位置的前后结点的指针即可。
（4）在链表中删除值说明：将指定位置的值删除，只需修改删除位置的前后结点的指针即可。
六、详细设计：源代码：#include<stdio.h>#include<conio.h>#include<stdlib.h>#include<iostream.h>#define OK 1#define ERROR 0#define OVERFLOW 0//线性链表的存储结构，一个结点typedef struct LNode{int data; // 数据域struct LNode *next; // 指针域}LNode,*LinkList; //结点结构类型和指向结点的指针类型int TraverseList_L(LinkList L) //遍历单链表{LinkList p;p=L->next;while(p){printf("-->%d",p->data);p=p->next;}return OK;}//尾插法创建的带头结点的单链表。
void CreateList_L(LinkList &L,int &n){L=(LinkList)malloc(sizeof (LNode));//建立一个空链表L。
数据结构——链表的创建、插入、删除
／ 令 Ｓ指 向结点的存储 内容为 ｘ ／ 半 ＊ ① ｓ ＞ｅ ｔ ｐ ＞ ｅ ｔ 一ｎｘ＝一ｎｘ ： 令新创设的结点 的指针指于 Ｐ 相邻 后方 的结点 ／
② Ｐ ＞ｅ ｔｓ 一ｎｘ＝ ： ｐ之 后 ，指 于 相 邻 后 方 的结 点 ／
这样一来。便实 现了于单链表中数据的后插放置 。 ①②行顺序我们 不能去忽略， 因为常常这里就是很容产生 错误的地方 ， 以说 ， 可 这两句顺序错误 ， 插入操作便不 能实现 ， 因为 ａ ５的地址被存储在 ａ ４结点的指针域中 ， 不是 明确 的， 如 果我们选择②先运行 ，则 ａ ５的地 址将 由于 ｘ结点的地址数据 的抹去 ， 不能够指 向 ａ ５以及其最 后的结点了。因为这个原因 ， 我们不仅仅需要知道涉及结点 的指针为 明确或者 隐含 ， 并且要 谨记将隐含结点先于别的结点执行 。
一
麝 一
相关代码
：
图５
ｌ ４～ ｏ
计算机光盘软件 与应用
２ １ 第 ８期 ０ ２年
Ｃ ｍ ｕ ｅ ＤＳ ｆｗ ｒ ｎ ｐ ｌｃ ｔ ｏ ｓ ｏ ｐ ｔ ｒＣ ｏ ｔ ａ ｅａ ｄＡ ｐ ｉ ａ ｉ ｎ 工 程 技 术
① ｓ （ｔ ｕ ｔ ｄ ｏ ｅ卓 ａ ｌｃ （ｉ ｅ ｆ ｓ ｒ ｃ ＝ ｓｒ ｃ ｎ ｄ ）ｍ ｌ ｏ ｓ ｚ ｏ （ｔ ｕ ｔ
一
、
图 ３
２ 后 插 法 ．
后插法没有前插法这么复杂 ，我们想象 ，于书 ｐ指 向的结 点的最后放进新创设 的结 点 ｘ ，如图 ４ 。 相关语 句： ｓｒ ｃ ｎ ｄ ｐ 水声 明指针 Ｐ宰 ｔ ｕ ｔ Ｌ ｏ ｅ书 ：／ ／ 令术 ｐ的地址为 ａ ： ４ ｓ （ｔ ｕ ｔ Ｌ ｏ ｅ木 ｍ ｌｏ （ｉ ｅ ｆ ｓｒ ｃ ｎ ｄ ） ：木 ＝ ｓ ｒ ｃ ｎ ｄ ） ａ ｌｃ ｓ ｚ ｏ （ｔ ｕ ｔ Ｌ ｏ ｅ ） ／ 令 Ｓ指于新创设 的结点 木 ／
数据结构--实验报告 线性表的基本操作
数据结构--实验报告线性表的基本操作数据结构--实验报告线性表的基本操作一、引言本实验报告旨在通过实际操作，掌握线性表的基本操作，包括初始化、插入、删除、查找等。
线性表是最基本的数据结构之一，对于理解和应用其他数据结构具有重要的作用。
二、实验目的1·了解线性表的定义和基本特性。
2·掌握线性表的初始化操作。
3·掌握线性表的插入和删除操作。
4·掌握线性表的查找操作。
5·通过实验巩固和加深对线性表的理解。
三、线性表的基本操作1·初始化线性表线性表的初始化是将一个线性表变量设置为空表的过程。
具体步骤如下：（1）创建一个线性表的数据结构，包括表头指针和数据元素的存储空间。
（2）将表头指针指向一个空的数据元素。
2·插入元素插入元素是向线性表中指定位置插入一个元素的操作。
具体步骤如下：（1）判断线性表是否已满，如果已满则无法插入元素。
（2）判断插入位置是否合法，如果不合法则无法插入元素。
（3）将插入位置及其后面的元素都向后移动一个位置。
（4）将待插入的元素放入插入位置。
3·删除元素删除元素是从线性表中删除指定位置的元素的操作。
具体步骤如下：（1）判断线性表是否为空，如果为空则无法删除元素。
（2）判断删除位置是否合法，如果不合法则无法删除元素。
（3）将删除位置后面的元素都向前移动一个位置。
（4）删除最后一个元素。
4·查找元素查找元素是在线性表中查找指定元素值的操作。
具体步骤如下：（1）从线性表的第一个元素开始，逐个比较每个元素的值，直到找到目标元素或遍历完整个线性表。
（2）如果找到目标元素，则返回该元素的位置。
（3）如果未找到目标元素，则返回找不到的信息。
四、实验步骤1·初始化线性表（1）定义线性表的数据结构，包括表头指针和数据元素的存储空间。
（2）将表头指针指向一个空的数据元素。
2·插入元素（1）判断线性表是否已满。
数据结构实验题目
实验题目一一、单链表基本运算【问题描述】设计并实现线性表的单链表存储和运算。
【基本要求】实现单链表的插入、删除和遍历运算，每种操作用一个函数实现。
插入操作：将一个新元素插入表中指定序号的位置。
删除操作：将指定序号的元素从表中删除。
遍历操作：从表头按次序输入所有元素的值，若是空表，则输出信息“empty list!”。
【实现提示】程序运行时，首先在main函数中创建空的、带头结点的单链表。
然后多次调用实现插入操作的函数（每次都将元素在序号1位置上插入），将元素依次插入表中，最后调用实现遍历操作的函数输出所有元素。
之后再多次调用实现删除操作的函数将表还原为空表（每次都删除第1个元素，每删除一个元素后，将表中剩余元素都输出一次）。
【测试数据】输入数据：1 2 3 4 5 0（为0时结束，0不存入链表）第一次输出：5 4 3 2 1第二次输出：4 3 2 1第三次输出：3 2 1第四次输出：2 1第五次输出：1第六次输出：empty list!二、约瑟夫环问题【问题描述】编号为1,2,...,n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。
现在给定一个随机数m>0，从编号为1的人开始，按顺时针方向1开始顺序报数，报到m时停止。
报m的人出圈，同时留下他的密码作为新的m值，从他在顺时针方向上的下一个人开始，重新从1开始报数，如此下去，直至所有的人全部出列为止。
【基本要求】利用单向循环链表存储结构模拟此过程，按照出列的顺序印出各人的编号。
【测试数据】M的初始值为20；n等于7，7个人的密码依次为：3，1，7，2，4，8，4。
输出为：6，1，4，7，2，3，5【实现提示】程序运行时，首先要求用户指定初始报数上限值，然后读取各人的密码。
可设n≤30。
此题所用的循环链表中不需要“头结点”，请注意空表和非空表的界限。
【选作内容】用顺序存储结构实现该题目。
三、一元多项式相加、减运算器【问题描述】设计一个一元稀疏多项式简单计算器。
数据结构--实验报告 线性表的基本操作
数据结构--实验报告线性表的基本操作线性表的基本操作实验报告1.引言线性表是最基本的数据结构之一，它可以用来存储一系列具有相同数据类型的元素。
本实验旨在通过实践掌握线性表的基本操作，包括插入、删除、查找和修改元素等。
本文档将详细介绍实验所需的步骤和操作方法。
2.实验目的1.掌握线性表的插入和删除操作。
2.理解线性表的查找和修改元素的方法。
3.熟悉线性表的基本操作在算法中的应用。
3.实验环境本实验使用编程语言/软件名称作为开发环境，具体要求如下：________●操作系统：________操作系统名称和版本●编程语言：________编程语言名称和版本4.实验步骤4.1 初始化线性表在程序中创建一个空的线性表，用于存储元素。
实现方法：________具体的初始化方法和代码示例 4.2 插入元素在线性表中指定位置插入一个新元素。
实现方法：________具体的插入元素方法和代码示例 4.3 删除元素删除线性表中指定位置的元素。
实现方法：________具体的删除元素方法和代码示例 4.4 查找元素在线性表中查找指定元素的位置。
实现方法：________具体的查找元素方法和代码示例 4.5 修改元素修改线性表中指定位置的元素值。
实现方法：________具体的修改元素方法和代码示例5.实验结果在完成上述步骤后，我们得到了一个可以进行插入、删除、查找和修改元素的线性表。
具体操作结果如下：________●插入元素操作结果：________插入元素的具体操作结果●删除元素操作结果：________删除元素的具体操作结果●查找元素操作结果：________查找元素的具体操作结果●修改元素操作结果：________修改元素的具体操作结果6.实验总结通过本次实验，我们深入理解了线性表的基本操作，并且掌握了这些操作的实现方法。
线性表在实际应用中十分常见，熟练掌握线性表的操作对于开发高效的算法和数据结构具有重要意义。
数据结构实验,线性表的插入和删除,单链表操作,Huffman编码树
{ int i,j,k,x1,x2,m1,m2;
for(i=1;i<(2*n);i++)
{ t[i].pa=t[i].lc=t[i].rc=0;
if(i<=n)
t[i].data=w[i];
else
t[i].data=0;
}
for(i=1;i<n;i++)
{ m1=m2=MAX;
x1=x2=0;
for(j=1;j<(n+i);j++)
ListCount=0;
int nOperateState;
while(TRUE)
{
printf( "选择你要操作的方法，1为插入，2为删除，3为查询！4为退出\r\n ");
scanf("%d",&nOperateState);
switch(nOperateState)
{
case 1:
InsertInfo();
{
printf("请不要重复插入相同学号的信息\r\n");
LocalFree(Info);
return;
}
ptemp=ptemp->pNext;
}
}
if (ListHead)
{
if (ListCount==1)
{
ListTail=Info;
ListTail->pNext=NULL;
ListHead->pNext=ListTail;
temp->stu_num,temp->stu_age,temp->stu_english_grade);
数据结构线性表试验报告
线性表上机实习1、实验目的（1）熟悉将算法转换为程序代码的过程。
（2）了解顺序表的逻辑结构特性，熟练掌握顺序表存储结构的C语言描述方法。
（3）熟练掌握顺序表的基本运算：查找、插入、删除等，掌握顺序表的随机存取特性。
（4）了解线性表的链式存储结构，熟练掌握线性表的链式存储结构的C语言描述方法。
（5）熟练掌握线性链表（单链表）的基本运算：查找、插入、删除等，能在实际应用中灵活选择适当的链表结构。
2、实验要求（1）熟悉顺序表的插入、删除和查找。
（2）熟悉单链表的插入、删除和查找。
3、实验内容:①顺序表（1）抽象数据类型定义typedef struct {TypeData data[maxsize]; //容量为maxsize的静态顺手表int n; //顺序表中的实际元素个数}SeqList; //静态顺序表的定义在本次实验中，首先建立一个空的静态顺序表，然后键盘输入数据存入表中，然后进入菜单选择界面，通过不同的数字输入，实现对顺序表，删除，插入，查找，显示等操作。
（2）存储结构定义及算法思想在顺序表结构体的定义中，typedef int TypeData 为整型，存储结构如下：for(n=0;n<m;n++){cout<<"请输入线性表数据"<<endl;cin>>[n]; //顺序将数据存入顺序表} //其他存储与此类似，都是直接赋值与数组的某一位插入版块子函数：void insert(SeqList &L) //插入数据{int a,b,c,k;cout<<"请输入插入的数及其插入的位置"<<endl;cin>>a>>b;if(b<=0||b>+1)) {cout<<"不能在该位置插入"<<endl; return;} //判断插入位置是否合法k=[b-1];[b-1]=a; c=; =+1;while(c>b){[c]=[c-1];c--; //通过循环，实现插入位置后的数据挨个往后移动一位}[b]=k;}顺序表的插入与删除操作类似，在插入与删除后，都要循环调整后面数组的每一位元素，同时记录数据元素的长度的标示符也要跟着改变。
数据结构实验报告-单链表
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.测试结论：可以正确的对链表进行插入，删除，取长度，输出操作。
数据结构实验报告-线性表
1 线性表1. 实验题目与环境1.1实验题目及要求（1）顺序表的操作利用顺序存储方式实现下列功能：根据键盘输入数据建立一个线性表，并输出该线性表；对该线性表进行数据的插入、删除、查找操作，并在插入和删除数据后，再输出线性表。
（2）单链表的操作利用链式存储方式实现下列功能：根据键盘输入数据建立一个线性表，并输出该线性表；对该线性表进行数据的插入、删除、查找操作，并在插入和删除数据后，再输出线性表。
（3）线性表的应用约瑟夫环问题。
有n个人围坐一圈，现从某个人开始报数，数到M的人出列，接着从出列的下一个人开始重新报数，数到M的人又出列，如此下去，直到所有人都出列为止。
要求依次输出出列人的编码。
2.问题分析（1）顺序表的操作利用一位数组来描述顺序表，即将所有元素一词储存在数组的连续单元中，要在表头或中间插入一个新元素时，需要将其后的所有元素都向后移动一个位置来为新元素腾出空间。
同理，删除开头或中间的元素时，则将其后的所有元素向前移动一个位置以填补空位。
查找元素时，则需要利用循环语句，一一判断直到找出所要查找的元素（或元素的位置），输出相关内容即可（2）单链表的操作利用若干个结点建立一个链表，每个节点有两个域，即存放元素的数据域和存放指向下一个结点的指针域。
设定一个头指针。
在带头结点的单链表中的第i个元素之前插入一新元素，需要计数找到第i-1个结点并由一指针p指向它，再造一个由一指针s指向的结点，数据为x，并使x的指针域指向第i个结点，最后修改第i-1个结点的指针域，指向x结点。
删除第i个元素时，需要计数寻找到第i个结点，并使指针p指向其前驱结点，然后删除第i个结点并释放被删除结点的空间。
查找第i个元素，需从第一个结点开始计数找到第i个结点，然后输出该结点的数据元素。
（3）线性表的应用程序运行之后，首先要求用户指定初始报数的上限值，可以n<=30,此题中循环链表可不设头结点，而且必须注意空表和"非空表"的界限。
数据结构单链表实验报告
{
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的长度*/
数据结构学习心得（二）-----线性表
数据结构学习⼼得（⼆）-----线性表线性表是由n个数据元素（结点）a1，a2,a3……an组成的有限序列。
线性表的数据元素ai所代表的具体含义随具体应⽤的不同⽽不同，在线性表的定义中，只不过是⼀个抽象的符号。
1.线性表的结点可以是单值元素（每个元素只有⼀个数据项）例如：26个英⽂字母表（A,B,C……Z）扑克的点数（2,3,4,5……J,Q,K）2.线性表中的结点可以是记录型元素，每个元素含有多个数据项，每个项称为结点的⼀个域，每个元素有⼀个可以唯⼀标识每个结点的数据项组，称为关键字。
例⼦：某校2001级同学的基本情况{（‘201112’，‘张三’，‘男’，‘1983/2/4’）,('201113','章华寺‘，’男‘1984/2/8)……}顺序线性表：数组表⽰粗出线性表的元素，顺序表还需要长度的属性，所以⽤结构类型来定义顺序表类型。
typedef struct sqlist{ElemType Elem_array[MAX_SIZE];int length;}Sqlist;链式线性表：为了正确表⽰节点间的逻辑关系，在存储每个结点值的同时，还必须存储指⽰其直接后继结点的地址（或位置），称为指针或链链表是通过每个节点的指针域将线性表的n个节点按其逻辑次序链接在⼀起的。
每⼀个结点只包含⼀个指针域的链表，称为单链表。
为操作⽅便，总是在链表的第⼀个节点之前附设⼀个头结点（头指针）head指向第⼀个结点。
头结点的数据域可以不存储任何信息（或链表长度等信息）。
结点的描述与实现typedef struct Lnode{ElemType data;struct Lnode *next;}LNode;结点的实现：结点是通过动态分配和释放来实现的，即需要时分配，不需要时释放。
实现时分别使⽤的c语⾔标准函数为：malloc(),realloc(),sizeof(),free();p=(LNode*)malloc(sizeof(LNode));函数malloc分配了⼀个类型为LNode的节点变量的空间，并将其⾸地址放⼊指针变量p中。
数据结构 实验二：单链表的基本操作
数据结构实验二：单链表的基本操作数据结构实验二：单链表的基本操作实验二：单链表的基本操作一、【实验目的】1、理解和掌握单链表的类型定义方法和结点生成方法。
2、掌握建立单链表和显示单链表元素的算法。
3、掌握单链表的查找、插入和删除算法二、【实验内容】1、建立一个整形数的单链表，手动输入10个数，并从屏幕显示单链表元素列表。
2、从键盘输入一个数，查找在以上创建的单链表中是否存在该数;如果存在，显示它的位置;如果不存在，给出相应提示。
3、删除上述单链表中指定位置的元素。
以下就是程序部分代码，恳请调试并补足并使之恰当运转：１．linlist.htypedefstructnode{datatypedata;structnode*next;}slnode;voidlistinitiate(slnode**head)/*初始化*/{/*如果有内存空间，申请头结点空间并使头指针head指向头结点*/if((*head=(slnode*)malloc(sizeof(slnode)))==null)exit(1);(*head)->next=null;/*置链尾标记null*/}intlistlength(slnode*head){slnode*p=head;/*p指向首元结点*/intsize=0;/*size初始为0*/while(p->next!=null)/*循环计数*/{p=p->next;size++;}returnsize;}intlistinsert(slnode*head,inti,datatypex)/*在带头结点的单链表head的数据元素ai（0≤i≤size）结点前*//*填入一个存放数据元素x的结点*/{slnode*p,*q;intj;p=head;/*p指向首元结点*/j=-1;/*j起始为-1*/while(p->next!=null&&j<i-1)/*最终让指针p指向数据元素ai-1结点*/{p=p->next;j++;}if(j!=i-1){printf(\填入边线参数弄错！\return0;}/*生成新结点由指针q指示*/if((q=(slnode*)malloc(sizeof(slnode)))==null)exit(1);q->data=x;q->next=p->next;/*给指针q->next赋值*/p->next=q;/*给指针p->next重新赋值*/return1;}intlistdelete(slnode*head,inti,datatype*x)/*删除带头结点的单链表head的数据元素ai（0≤i≤size-1）结点*//*删除结点的数据元素域值由x带回。
数据结构单链表实验报告
数据结构单链表实验报告一、实验目的本次实验旨在深入理解和掌握数据结构中单链表的基本概念、操作原理及实现方法。
通过实际编程实现单链表的创建、插入、删除、查找等基本操作，提高对数据结构的理解和编程能力。
二、实验环境本次实验使用的编程环境为具体编程语言，编译工具为具体编译工具名称。
三、实验原理1、单链表的定义单链表是一种线性表的数据结构，它由一系列节点组成，每个节点包含数据域和指针域。
数据域用于存储节点的数据，指针域用于指向下一个节点的地址。
通过这种方式，将各个节点连接起来，形成一个链表。
2、单链表的基本操作创建单链表：从无到有构建一个单链表，可以通过逐个插入节点来实现。
插入节点：可以在链表的头部、尾部或指定位置插入新的节点。
删除节点：根据给定的条件或位置删除链表中的节点。
查找节点：在链表中查找满足特定条件的节点。
四、实验内容1、单链表节点的定义｀｀｀具体编程语言typedef struct Node ｛int data;struct Node next;｝ Node;｀｀｀2、创建单链表｀｀｀具体编程语言Node createList(）｛Node head ＝ NULL;Node newNode;int data;printf(＂请输入节点数据（输入－1 结束）：＂）；scanf(＂％d"，＆data)；while （data!＝－1) ｛newNode ＝（Node ）malloc(sizeof(Node)）；newNode>data ＝ data;newNode>next ＝ NULL;if （head ＝＝ NULL) ｛head ＝ newNode;｝ else ｛Node temp ＝ head;while （temp>next!＝ NULL) ｛temp ＝ temp>next;｝temp>next ＝ newNode;｝printf(＂请输入节点数据（输入－1 结束）：＂）；scanf(＂％d"，＆data)；｝return head;｝｀｀｀3、插入节点在头部插入｀｀｀具体编程语言Node insertAtHead(Node head, int data) ｛Node newNode ＝（Node ）malloc(sizeof(Node)）；newNode>data ＝ data;newNode>next ＝ head;head ＝ newNode;return head;｝｀｀｀在尾部插入｀｀｀具体编程语言void insertAtTail(Node head, int data) ｛Node newNode ＝（Node ）malloc(sizeof(Node)）；newNode>data ＝ data;newNode>next ＝ NULL;Node temp ＝ head;while （temp>next!＝ NULL) ｛temp ＝ temp>next;｝temp>next ＝ newNode;｝｀｀｀在指定位置插入｀｀｀具体编程语言void insertAtPosition(Node head, int position, int data) ｛Node newNode ＝（Node ）malloc(sizeof(Node)）；newNode>data ＝ data;if （position ＝＝ 1) ｛newNode>next ＝ head;head ＝ newNode;return;｝Node temp ＝ head;int count ＝ 1;while （temp!＝ NULL ＆＆ count ＜ position 1) ｛temp ＝ temp>next;count+＋；｝if （temp ＝＝ NULL) ｛printf(＂位置无效\n"）；return;｝newNode>next ＝ temp>next;temp>next ＝ newNode;｝｀｀｀4、删除节点删除头部节点｀｀｀具体编程语言Node deleteAtHead(Node head) ｛if （head ＝＝ NULL) ｛printf(＂链表为空，无法删除\n"）；return NULL;｝Node temp ＝ head;head ＝ head>next;free(temp)；return head;｝｀｀｀删除尾部节点｀｀｀具体编程语言void deleteAtTail(Node head) ｛if （head ＝＝ NULL) ｛printf(＂链表为空，无法删除\n"）；return;｝Node prev ＝ NULL;Node temp ＝ head;while （temp>next!＝ NULL) ｛prev ＝ temp;temp ＝ temp>next;｝if （prev ＝＝ NULL) ｛head ＝ NULL;｝ else ｛prev>next ＝ NULL;｝free(temp)；｝｀｀｀删除指定节点｀｀｀具体编程语言void deleteNode(Node head, int data) ｛Node prev ＝ NULL;Node temp ＝ head;while （temp!＝ NULL ＆＆ temp>data!＝ data) ｛prev ＝ temp;temp ＝ temp>next;｝if （temp ＝＝ NULL) ｛printf(＂未找到要删除的数据\n"）；return;｝if （prev ＝＝ NULL) ｛head ＝ temp>next;｝ else ｛prev>next ＝ temp>next;｝free(temp)；｝｀｀｀5、查找节点｀｀｀具体编程语言Node search(Node head, int data) ｛Node temp ＝ head;while （temp!＝ NULL) ｛if （temp>data ＝＝ data) ｛return temp;｝temp ＝ temp>next;｝return NULL;｝｀｀｀6、打印单链表｀｀｀具体编程语言void printList(Node head) ｛Node temp ＝ head;while （temp!＝ NULL) ｛printf(＂％d ＂， temp>data)；temp ＝ temp>next;｝printf(＂＼n"）；｝｀｀｀五、实验结果1、成功创建了不同数据的单链表，并能够正确打印出链表中的数据。
【数据结构】线性表的基本操作
【数据结构】线性表的基本操作【数据结构】线性表的基本操作【一、概述】线性表是一种常见的数据结构，它是由一组具有相同特性的数据元素组成的有序序列。
线性表的基本操作包括插入、删除、查找和修改等操作，本文将对这些操作进行详细介绍。
【二、插入操作】插入操作是向线性表中某个位置插入一个新元素的操作。
插入操作包括头部插入、尾部插入和中间插入三种情况。
首先需要确定插入的位置，然后将插入位置后的元素依次向后移动一位，最后在插入位置处放入新元素。
1.头部插入：将新元素插入线性表的头部位置。
2.尾部插入：将新元素插入线性表的尾部位置。
3.中间插入：将新元素插入线性表的任意中间位置。
【三、删除操作】删除操作是从线性表中删除某个元素的操作。
删除操作包括删除头部元素、删除尾部元素和删除中间元素三种情况。
首先需要确定删除的位置，然后将删除位置后的元素依次向前移动一位，最后删除最后一个元素位置上的元素。
1.删除头部元素：删除线性表的头部元素。
2.删除尾部元素：删除线性表的尾部元素。
3.删除中间元素：删除线性表的任意中间位置的元素。
【四、查找操作】查找操作是在线性表中搜索某个元素的操作。
查找操作包括按值查找和按位置查找两种情况。
1.按值查找：根据给定的元素值，在线性表中搜索并返回该元素的位置。
2.按位置查找：根据给定的位置，返回该位置上的元素值。
【五、修改操作】修改操作是修改线性表中某个元素的值的操作。
需要先找到要修改的元素位置，然后将其值修改为新的值。
【附件】本文档涉及附件略。
【法律名词及注释】本文档所涉及的法律名词及注释略。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验报告课程名称数据结构姓名学号专业班级指导教师目录第二章线性表的查找、插入、删除 (1)1.1顺序表的查找 (1)1.2顺序表的插入 (2)1.3顺序表的删除 (4)单链表的建立、插入、删除 (6)2.1 单链表的建立（尾插法） (6)2.2 单链表的插入 (8)2.3 单链表的删除 (10)第三章栈 (14)3.1链栈 (14)3.2 顺序栈 (16)3.3队列 (18)3.4杨辉三角 (20)第四章串 (23)4.1字符串的建立 (23)4.2顺序串的插入 (25)1.线性表的查找、插入、删除1.1顺序表的查找程序：#include <stdio.h>#include<stdlib.h>#include<malloc.h>#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define ElemType int#define MAXSIZE 100 /*此处的宏定义常量表示线性表可能达到的最大长度*/typedef struct{ElemType elem[MAXSIZE]; /*线性表占用的数组空间*/int last; /*记录线性表中最后一个元素在数组elem[]中的位置（下标值），空表为-1*/}Seqlist;int Locate(Seqlist L,ElemType e)/*在顺序表L中查找与e相等的元素，若L。
elem[i]=e,则找到该元素，并返回i+1，若找不到，则返回-1*/{ int i=0; /*i为扫描计数器，初值为0，即从第一个元素开始比较*/while ((i<=st)&&(L.elem[i]!=e))/*顺序扫描表，直到找到值为e的元素，或扫描到表尾仍没找到*/i++;if(i<=st)return (i+1); /*若找到值为e的元素，则返回其序号*/elsereturn(-1); /*若没找到，则返回空序号*/}void main(){Seqlist l;int p,q,r;int i;printf("请输入线性标的长度:");scanf("%d",&r);st=r-1;printf("请输入线性表的各元素值：\n");for (i=0;i<=st;i++){scanf("%d",&l.elem[i]);}printf("请输入要查找的元素值:\n");scanf("%d",&q);p=Locate(l,q);if(p==-1)printf("在此线性表中没有该元素!\n");elseprintf("该素在线性表中的位置为:%d\n",p);}执行结果：错误分析：在编写过程中，在编写主函数的时候有落下未编写的，导致运行过程中不识别。
1.2顺序表的插入程序：#include <stdio.h>#include <stdlib.h>//#include <malloc.h>#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define ElemType int#define MAXSIZE 100typedef struct{ElemType elem[MAXSIZE];int last;}SeqList;//#include "common.h"//#include "seqlist.h"int InsList(SeqList *L,int i,ElemType e) {int k;if((i<1) || (i>L->last+2)){printf("插入位置i值不合法");return(ERROR);}if(L->last>= MAXSIZE-1){printf("表已满无法插入");return(ERROR);}for(k=L->last;k>=i-1;k--)L->elem[k+1]=L->elem[k];L->elem[i-1]=e;L->last++;return(OK);}void main(){SeqList *l;int p,q,r;int i;l=(SeqList*)malloc(sizeof(SeqList));printf("请输入线性表的长度:");scanf("%d",&r);l->last = r-1;printf("请输入线性表的各元素值:\n");for(i=0; i<=l->last; i++){scanf("%d",&l->elem[i]);}printf("请输入要插入的位置:\n");scanf("%d",&p);printf("请输入要插入的元素值:\n");scanf("%d",&q);InsList(l,p,q);for(i=0; i<=l->last; i++){printf("%d ",l->elem[i]);}}执行结果：1.3顺序表的删除程序：#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define ElemType int#define MAXSIZE 100typedef struct{ElemType elem[MAXSIZE];int last;}SeqList;int DelList(SeqList *L,int i,ElemType *e) {int k;if((i<1)||(i>L->last+1)){printf("删除位置不合法!");return(ERROR);}*e = L->elem[i-1];for(k=i; i<=L->last; k++)L->elem[k-1] = L->elem[k];L->last--;return(OK);}void main(){SeqList *l;int p,r;int *q;int i;l = (SeqList*)malloc(sizeof(SeqList));q = (int*)malloc(sizeof(int));printf("请输入线性表的长度:");scanf("%d",&r);l->last = r-1;printf("请输入线性表的各元素值:\n");for(i=0; i<=l->last; i++){scanf("%d",&l->elem[i]);}printf("请输入要删除的元素位置:\n");scanf("%d",&p);DelList(l,p,q);printf("删除的元素值为:%d\n",*q);}执行结果：2.单链表的建立、插入、删除2.1 单链表的建立（尾插法）程序：#include<stdio.h>#include<stdlib.h>#define ERROR 0#define TRUE 1#define FALSE 0typedef char ElemType;typedef struct Node /*结点类型定义*/{ElemType data;struct Node * next;}Node, *LinkList; /* LinkList为结构指针类型*/void init_linklist(LinkList *l)/*对单链表进行初始化*/{*l=(LinkList)malloc(sizeof(Node));(*l)->next=NULL;}void CreateFromTail(LinkList L){Node *r, *s;char c;int flag =1; /*设置一个标志，初值为，当输入"$"时，flag为，建表结束*/r=L; /*r指针动态指向链表的当前表尾，以便于做尾插入，其初值指向头结点*/while(flag) /*循环输入表中元素值，将建立新结点s插入表尾*/{c=getchar();if(c!='a'){s=(Node*)malloc(sizeof(Node));s->data=c;r->next=s;r=s;}else{flag=0;r->next=NULL; /*将最后一个结点的next链域置为空，表示链表的结束*/}}}int main(){LinkList l;Node *p;init_linklist(&l);printf("用尾插法建立单链表,请输入链表数据,以a结束!\n");CreateFromTail(l);p = l->next;while(p!=NULL){printf("%c\n",p->data);p=p->next;}return 0;}执行结果：错误分析：在代码的时候忘记分号，导致运行错误；截图如下:2.2 单链表的插入程序：#include "common.h"#include "linklist.h"int InsList(LinkList L,int i,ElemType e)/*在带头结点的单链表L中第i个位置插入值为e的新结点s*/{Node *pre,*s;int k;pre=L;k=0; /*从"头"开始，查找第i-1个结点*/while(pre!=NULL&&k<i-1) /*表未查完且未查到第i-1个时重复，找到pre 指向第i-1个*/{pre=pre->next;k=k+1;} /*查找第i-1结点*/if(!pre) /*如当前位置pre为空表已找完还未数到第i个，说明插入位置不合理*/{printf("插入位置不合理!");return ERROR;}s=(Node*)malloc(sizeof(Node)); /*申请一个新的结点S */s->data=e; /*值e置入s的数据域*/s->next=pre->next; /*修改指针，完成插入操作*/pre->next=s;return OK;}void main(){LinkList l;Node *p;int flag=0;int i;char c;init_linklist(&l);printf("请输入链表数据,以$结束!\n");CreateFromTail(l);p = l->next;while(p!=NULL){printf("%c\n",p->data);p=p->next;}printf("请输入插入的位置和元素:\n");scanf("%d,%c",&i,&c);printf("%c\n",c);flag=InsList(l, i, c);if(flag)printf("插入操作成功!\n");elseprintf("插入操作失败!\n");p = l->next;while(p!=NULL){printf("%c\n",p->data);p=p->next;}}执行结果：2.3 单链表的删除程序：#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0typedef char ElemType;typedef struct Node /*结点类型定义*/{ElemType data;struct Node * next;}Node, *LinkList; /* LinkList为结构指针类型*/void init_linklist(LinkList *l)/*对单链表进行初始化*/ {*l=(LinkList)malloc(sizeof(Node));(*l)->next=NULL;}void CreateFromTail(LinkList L){Node *r, *s;char c;int flag =1; /*设置一个标志，初值为1，当输入"$"时，flag为0，建表结束*/r=L; /*r指针动态指向链表的当前表尾，以便于做尾插入，其初值指向头结点*/while(flag) /*循环输入表中元素值，将建立新结点s插入表尾*/{c=getchar();if(c!='$'){s=(Node*)malloc(sizeof(Node ));s->data=c;r->next=s;r=s;}else{flag=0;r->next=NULL; /*将最后一个结点的next链域置为空，表示链表的结束*/}}}int DelList(LinkList L,int i,ElemType *e)/*在带头结点的单链表L中删除第i个元素，并将删除的元素保存到变量*e中*/{Node *pre,*r;int k;pre=L;k=0;while(pre->next!=NULL && k<i-1) /*寻找被删除结点i的前驱结点i-1使p 指向它*/{pre=pre->next;k=k+1;} /*查找第i-1个结点*/if(!(pre->next)) /* 即while循环是因为p->next=NULL或i<1而跳出的,而是因为没有找到合法的前驱位置，说明删除位置i不合法。