单链表以及单链表的建立、清空、插入、删除、查找、修改等运算

#include

#include

#include

struct lian_node{ /*单个链表节点的结构体*/

int n;

int num;

struct lian_node*link;

};

struct lian_node*Create_Lian_Doc(); /*通过输入建立一个只有6个结点的单链表，并输出该链表*/

void SearchDoc_n(struct lian_node*link,int n); /*输入序号n，查找序号为n的结点，并输出*/

void SearchDoc_num(struct lian_node*link,int num); /*输入值x，查找值为x的结点，并输出*/

void InsertDoc(struct lian_node*llist,struct lian_node*p,int n); /*插入结点: 输入序号n 和值x。在序号为n的结点后插入x，并输出该链表*/

void DeleteDoc(struct lian_node*llist,int n); /*删除结点: 输入序号n，删除序号为n的结点，并输出该链表*/

void Print_Lian_Doc(struct lian_node*llist); /*遍历链表*/

int main(void)

{

struct lian_node*llist,*p;

int n,num,choice;

int size=sizeof(struct lian_node);

llist=Create_Lian_Doc();

do{

printf(" \n链表操作\n");

printf(" 1 ：查找\n");

printf(" 2 ：删除\n");

printf(" 3 ：插入\n");

printf(" 0 : 退出\n");

printf("请选择功能：");

scanf("%d",&choice);

switch(choice){

case 0:

break;

case 1:

/*查找值*/

printf("输入值：");

scanf("%d",&num);

SearchDoc_num(llist,num);

break;

case 3: /*插入结点*/

printf("插入结点位置:");

scanf("%d",&n);

printf("插入结点数值:");

scanf("%d",&num);

p=(struct lian_node *)malloc(size); /*size=sizeof(struct lian_node);*/ p->n=n+1;

p->num=num;

p->link=NULL;

InsertDoc(llist,p,n);

break;

case 2:/*删除结点*/

printf("\n删除结点: ");

scanf("%d",&n);

DeleteDoc(llist,n);

break;

}

}while (choice!=0);

return 0;

}

/*新建链表*/

struct lian_node*Create_Lian_Doc()

{

int i,num,n;

int size=sizeof(struct lian_node);

struct lian_node *llist,*tail,*p;

llist=tail=NULL;

printf("请输入链表长度n=");

scanf("%d",&n);

printf("请输入链表的各个值:");

for(i=1;i<=n;i++){

p=(struct lian_node *)malloc(size); /*size=sizeof(struct lian_node);*/ scanf("%d",&num);

p->n=i;

p->num=num;

p->link=NULL;

if(llist==NULL)

llist=p;

else

tail->link=p;

tail=p;

}

return llist;

}

/*查找值*/

void SearchDoc_num(struct lian_node*llist,int num)

{

struct lian_node *ptr;

if(llist==NULL){

printf("\n无结果！\n");

return;

}

for(ptr=llist;ptr;ptr=ptr->link){

if(ptr->num==num){

printf("输出序号为: %d\n\n",ptr->n);

break;

}

}

if(ptr==NULL)

printf("\n无结果！\n");

}

/*插入操作*/

void InsertDoc(struct lian_node*llist,struct lian_node*p,int n) {

int i=1;

struct lian_node *ptr,*ptr1,*ptr2;

ptr1=llist;

ptr2=llist->link;

while(ptr1->n!=n && ptr2!=NULL){

ptr1=ptr2;

ptr2=ptr2->link;

}

if(ptr1->n==n){

p->link=ptr2;

ptr1->link=p;

}

else

printf("\n无结果！\n");

for(ptr=llist;ptr;ptr=ptr->link){

ptr->n=i;

i++;

}

Print_Lian_Doc(llist);

}

/*删除操作*/

void DeleteDoc(struct lian_node*llist,int n)

{

struct lian_node *ptr,*ptr1,*ptr2;

int i=1;

while(llist!=NULL && llist->n==n){

ptr2=llist;

llist=llist->link;

free(ptr2);

}

if(llist==NULL)

printf("\n无结果！\n");

ptr1=llist;

ptr2=llist->link;

while(ptr2!=NULL){

if(ptr2->n==n){

ptr1->link=ptr2->link;

free(ptr2);

}

else

ptr1=ptr2;

ptr2=ptr1->link;

}

for(ptr=llist;ptr;ptr=ptr->link){

ptr->n=i;

i++;

}

Print_Lian_Doc(llist);

}

/*遍历操作*/

void Print_Lian_Doc(struct lian_node*llist) {

struct lian_node*ptr;

printf("输出链表：");

for(ptr=llist;ptr;ptr=ptr->link)

printf("%5d",ptr->num);

printf("\n");

}

顺序表的创建插入与删除

#include #define maxsize 1024 //定义maxsize是1024 #define inplen 10 //定义inplen是10 typedefint datatype; typedefstruct { datatype data[maxsize]; int last; }sequenlist; //创建一个顺序表并且将之初始化 sequenlist *CreatInit(void) { sequenlist *l; l = new sequenlist( ); //使用动态分配sequenlist空间大小l->last=-1; //空表 return l; } //打印出顺序表 void println(sequenlist *head) { sequenlist *p = head; inti = 0; printf(" Now the squenlist is:"); for (i = 0; i<= p->last; i++) { printf("%d ", p->data[i]); } } //计算出顺序表的长度 int Length(sequenlist *head) { return head->last+1; } //给顺序表结点data[i]赋值 sequenlist *Setvalue(sequenlist *head) { inti; sequenlist *p = head; for (i = 0; idata[i]); //键盘上输入10 个结点的值} p->last = i-1;

单链表的创建、插入和删除

单链表的创建、插入和删除 （数据结构） ——SVS #include #include #include typedef int ElemType; typedef int Status; typedef struct LNode { ElemType data; struct LNode *next; }LNode,*LinkList; void InitList_Link(LinkList L) //创建空链表 { L=(LinkList)malloc(sizeof(LNode)); L->next=NULL; } Status InsertList_Link(LinkList L,int i,ElemType e) //插入链表 { LinkList s,p=L; int j=0; while(p&&jnext;j++;} if(!p||j>i-1)return -1; s=(LinkList)malloc(sizeof(LNode)); s->data=e; s->next=p->next; p->next=s; return 1; }

Status DeleteList_Link(LinkList L,int i,ElemType e) //删除链表{ LinkList q,p=L;int j=0; while(p->next&&jnext;j++;} if(!(p->next)||j>i-1)return -1; q=p->next; e=q->data; p->next=q->next; free(q); return 1; } void OutPutList_Link(LinkList L) //输出链表 { printf("表中值为："); LinkList p=L->next; while(p) { printf("%d ",p->data); p=p->next; } printf("\n"); } void CreateList_Link(LinkList L,int len) //创建链表 { int i; LinkList s,p=L; for(i=0;idata); s->next=NULL; p->next=s; p=s; } } int main() { int len; LinkList L; ElemType e; L=(LinkList)malloc(sizeof(LNode));

数据结构-顺序表的查找插入与删除

一、上机实验的问题和要求： 顺序表的查找、插入与删除。设计算法，实现线性结构上的顺序表的产生以及元素的查找、插入与删除。具体实现要求： 1.从键盘输入10个整数，产生顺序表，并输入结点值。 2.从键盘输入1个整数，在顺序表中查找该结点的位置。若找到，输出结点的位置；若找 不到，则显示“找不到”。 3.从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插 入在对应位置上，输出顺序表所有结点值，观察输出结果。 4.从键盘输入1个整数，表示欲删除结点的位置，输出顺序表所有结点值，观察输出结果。 二、源程序及注释： #include #include /*顺序表的定义：*/ #include #define ListSize 100 /*表空间大小可根据实际需要而定，这里假设为100*/ typedef int DataType; /*DataType可以是任何相应的数据类型如int, float或char*/ typedef struct { DataType data[ListSize]; /*向量data用于存放表结点*/ int length; /*当前的表长度*/ }SeqList; void main() { SeqList L; int i,x; int n=10; /*欲建立的顺序表长度*/ L.length=0; void CreateList(SeqList *L,int n); void PrintList(SeqList L,int n); int LocateList(SeqList L,DataType x); void InsertList(SeqList *L,DataType x,int i); void DeleteList(SeqList *L,int i); CreateList(&L,n); /*建立顺序表*/ PrintList(L,n); /*打印顺序表*/ printf("输入要查找的值："); scanf("%d",&x); i=LocateList(L,x); /*顺序表查找*/ printf("输入要插入的位置："); scanf("%d",&i); printf("输入要插入的元素："); scanf("%d",&x);

数据结构-单链表元素的删除与插入

单链表的删除与插入源程序如下： #include #include #include typedef int elemtype; typedef struct LNode //定义单链表存储类型 { elemtype data; struct LNode *next; }linklist; void creatlistf(linklist *&L ) //建立链表 { linklist *s; int i; elemtype a[10]; printf("请输入10个数:\n"); for(i=0;i<10;i++) scanf("%d",&a[i]); L=(linklist *)malloc(sizeof(linklist)); L->next=NULL; for(i=0;i<10;i++) { s=(linklist *)malloc(sizeof(linklist)); s->data=a[i]; s->next=L->next; L->next=s; } } void displist(linklist *L) //输出单链表 { linklist *s; s=L->next; while(s!=NULL) { printf(" %d",s->data); s=s->next; } printf("\n"); } void listinsert(linklist *L) //插入元素 {

int i=0,j,m; linklist *s,*p; printf("请输入插入位置:"); scanf("%d",&j); printf("请输入需插入元素:"); scanf("%d",&m); s=L; while(inext; i++; } if(s==NULL) printf("输入错误!\n"); else { p=(linklist *)malloc(sizeof(linklist)); p->data=m; p->next=s->next; s->next=p; } } void listdelete(linklist *&L)//删除元素{ int i,j=0,e; printf("请输入需删除第几个元素:"); scanf("%d",&i); linklist *s; s=L; while(jnext; j++; } if(s->next==NULL) printf("输入错误!\n"); else { if(s->next->next!=NULL) { e=s->next->data; s->next->data=s->next->next->data;

单链表的初始化,建立,插入,查找,删除

单链表的初始化，建立，插入，查找，删除。 #include <stdio.h> #include <stdlib.h> typedef int ElemType; //定义结点类型 typedef struct Node { ElemType data; //单链表中的数据域

struct Node *next; //单链表的指针域 }Node,*LinkedList; //单链表的初始化 LinkedList LinkedListInit() { Node *L; L = (Node

*)malloc(sizeof(Node)); //申请结点空间 if(L == NULL) //判断是否有足够的内存空间 printf("申请内存空间失败\n"); L->next = NULL; //将next设置为NULL,初始长度为0的单链表return L; }

//单链表的建立1，头插法建立单链表 LinkedList LinkedListCreatH() { Node *L; L = (Node *)malloc(sizeof(Node)); //申请头结点空间 L->next = NULL; //初始化一个空链表

ElemType x; //x为链表数据域中的数据 while(scanf("%d",&x) != EOF) { Node *p; p = (Node *)malloc(sizeof(Node)); //申请新的结点 p->data = x; //结点数据域赋值

实验一 数据结构顺序表的插入和删

实验一顺序表的操作 1.实验题目：顺序表的操作 2.实验目的和要求： 1）了解顺序表的基本概念、顺序表结构的定义及在顺序表上的基本操作(插入、删除、查找以及线性表合并)。 2)通过在Turbo C（WinTc，或visual stdio6）实现以上操作的C语言代码。 3）提前了解实验相关的知识（尤其是C语言）。 3.实验内容：(二选一) 1)顺序表的插入算法,删除算法,顺序表的合并算法 2)与线性表应用相关的实例(自己选择详尽实例) 4.部分参考实验代码： ⑴顺序表结构的定义： #include #define MAXLEN 255 typedef int ElemType; typedef struct { ElemType elem[MAXLEN]; int length; }sqList; ⑵顺序表前插（在第i号元素前插入一个新的元素） int ListInsert(sqList *la,int i,int x)

{ int j; if(i<0||i>la-> length +1) {printf(“\n the value of i is wrong!”); return 0; } if(la-> length +1>=MAXLEN) { printf(“\n overflow!”); return 0; } . for(j=la-> length;j>=i;j--) la->list[j+1]=la->list[j]; la->list[i]=x; la-> length++; return 1; } ⑶顺序表删除 int ListDelete(sqList *la,int i) { if(i<0||i>la-> length) { printf(“\n the position is wrong!\n”); return 0; }

C语言链表的建立、插入和删除

数组作为存放同类数据的集合，给我们在程序设计时带来很多的方便，增加了灵活性。但数组也同样存在一些弊病。如数组的大小在定义时要事先规定，不能在程序中进行调整，这样一来，在程序设计中针对不同问题有时需要3 0个大小的数组，有时需要5 0个数组的大小，难于统一。我们只能够根据可能的最大需求来定义数组，常常会造成一定存储空间的浪费。我们希望构造动态的数组，随时可以调整数组的大小，以满足不同问题的需要。链表就是我们需要的动态数组。它是在程序的执行过程中根据需要有数据存储就向系统要求申请存储空间，决不构成对存储区的浪费。 链表是一种复杂的数据结构，其数据之间的相互关系使链表分成三种：单链表、循环链表、双向链表，下面将逐一介绍。 7.4.1 单链表 图7 - 3是单链表的结构。 单链表有一个头节点h e a d，指向链表在内存的首地址。链表中的每一个节点的数据类型为结构体类型，节点有两个成员：整型成员（实际需要保存的数据）和指向下一个结构体类型节点的指针即下一个节点的地址（事实上，此单链表是用于存放整型数据的动态数组）。链表按此结构对各节点的访问需从链表的头找起，后续节点的地址由当前节点给出。无论在表中访问那一个节点，都需要从链表的头开始，顺序向后查找。链表的尾节点由于无后续节点，其指针域为空，写作为N U L L。 图7 - 3还给出这样一层含义，链表中的各节点在内存的存储地址不是连续的，其各节点的地址是在需要时向系统申请分配的，系统根据内存的当前情况，既可以连续分配地址，也可以跳跃式分配地址。 看一下链表节点的数据结构定义： struct node { int num; struct node *p; } ; 在链表节点的定义中，除一个整型的成员外，成员p是指向与节点类型完全相同的指针。在链表节点的数据结构中，非常特殊的一点就是结构体内的指针域的数据类型使用了未定义成功的数据类型。这是在C中唯一规定可以先使用后定义的数据结构。 ?单链表的创建过程有以下几步： 1 ) 定义链表的数据结构。 2 ) 创建一个空表。 3 ) 利用m a l l o c ( )函数向系统申请分配一个节点。 4 ) 将新节点的指针成员赋值为空。若是空表，将新节点连接到表头；若是非空表，将新 节点接到表尾。 5 ) 判断一下是否有后续节点要接入链表，若有转到3 )，否则结束。 ?单链表的输出过程有以下几步 1) 找到表头。

数据结构--单链表的插入和删除

单链表的插入和删除实验日志 指导教师刘锐实验时间2010 年10 月11 日 学院数理专业数学与应用数学 班级学号姓名实验室S331-A 实验题目：单链表的插入和删除 实验目的：了解和掌握线性表的逻辑结构和链式存储结构，掌握单链表的基本算法及相关的时间性能分析。 实验要求：建立一个数据域定义为字符串的单链表，在链表中不允许有重复的字符串；根据输入的字符串，先找到相应的结点，后删除之。 实验主要步骤： 1、分析、理解程序(相关程序见附录) 。 2、调试程序，并设计输入字符串数据（如：aa, bb , cc , dd, ee，#），测试程序的如下功能： 不允许重复字符串的插入；根据输入的字符串，找到相应的结点并删除。 3、修改程序： （1）增加插入结点的功能。 （2）将建立链表的方法改为头插入法。 实验结果： 1、不允许重复字符串的插入功能结果如下：

3、删除和插入结点的功能如下：

心得体会： 通过这次实验我学会了单链表的建立和删除，基本了解了线性表的逻辑结构和链式存储结构，掌握了单链表的基本算法，使我受益匪浅。在调试程序的过程中，遇见了一系列的问题，后来在同学的帮助下，修改了几个语句后，终于把它给调试出来了。有时候一个标点符号的问题就可能导致程序无法运行。所以在分析调试程序的时候一定要仔细。 附加程序代码： 1、调试之后的程序如下（其中蓝色字体部分为修改过的）： #include"stdio.h" #include"string.h" #include"stdlib.h" #include"ctype.h" typedef struct node //定义结点 { char data[10]; //结点的数据域为字符串 struct node *next; //结点的指针域 }ListNode; typedef ListNode * LinkList; // 自定义LinkList单链表类型 LinkList CreatListR1(); //函数，用尾插入法建立带头结点的单链表ListNode *LocateNode(); //函数，按值查找结点

数据结构循环链表插入和删除源代码代码

typedef struct LNode//结点类型 { int data;//数值域 struct LNode *next;//指针域 }CrLNode,*CrLinklist; #include"Base.h" #include"construct.h" #include"circulate_operation.c" int main() { CrLinklist L; int i,choice,n,e; printf("请输入链表元素个数:"); scanf("%d",&n); L=Initlist_L(n); printf("请选择执行语句，选择输入1，执行插入操作或选择输入2，执行删除操作:"); scanf("%d",&choice); switch(choice) { case 1: { printf("请输入插入元素的位置:"); scanf("%d",&i); if(i<=0||i>n) printf("您输入的值不合法"); else printf("请输入插入元素的值："); scanf("%d",&e); L=ListInsert_L(L,i,e); printf("插入后的链表为："); printlist_L(L); };break; case 2: { printf("请输入删除元素的位置:"); scanf("%d",&i); if(i<=0||i>n) printf("您输入的值不合法"); else L=ListDelete_L(L,i); printf("删除后的链表为");

printlist_L(L); };break; } } CrLinklist Initlist_L(int n)//创建带头结点的单链表 { CrLinklist L; CrLinklist P; int i; L=(CrLinklist)malloc(sizeof(CrLNode)); L->next=L;/* 先建立一个带头结点的单链表*/ printf("请输入%d个数据\n",n); for(i=n;i>0;--i) { P=(CrLinklist)malloc(sizeof(CrLNode)); /* 生成新结点*/ scanf("%d",&P->data); /* 输入元素值*/ P->next=L->next; /* 插入到表头*/ L->next=P; } return L; } CrLinklist ListInsert_L(CrLinklist L,int i,int e)//单链表的插入 { CrLinklist P,S; int j; P=L; j=0; while(P&&jnext; ++j; }//寻找第i-1个节点 if(!P||j>i-1) return ERROR; S=(CrLinklist)malloc(sizeof(CrLNode));//生成新节点 S->data=e; S->next=P->next;//插入到S中 P->next=S; return L; } CrLinklist ListDelete_L(CrLinklist L,int i)//单链表的删除 { CrLinklist P,S;

单链表的插入和删除实验报告

. 实验一、单链表的插入和删除 一、目的 了解和掌握线性表的逻辑结构和链式存储结构，掌握单链表的基本算法及相关的时间性能分析。 二、要求： 建立一个数据域定义为字符串的单链表，在链表中不允许有重复的字符串；根据输入的字符串，先找到相应的结点，后删除之。 三、程序源代码 #include"stdio.h" #include"string.h" #include"stdlib.h" #include"ctype.h" typedef struct node //定义结点 { char data[10]; //结点的数据域为字符串 struct node *next; //结点的指针域 }ListNode; typedef ListNode * LinkList; // 自定义LinkList单链表类型 LinkList CreatListR1(); //函数，用尾插入法建立带头结点的单链表

ListNode *LocateNode(); //函数，按值查找结点 void DeleteList(); //函数，删除指定值的结点void printlist(); //函数，打印链表中的所有值 void DeleteAll(); //函数，删除所有结点，释放内存 //==========主函数============== void main() { char ch[10],num[10]; LinkList head; head=CreatListR1(); //用尾插入法建立单链表，返回头指针printlist(head); //遍历链表输出其值 printf(" Delete node (y/n):");//输入“y”或“n”去选择是否删除结点scanf("%s",num); if(strcmp(num,"y")==0 || strcmp(num,"Y")==0){ printf("Please input Delete_data:"); scanf("%s",ch); //输入要删除的字符串 DeleteList(head,ch); printlist(head); } DeleteAll(head); //删除所有结点，释放内存 } //==========用尾插入法建立带头结点的单链表

顺序表的查找、插入与删除实验报告

《数据结构》实验报告一 学院：班级： 学号：姓名： 日期：程序名 一、上机实验的问题和要求： 顺序表的查找、插入与删除。设计算法，实现线性结构上的顺序表的产生以及元素的查找、插入与删除。具体实现要求： 1.从键盘输入10个整数，产生顺序表，并输入结点值。 2.从键盘输入1个整数，在顺序表中查找该结点的位置。若找到，输出结点的位置；若找 不到，则显示“找不到”。 3.从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插 入在对应位置上，输出顺序表所有结点值，观察输出结果。 4.从键盘输入1个整数，表示欲删除结点的位置，输出顺序表所有结点值，观察输出结果。 二、源程序及注释： #include #include /*顺序表的定义：*/ #include #define ListSize 100 /*表空间大小可根据实际需要而定，这里假设为100*/ typedef int DataType; /*DataType可以是任何相应的数据类型如int, float或char*/ typedef struct { DataType data[ListSize]; /*向量data用于存放表结点*/ int length; /*当前的表长度*/ }SeqList; void main() { SeqList L; int i,x; int n=10; /*欲建立的顺序表长度*/ L.length=0; void CreateList(SeqList *L,int n); void PrintList(SeqList L,int n); int LocateList(SeqList L,DataType x); void InsertList(SeqList *L,DataType x,int i); void DeleteList(SeqList *L,int i);

单链表的插入和删除实验报告

单链表的插入和删除实验报告

实验一、单链表的插入和删除 一、目的 了解和掌握线性表的逻辑结构和链式存储结构，掌握单链表的基本算法及相关的时间性能分析。 二、要求： 建立一个数据域定义为字符串的单链表，在链表中不允许有重复的字符串；根据输入的字符串，先找到相应的结点，后删除之。 三、程序源代码 #include"stdio.h" #include"string.h" #include"stdlib.h" #include"ctype.h" typedef struct node //定义结点 { char data[10]; //结点的数据域为字符串struct node *next; //结点的指针域 }ListNode; typedef ListNode * LinkList; // 自定义LinkList单链表类型LinkList CreatListR1(); //函数，用尾插入法建立带头结点的单链表

ListNode *LocateNode(); //函数，按值查找结点void DeleteList(); //函数，删除指定值的结点void printlist(); //函数，打印链表中的所有值void DeleteAll(); //函数，删除所有结点，释放内存//==========主函数============== void main() { char ch[10],num[10]; LinkList head; head=CreatListR1(); //用尾插入法建立单链表，返回头指针 printlist(head); //遍历链表输出其值 printf(" Delete node (y/n):");//输入“y”或“n”去选择是 否删除结点 scanf("%s",num); if(strcmp(num,"y")==0 || strcmp(num,"Y")==0){ printf("Please input Delete_data:"); scanf("%s",ch); //输入要删除的字符串 DeleteList(head,ch); printlist(head); } DeleteAll(head); //删除所有结点，释放内存 }

实验一数据结构顺序表的插入和删除

实验一顺序表的操作 1. 实验题目：顺序表的操作 2.实验目的和要求： 1)了解顺 序表的基本概念、顺序表结构的定义及在顺序表上的基本操作(插入、 删除、查找以及线性表合并 )。 2)通过在 Turbo C ( WinTc ，或 visual stdio6 )实现以上操作的 C 语言 代码。 3)提前了解实验相关的知识(尤其是 C 语 言)。 3.实验内容：(二选一) 1) 顺序表的插入算法, 删除算法, 顺序表的合并算法 2) 与线性表应用相关的实例( 自己选择具体实例) 4.部分参考实验代码： ⑴ 顺序表结构的定义： #include #define MAXLEN 255 typedef int ElemType; typedef struct { ElemType elem[MAXLEN]; int length; }sqList; ⑵ 顺序表前插(在第i 号元素前插入一个新的元素) int ListInsert(sqList *la,int i,int x) { int j; if(i<0||i>la-> length +1) { printf( “ n the value of i is wrong! ” ); return 0; } if(la-> length +1>=MAXLEN) { printf( “ n overflow! ” ); return 0; }

. for(j=la-> length;j>=i;j--) la->list[j+1]=la->list[j]; la->list[i]=x; la-> length ++; return 1; } ⑶ 顺序表删除 int ListDelete(sqList *la,int i) { if(i<0||i>la-> length ) { printf( “ return 0; n”); } for(i;i length;i++) la->list[i-1]=la->list[i]; la-> length --; return 1; } 5.附录：实验预备知识： ⑴ 复习 C 语言中数组的用法。 ⑵ 了解线性表和顺序表的概念，顺序表的定义方法； 线性表是n 个数据元素的有限序列，至于每个数据元素的具体含义，在不同的情况下各不相同。 顺序表是线性表的顺序存储表示，是用一组地址连续的存储单元依次存储线性表的数据元素。 在 C 语言中，顺序表是用数组来实现的。 ⑶ 掌握线性表在顺序存储结构上实现基本操作：查找、插入、删除和 合并的算法。 在实现这些算法的时候，要注意判断输入数据的合法性，除此之外还要要注意以下内容： 在实现查找的时候，首先要判断该顺序表是否为空，其次要判断查找后的结果（查到时输出查到的数据，未查到时给出未查到提 示）。 在实现插入的时候，首先要判断该顺序表是否为满，如为满则报错 （此时要注意：顺序表是用数组来实现的，它不能随机分配空 间）；如不为满，则需判断要插入的位置是否合法（例如：如果 一个线性表的元素只有10 个，而要在第0 个元素前插入或在第 11 个元素后插入就为不合法）。其次要注意是前插还是后插，两

单链表的插入和删除实验报告

单链表的插入和删除实验报告 一、目的： 了解和掌握线性表的逻辑结构和链式存储结构，掌握单链表的基本算法及相关的时间性能分析。 二、要求： 建立一个数据域定义为字符串的单链表，在链表中不允许有重复的字符串；根据输入的字符串，先找到相应的结点，后删除之。 三、实验内容： 1、分析、理解程序。

程序的主要功能是实现对数据域为字符串的单链表的建立、查找、删除、插入和浏览。 其中链表的建立为头插入法。 链表建立示意图： (a)、删除hat: （b）、插入charu: 2、修改程序： 1)增加插入结点的功能。 如在jat后插入charu，程序运行结果为：

2)将建立链表的方法改为头插入法。 程序源代码： ===================main.cpp===================== #include #include #include #include #include "linkList.h" void main() { char ch[10],num[10],ch1[10];

LinkList L; L=CreateList(); //用尾插入法建立单链表，返回头指针 PrintList(L); //遍历链表输出其值 printf(" Delete node (y/n):"); //输入"y"或"n"去选择是否删除结点 scanf("%s",num); if(strcmp(num,"y")==0 || strcmp(num,"Y")==0) { printf("Please input Delete_data:"); scanf("%s",ch); //输入要删除的字符串 DeleteList(L,ch); PrintList(L); } printf("the position after:"); scanf("%s",ch1); InsertList(L,ch1); PrintList(L); FreeAll(L); //删除所有结点，释放内存 } ===================linkList.cpp===================== #include "linkList.h" #include #include #include #include //==========用尾插入法建立带头结点的单链表============ LinkList CreateList()

顺序表的查找、插入与删除

1. 实验项目的目的和任务 顺序表的查找、插入与删除。设计算法，实现线性结构上的顺序表的产生以及元素的查找、插入与删除。具体实现要求： 1) 从键盘输入10个整数，产生顺序表，并输入结点值。 2) 从键盘输入1个整数，在顺序表中查找该结点的位置。若找到，输出结点的位置；若找不到，则显示“找不到”。 3) 从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插入在对应位置上，输出顺序表所有结点值，观察输出结果。 4) 从键盘输入1个整数，表示欲删除结点的位置，输出顺序表所有结点值，观察输出结果。 2. 上机实验内容 1. 定义一个整型数组。用于存放顺序表的数据元素 2. 设计一个函数，完成顺序表的建立。 从键盘输入10个整数，产生顺序表，并输入结点值。 3. 设计一个函数，完成顺序表的查找。 从键盘输入1个整数，在顺序表中查找该结点的位置。若找到，输出结点的位置；若找不到，则显示“找不到”。 4. 设计一个函数，完成顺序表的插入。 从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插入在对应位置上，输出顺序表所有结点值，观察输出结果。 5. 设计一个函数，完成顺序表的删除。 从键盘输入1个整数，表示欲删除结点的位置，输出顺序表所有结点值，观察输出结果。 6. 设计一个函数，用于顺序显示当前线性表中的所以元素。 3. 主要实验方法 程序主框架已经设计好。见SqList.C文件。请按要求设计各个函数，并完成正确调用。 下面是SqList.C里的内容 #include #include #define N 10 //顺序表的最大容量 int length=0; //顺序表的当前元素个数 void main() { int List[N]; char ch,exit='N'; do { system("CLS"); printf("\t\t********************************************\n"); printf("\t\t* 1.创建一个顺序表 .........(1) *\n"); printf("\t\t* 2.在顺序表中查找元表.........(2) *\n"); printf("\t\t* 3.在顺序表中插入元表.........(3) *\n");

数据结构课程设计实验 单链表的插入与删除实验报告

**学院 本科实验报告 （**-**学年第一学期） 课程名称：数据结构实验 任课教员： 系： 专业： 年月日 **学院

《数据结构》课程实验报告 实验项目名称：单链表的插入与删除 系（）：：专业：指导教员： 姓名：学号：成绩： 同组姓名： 实验地点： １.实验项目名称：单链表的查找、插入与删除 2.实验目的和要求：设计算法，实现线性结构上的单链表的产生以及元素的查找、插入与删除。通过该算法的设计和C语言程序实现，熟悉针对单链表作为存储结构的线性表上的查找、插入、删除等基本操作的实现方法。 3.实验原理：单链表采用链式存储结构，具有指针域和数据域。 4.实验内容: 1)从键盘输入20个整数，产生不带表头的单链表，并输入结点

值。 2)从键盘输入1个整数，在单链表中查找该结点的位置。若找到， 则显示“找到了”；否则，则显示“找不到”。 3)从键盘输入2个整数，一个表示欲插入的位置i，另一个表示 欲插入的数值x，将x插入在对应位置上，输出单链表所有结点值，观察输出结果。 4)从键盘输入1个整数，表示欲删除结点的位置，输出单链表所 有结点值，观察输出结果。 5.实验环境:Windows2000 visual studio c++ 6.操作方法与实验步骤: (1)实验原代码（c语言版）： #include typedef int ElemType; #include /* For _MAX_PATH definition */ #include /* 单链表结构的定义*/ typedef struct LNode { ElemType data; struct LNode *next; }; typedef struct LNode *LinkList; LinkList CreatList_L(struct LNode **L,int n)

线性顺序表的插入与删除(实验报告)

一、实验目的和要求 通过对顺序表的编程练习，加强对顺序表的特点、顺序存储结构及其基本运算的理解和掌握。提前了解实验相关的c语言的知识。使用C语言根据相应算法编写一个程序，实现建立线性顺序表、插入和删除等基本操作。要求仔细阅读下面的内容，编写一个C程序，上机调试通过，并观察其结果，写出实验报告书。 二、实验内容和原理 内容：建立一个容量10的顺序表，在其中插入3个元素，然后作删除运算。 原理： 在第i个元素前插入元素，从第i个元素开始到最后一个元素均向后移动一个位置，然后将新元素插入到第i个位置，将线性表的长度加1。 删除第i个元素，从第i+1个元素开始到最后一个元素均向前移动一个位置，然后将线性表的长度减1。 三、主要仪器设备 计算机一台 四、实验主程序 #include #include struct List{ int size; int n; int *head; }; void init(struct List *pl,int size) { pl->size=size; pl->n=0; pl->head=malloc(size*sizeof(int)); } void in(int i,int val,struct List *pl) { int k; if(pl->n==pl->size) { printf("list is full.\n"); return; } if(i>pl->n) i=pl->n+1; if(i<1) i=1; for(k=pl->n-1;k>=i-1;--k) pl->head[k+1]=pl->head[k]; pl->head[i-1]=val; ++pl->n; } void out(int i,struct List *pl) { int k; if(pl->n==0) { printf("list is empty.\n"); return; } if(i<1||i>pl->n) { printf("this element is not in the list.\n"); return; } for(k=i;k<=pl->n;++k) pl->head[k-1]=pl->head[k]; --pl->n;

实验一 顺序表的操作、插入与删除

实验一顺序表的操作、插入与删除 【实验目的】 （1）熟悉数据移动是顺序表的操作特点。 （2）掌握顺序表中元素的移动、插入和删除操作的特点。 【实验内容】 题1 设有一个用向量表示的线性表a[n]，a[0]中不存放线性表的元素。要求写出将其中元素逆置的函数，并只允许用a[0]作附加的工作单元。 题2 写出从线性表中删除元素值为x的结点的函数。若该表中无此结点，则输出“无此结点”信息。 【实验要求】 从键盘任意输入9个整数，依次存放在数组a[10]的元素a[1]~a[9]中，逆置后输出。 在题1的基础上，从键盘输入一个整数x，从a[1]开始访问数组a，完成题2。 【实验提示】 题1 有以下两种方法： （1）将a[1]至a[n-1]前移1位，再将a[n-1]←a[0]；接着a[1]至a[n-2]前移一位，再将a[n-2]←a[0]；……。 （2）可用移动和插入，通过a[0]使元素a[1]和a[n-1]交换；再使a[2]和a[n-2]交换；如此继续至中点为止。注意如何判断中点。 思考这两种方法的时间复杂度分别是多少。 题2 首先也要找到被删除元素的位置，然后将该位置以后的数据元素全部前移一个单元。注意：当数组a中有重复的元素值且x与此值相等时，函数应能删除全部重复元素。当有多个连续的相同值需要删除时，应都能删除。 程序如下： #include #include /* run this program using the console pauser or add your own getch, system("pause") or input loop */ int main(int argc, char *argv[]) { int a[100]={0},i,x,j,k; int n; //输入数组 printf("请输入数组大小n："); scanf("%d",&n); printf("请输入%d个数:\n",n-1); for (i=1;i

数据结构线性表单链表的查找,插入,删除

实验报告 课程名称数据结构 姓名 学号 专业班级 指导教师

目录 第二章线性表的查找、插入、删除 (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 #include #include #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<=https://www.sodocs.net/doc/d47095234.html,st)&&(L.elem[i]!=e)) /*顺序扫描表，直到找到值为e的元素，或扫描到表尾仍没找到*/ i++; if(i<=https://www.sodocs.net/doc/d47095234.html,st) return (i+1); /*若找到值为e的元素，则返回其序号*/ else return(-1); /*若没找到，则返回空序号*/ } void main() { Seqlist l; int p,q,r; int i; printf("请输入线性标的长度:"); scanf("%d",&r);