实验二 单向链表的操作

合集下载

链表基本操作实验报告

链表基本操作实验报告
void LinkedListInsert(LinkedList L,int i,ElemType x) {LinkedList p,s; int j; j=1;p=L;
while(p&&j<i) {p=p->next;j++;} if(p==NULL||j>i)
printf("插入位置不正确\n"); else{s=(LNode *)malloc(sizeof(LNode));
{printf("%d ",p->data); p=p->next;} } printf("\n"); }
int LinkedListLength (LinkedList L) {LinkedList p;
int j; p=L->next; j=0; while(p!=NULL)
{j++;p=p->next;} return j; }
8.向链表中插入元素
插入元素之后的链表 9.从链表中删除元素
删除位置为 6 的元素(是 3)
10.清空单链表
五、 实验体会
经过这次单链表基本操作实验,自己的编程能力有了进一步的提高,认识到自 己以前在思考一个问题上思路不够开阔,不能灵活的表达出自己的想法,虽然在 打完源代码之后出现了一些错误,但是经过认真查找、修改,最终将错误一一修 正,主要是在写算法分析的时候出现了障碍,经过从网上查找资料,自己也对程 序做了仔细的分析,对单链表创建、插入、删除算法画了详细的 N-S 流程图。
r=L; r 指向头结点
使用 malloc 函数动态分配存储空间,指针 p 指向新开辟的结点,并将元素存
放到新开辟结点的数据域,

实验2-链表的应用

实验2-链表的应用

实验2 链表的应用一、实验目的●了解并掌握链表的概念与定义●能够实现并运用链表●熟练运用链表的基本操作二、实验环境●个人计算机一台,CPU主频1GHz以上,1GB以上内存,2GB以上硬盘剩余空间。

●Windows2000、Windows XP或Win 7操作系统●Code::Blocks(版本12.11或近似版本,英文版),或VC++ 6.0三、实验内容1 基本部分(必做)1.单向链表的创建与操作设单向链表中节点的数据域的数据类型为整型,编写函数实现以下操作:(1)实现单向链表的创建(包括初始化)与输出操作,节点的个数及节点的数据由用户输入。

(源代码:ds3-1.c)(2)查找给定的单链表中的第i个节点,并将其地址返回。

若不存在第i 个节点,则返回空地址。

(源代码:ds3-2.c)(3)查找给定的单链表中值为n的节点,并将其地址返回。

若不存在值为n的节点,则返回空地址。

同时,还应通过参数传回该节点的序号。

(源代码:ds3-3.c)(4)删除给定的单链表中的第i个节点,成功返回1,失败返回0。

(源代码:ds3-4.c)(5)删除给定的单链表中值为n的节点,成功返回1,失败返回0。

(源代码:ds3-5.c)(6)在给定的单链表的第i位上插入值为n的节点。

(源代码:ds3-6.c)(7)在给定单链表的值为m的节点的前面插入一个值为n的节点。

(源代码:ds3-7.c)2.双向循环链表的创建与操作设双向链表中节点的数据域的数据类型为整型,编写函数实现以下操作:(1)实现双向循环链表的创建(包括初始化)与输出操作,节点的个数及节点的数据可以在程序中直接确定。

(源代码:ds4-1.c)(2)删除给定的双向循环链表中值为n的节点,成功返回1,失败返回0。

(源代码:ds4-2.c)(3)在给定的双向循环链表中的第i位上插入值为n的节点,成功返回1,失败返回0。

(源代码:ds4-3.c)2 提高部分(选做)已知链表A和B中节点的值都按照从小到大的顺序排序,且任何两个节点的值都不相同。

实验二 链式存储结构----单向链表的有关操作

实验二 链式存储结构----单向链表的有关操作

实验二链式存储结构----单向链表的有关操作
一、实验目的
了解和掌握线性表的逻辑结构和链式存储结构,掌握单链表的基本算法。

二、实验内容
建立一个学生成绩信息(包括学号、姓名、成绩)的单向链表,学生记录按学号由小到大顺序排列,要求实现对成绩信息的插入、修改、删除和遍历操作。

三、实验要求
1. 根据实验内容编程,上机调试、得出正确的运行程序。

2. 写出实验报告(包括源程序和运行结果)。

四、实验学时
2学时。

五、实验步骤:
1.进入编程环境,建立一新文件;
2.类型定义
#include <stdio.h>
struct stud_node{ /*链表结点类型*/
char num[10];
char name[20];
int score;
struct stud_node *next;
}LNode,*LinkList;
3.为了算法实现简单,最好采用带头结点的单向链表。

4. 编译运行程序,观察运行情况和输出结果。

数据结构-实验2-链表的基本操作

数据结构-实验2-链表的基本操作

实验2链表的基本操作一、需求分析1,初始化链表2,调用插入函数建立一个链表3,链表的插入和删除4,链表元素的查找4,将链表分为奇链表和偶链表5,链表的逆置二、概要设计1.基础题1)编写链表基本操作函数typedefstruct list{Int data;Struct list* next}LIST;LIST* InitList() //初始化LIST* InsertList(LIST * L,int item,int re) //向链表指定位置插入元素LIST* InsertOrderList(LIST *L,int item) //向有序链表指定位置插入元素void FindList(LIST*L, int item)//查找链表中的元素void display(LIST *L)//显示链表void divide(LIST* La, LIST *Lb)//拆分链表LIST * turn(LIST *L)//转置链表2)调用上述函数实现下列操作,操作步骤如下。

A.初始化链表B.调用插入函数建立一个链表C.在链表中寻找指定的元素D.在链表中删除指定值的元素E.遍历并输出链表注意每完成一个步骤,必须及时输出顺序表元素,便于观察操作结果2.提高题a)将一个首结点指针为a的单链表A分解成两个单链表A和B,其首结点指针分别为a,b,使得链表A中含有原链表A中序号为奇数的元素,而链表B中含有原链表A中序号为偶数的元素,且保持原来的相对顺序。

解题思路将单链表A中含有序号为偶数的元素删除,并在删除时把这些结点链接起来构成单链表B即可。

b)将链接存储线性表逆置,即最后一个结点变成第一个结点原来倒数第二个结点变成第二个结点,如此等等。

解题思路依次遍历源链表,将每个元素依次赋给一个新链表并将新链表从后到前连接。

3.主函数void main(){LIST *L1,*L2,*L3;int i;L1=InitList();printf("创建链表L1:\n");for(i=1;i<=5;i++){L1=InsertList(L1,i*2,i);}display(L1);for(i=1;i<=9;i+=4){printf("在L1的%d位置插入3:\n",i);L1=InsertList(L1,3,i);display(L1);}//有序表L2 = InitList();printf("\n有序表实验:\n");printf("创建链表L2:\n");for (i = 1; i <= 5; i++){L2 = InsertList(L2, i * 2, i); }display(L2);for (i = 1; i <= 13; i +=6 ){printf("插入%d:\n",i);L2 = InsertOrderList(L2,i);display(L2);}//删除元素实验printf("\n删除元素实验:\n"); printf("L2插入1:\n", i);L2 = InsertList(L2,1,1);display(L2);for (i = 1; i < 12; i += 5){printf("删除L2中%d\n",i);L2 = DeleteList(L2, i);display(L2);}//查找printf("\n查找元素实验:\n"); printf("查找L2中%d\n", 13); FindList(L2,13);printf("查找L2中%d\n", 6); FindList(L2, 6);//分解printf("\n分解实验:\n");printf("L2:\n");display(L2);L3 = InitList();printf("将L2偶序数拆分到L3\n"); divide(L2,L3);printf("L2:\n");display(L2);printf("L3:\n");display(L3);printf("\n逆序实验:\n");printf("L2:\n");display(L2);L2 = turn(L2);printf("转置L2:\n");display(L2);}三、详细分析插入实验,函数能够在链表前、中、后插入元素,并判断插入位置是否超过链表长度,若超过则接入链尾。

实验二 单链表基本操作

实验二  单链表基本操作

实验二单链表基本操作一、实验目的1.掌握握单链表的基本操作:新建、插入、删除、查找等运算。

二、实验要求1.认真阅读和掌握本实验的程序。

2.上机运行本程序。

3.保存和打印出程序的运行结果,并结合程序中的问题进行分析。

三、实验内容单链表基本操作的实现,这个程序中演示了单链表的创建、插入、删除和查找。

程序如下:#include<malloc.h>typedef struct node{int data;struct node *next;} NODE;/******************************************/NODE *Create()//问题1:该函数创建的带头结点的单链表,还是不带头结点的单链表?{NODE *p,*head;int x;head=(NODE *)malloc(sizeof(NODE));head->next=NULL;printf("Input data,-1 to End!\n");scanf("%d",&x);while(x!=-1){p=(NODE *)malloc(sizeof(NODE));p->data=x;p->next=head->next;head->next=p;scanf("%d",&x);}return(head);}/******************************************/void Output(NODE *head){NODE *p;p=head;printf("Begin to dump the LinkList...\n");while(p->next!=NULL){printf("->%d",p->next->data);p=p->next;}printf("\nThe LinkList ended!\n");}/******************************************/int Listlen(NODE *head){int i=0;NODE *p=head;while(p->next!=NULL){i++;p=p->next;}return(i);}/******************************************/int Get(NODE *head,int i)//问题2:将该函数修改成返回第i个元素的指针,若不存在,返回空{int j=0;NODE *p=head;while(p->next&&j<i){j++;p=p->next;}if(!p->next||j>i) return(0);else return(p->data);}/******************************************/void Del(NODE *head,int i){NODE *p=head;int j=0;while(p->next&&j<i-1){j++;p=p->next;}if(!p->next||j>i-1) printf("the position is wrong\n");elsep->next=p->next->next;}/******************************************/void Ins(NODE *head,int i,int e){NODE *p=head,*q;int j=0;while(p->next&&j<i-1){j++;p=p->next;}if(!p->next&&j>i-1) printf("Wrong position\n" );else{q=(NODE *)malloc(sizeof(NODE));q->data=e;q->next=p->next;p->next=q;}}/******************************************/main(){NODE *head;int length;int i,element;head=Create();Output(head);//以下函数调用(求长度、插入、删除、查找)能否改成菜单形式?如何改?length=Listlen(head);printf("the length of the link is %d\n",length);printf("input the order :\n");scanf("%d",&i);element=Get(head,i);printf("the element of the order is %d\n",element);printf("input the del position \n");scanf("%d",&i);Del(head,i);Output(head);printf("Input the insert posion and element:\n");scanf("%d%d",&i,&element);Ins(head,i,element);Output(head);}}。

实验二 链表操作实现

实验二 链表操作实现

实验二链表操作实现实验日期:2017 年 3 月16 日实验目的及要求1. 熟练掌握线性表的基本操作在链式存储上的实现;2. 以线性表的各种操作(建立、插入、删除、遍历等)的实现为重点;3. 掌握线性表的链式存储结构的定义和基本操作的实现;4. 通过本实验加深对C语言的使用(特别是函数的参数调用、指针类型的应用)。

实验内容已知程序文件linklist.cpp已给出学生身高信息链表的类型定义和基本运算函数定义。

(1)链表类型定义typedef struct {int xh; /*学号*/float sg; /*身高*/int sex; /*性别,0为男生,1为女生*/} datatype;typedef struct node{datatype data; /*数据域*/struct node *next; /*指针域*/} LinkNode, *LinkList;(2)带头结点的单链表的基本运算函数原型LinkList initList();/*置一个空表(带头结点)*/void createList_1(LinkList head);/*创建单链表*/void createList_2(LinkList head);/* 创建单链表*/void sort_xh(LinkList head);/*单链表排序*/void reverse(LinkList head);/*对单链表进行结点倒置*/void Error(char *s);/*自定义错误处理函数*/void pntList(LinkList head);/*打印单链表*/void save(LinkList head,char strname[]);/*保存单链表到文件*/任务一创建程序文件linklist.cpp,其代码如下所示,理解LinkList类型和基本运算函数后回答下列问题。

#include <stdio.h>#include <stdlib.h>/*单链表结点类型*/typedef struct {int xh; /*学号*/float sg; /*身高*/int sex; /*性别,0为男生,1为女生*/} datatype;typedef struct node{datatype data; /*数据域*/struct node *next; /*指针域*/} LinkNode, *LinkList;/*带表头的单链表的基本运算函数*/LinkList initList();/*置一个空表(带头结点)*/void createList_1(LinkList head);/*创建单链表*/void createList_2(LinkList head);/*创建单链表*/void sort_xh(LinkList head);/*单链表排序*/void reverse(LinkList head);/*单链表倒置*/void Error(char *s);/*自定义错误处理函数*/void pntList(LinkList head);/*打印单链表*/void save(LinkList head,char strname[]);/*保存单链表到文件*//*置一个空表*/LinkList initList(){ LinkList p;p=(LinkList)malloc(sizeof(LinkNode));p->next=NULL;return p;}/*创建单链表*/void createList_1(LinkList head){ FILE *fp;int xh;float sg;int sex;LinkList p;if((fp=fopen("records.txt","r"))==NULL){ Error("can not open file !");return ;}while(!feof(fp)){ fscanf(fp,"%d%f%d",&xh,&sg,&sex);p=(LinkList)malloc(sizeof(LinkNode));p->data.xh=xh;p->data.sg=sg;p->data.sex=sex;p->next=head->next;head->next=p;}fclose(fp);}/*创建单链表*/void createList_2(LinkList head){ FILE *fp;int xh;float sg;int sex;LinkList p,rear;if((fp=fopen("records.txt","r"))==NULL){ Error("can not open file !");return ;}rear=head;while(!feof(fp)){ fscanf(fp,"%d%f%d",&xh,&sg,&sex);p=(LinkList)malloc(sizeof(LinkNode));p->data.xh=xh;p->data.sg=sg;p->data.sex=sex;p->next=NULL;rear->next=p;rear=p;}fclose(fp);}/*单链表排序*/void sort_xh(LinkList head){LinkList q,p,u;p=head->next;head->next=NULL;/*利用原表头结点建新的空表*/while(p){ q=p; /*q为被插入的结点*/p=p->next;/*用p记录后继结点*//*遍历新链表查找插入位置*/u=head;while(u->next!=NULL)/*查找插入位置*/{ if(u->next->data.xh>q->data.xh)break;u=u->next;}/*插入在u结点的后面*/q->next=u->next;u->next=q;}}/*单链表倒置*/void reverse(LinkList head){ LinkList p, r;p=head->next;head->next=NULL;while(p){ r=p;p=p->next;/*r指向结点头插到链表*/r->next=head->next;head->next=r;}}/*输出单链表*/void pntList(LinkList head){ LinkList p;p=head->next;while(p!=NULL){printf("%2d: %.2f %d\n",p->data.xh,p->data.sg,p->data .sex);p=p->next;}}/*自定义错误处理函数*/void Error(char *s){ printf("\n %s", s);exit(1); /*返回OS,该函数定义在stdlib.h中*/}/*保存单链表到文件*/void save(LinkList head,char strname[]){ FILE *fp;LinkList p;if((fp=fopen(strname,"w"))==NULL){ printf("can not open file !");return ;}p=head->next;while(p!=NULL){ fprintf(fp,"%2d %5.2f %2d\n",p->data.xh,p->data.sg,p->data.sex);p=p->next;}fclose(fp);}请回答下列问题:(1)由单链表结点类型定义可知,该链表结点类型名为 LinkNode ,结点的指针类型为 LinkList ,向系统申请一个学生结点空间并把起始地址存于上述结点指针变量new 中的语句是: p=(LinkList)malloc(sizeof(LinkNode)); 。

数据结构实验二链表

数据结构实验二链表

数据结构实验二1、实验目的∙熟练掌握线性表的链式存储结构定义及基本操作∙理解循环链表和双链表的特点和基本运算2、实验内容:建立单链表,完成链表(带表头结点)的基本操作:建立链表、插入、删除、查找、输出、求前驱、求后继、两个有序链表的合并操作。

其他基本操作还有销毁链表、将链表置为空表、求链表的长度、获取某位置结点的内容、搜索结点。

1.问题描述:利用线性表的链式存储结构,设计一组输入数据(假定为一组整数),能够对单链表进行如下操作:∙初始化一个带表头结点的空链表;∙创建一个单链表是从无到有地建立起一个链表,即一个一个地输入各结点数据,并建立起前后相互链接的关系。

又分为逆位序(插在表头)输入n 个元素的值和正位序(插在表尾)输入n 个元素的值;∙插入结点可以根据给定位置进行插入(位置插入),也可以根据结点的值插入到已知的链表中(值插入),且保持结点的数据按原来的递增次序排列,形成有序链表。

∙删除结点可以根据给定位置进行删除(位置删除),也可以把链表中查找结点的值为搜索对象的结点全部删除(值删除);∙输出单链表的内容是将链表中各结点的数据依次显示,直到链表尾结点;∙求前驱结点是根据给定结点的值,在单链表中搜索其当前结点的后继结点值为给定的值,将当前结点返回;∙求后继结点是根据给定结点的值,在单链表中搜索其当前结点的值为给定的值,将后继结点返回;∙两个有序链表的合并是分别将两个单链表的结点依次插入到第3 个单链表中,继续保持结点有序;编写主程序,实现对各不同的算法调用。

其它的操作算法描述略。

2.实现要求:对链表的各项操作一定要编写成为C(C++)语言函数,组合成模块化的形式,还要针对每个算法的实现从时间复杂度和空间复杂度上进行评价。

∙“初始化算法”的操作结果:构造一个空的线性表L,产生头结点,并使L 指向此头结点;∙“建立链表算法”初始条件:空链存在;操作结果:选择逆位序或正位序的方法,建立一个单链表,并且返回完成的结果;∙“链表(位置)插入算法”初始条件:已知单链表L 存在;操作结果:在带头结点的单链线性表L 中第i 个位置之前插入元素e;∙“链表(位置)删除算法”初始条件:已知单链表L 存在;操作结果:在带头结点的单链线性表L 中,删除第i 个元素,并由e 返回其值;∙“输出算法”初始条件:链表L 已存在;操作结果:依次输出链表的各个结点的值;∙“求前驱算法”初始条件: 线性表L 已存在;操作结果: 若cur_e 是L 的数据元素,且不是第一个,则用pre_e 返回它的前驱;∙“求后继算法”初始条件: 线性表L 已存在;操作结果: 若cur_e 是L 的数据元素,且不是最后一个,则用next_e 返回它的后继;∙“两个有序链表的合并算法”初始条件: 线性表单链线性表La 和Lb 的元素按值非递减排列;操作结果:归并La 和Lb 得到新的单链表。

单链表的 基本操作

单链表的 基本操作

单向链表单向链表的基本操作,创建一个由6个节点组成的单向链表,显示链表中每个节点的数据,并且做增加、删除、查找节点以及计算单链表的长度等处理。

➢需求分析:1.功能(1)用尾插法创建一带头结点的由6个节点组成的单向链表:从键盘读入一组整数,作为单链表中的元素,输入完第6个结点后结束;将创建好的单链表元素依次输出到屏幕上。

(2)显示链表中每个节点的数据(3)从键盘输入一个数,查找在以上创建的单链表中是否存在该数;如果存在,显示它的位置,即第几个元素;如果不存在,给出相应提示如“No found node!”。

(4)在上述的单链表中的指定位置插入指定数据,并输出单链表中所有数据。

(5)删除上述单链表中指定位置的结点,并输出单链表中所有数据。

(6)求单链表的长度并输出.2.输入要求先输入单链表中结点个数n,再输入单链表中所有数据,在单链表中需查找的数据,需插入的数据元素的位置、值,要删除的数据元素的位置。

3。

测试数据单链表中所有数据:12,23,56,21,8,10在单链表中需查找的数据:56;24插入的数据元素的位置、值:1,28;7,28;0,28要删除的数据元素的位置:6➢概要设计:1.算法思想:由于在操作过程中要进行插入、删除等操作,为运算方便,选用带头结点的单链表作数据元素的存储结构.对每个数据元素,由一个数据域和一个指针域组成,数据域放输入的数据值,指针域指向下一个结点。

2.数据结构:单链表结点类型:typedef struct Liistnode {int data;struct Listnode *next;}NODE;3.模块划分:a)用尾插法建立带头结点的单链表*CreateList函数;b)显示链表中每个结点的数据PrintList函数;c)从键盘输入一个数,查找单链表中是否存在该数FoundList函数;d)在单链表中指定位置插入指定数据并输出单链表中所有数据InsertList函数;e)删除单链表中指定位置的结点并输出单链表中所有数据DeleteList函数;f)计算单链表的长度并在屏幕上输出LengthList函数;g)主函数main(),功能是给出测试数据值,建立测试数据值的带头结点的单链表,调用PrintList函数、FoundList函数、InsertList函数、DeleteList函数、LengthList函数实现问题要求。

单链表的基本操作

单链表的基本操作

实验二:单链表的基本操作编写一个完整的程序,实现单链表的建立、插入、删除、输出等基本操作。

(1)建立一个带头结点的单链表。

(2)计算单链表的长度,然后输出单链表。

(3)查找值为x的直接前驱结点q。

(4)删除值为x的结点。

(5)把单向链表中元素逆置(不允许申请新的结点空间)。

(6)已知单链表中元素递增有序,请写出一个高效的算法,删除表中所有值大于mink且小于maxk的元素(若表中存在这样的元素),同时释放被删结点空间,并分析你的算法的时间复杂度(注意:mink和maxk是给定的两个参变量,他们的值可以和表中的元素相同,也可以不同)。

(7)同(6)的条件,试写一高效的算法,删除表中所有值相同的多余元素(使得操作后的线性表中所有元素的值均不相同),同时释放被删结点空间,并分析你的算法时间复杂度。

(8)利用(1)建立的链表,实现将其分解成两个链表,其中一个全部为奇数,另一个全部为偶数(尽量利用已知的存储空间)。

(9)在主函数中设计一个简单的菜单,分别测试上述算法。

# include <stdio.h># include <stdlib.h>typedef struct node{int data;struct node * next;}Lnode, * LinkList;int m=sizeof(Lnode);//建立新的链表void Bulid_List(LinkList root){int num;LinkList s,p;s=root->next;int n;printf("请输入新建链表的长度n数据:\n"); scanf("%d",&n);printf("请依次建立链表:");for(int i=0;i<n;i++){scanf("%d",&num);s->data=num;p=(LinkList)malloc(m);s->next=p;s=p;s->next=NULL;}printf("链表已建立!\n");}//对链表的输出,包括长度和元素void OutPut_list(LinkList root) {int len=0;LinkList s;s=root->next;if(s->next==NULL)printf("单链表无数据,请先新建单链表。

实验二 链式存储结构(一)----单向链表的有关操作

实验二 链式存储结构(一)----单向链表的有关操作
_LinkList2->next = _LinkList1;
}
//建立非递减有序单向链表
LinkList Manual_Create_Ordered_LinkList(int_int)
{
cout<<"采用手动方式建立非递减有序单向链表:"<<endl;
LinkList _LinkList =newLNode();
typedefintElemType;
//节点定义
typedefstructLNode
{
ElemType data;
structLNode *next;
}LNode,*LinkList;
//手动方式创建链表
LinkList Manual_Create_LinkList(intn)
{ cout<<"采用手动方式创建链表:"<<endl;
实验二
姓名
王艳青
学号
520713130135
日期
2009.12.7
实验题目
单向链表的有关操作
实验内容
1.随机产生或键盘输入一组元素,建立一个带头结点的单向链表(无序)。
2.遍历单向链表。
3.把单向链表中元素逆置(不允许申请新的结点空间)。
4.在单向链表中删除所有的偶数元素结点。
5.编写在非递减有序链表中插入一个元素使链表元素仍有序的函数,并利用该函数建立一个非递减有序单向链表。
{cout<<"值没有找到!"<<endl;return;}
else
{ _LinkList1->next = _LinkList2->next;

《数据结构》实验指导实验二单链表的存储及操作

《数据结构》实验指导实验二单链表的存储及操作

《数据结构》实验指导实验二:单链表的存储及操作一、实验目的1、掌握单链表抽象数据类型的定义。

2、掌握单链表的存储实现。

3、掌握单链表的操作算法实现。

4、了解单链表的应用。

二、实验学时2学时三、实验类型验证性实验四、实验需求1、硬件每位学生配备计算机一台;2、软件Windows XP/ Windows 7 操作系统;开发工具软件:Microsoft Visual Studio 2010。

五、实验理论与预备知识1、数据结构的基本概念2、顺序存储结构的特点3、线性表的特点和基本运算4、线性表顺序存储结构下的操作算法六、实验任务1、单链表抽象数据类型的代码实现2、编写应用程序,用相关数据验证运算算法七、实验内容及步骤1、任务一:有一个单链表对象L,设计一个算法查找最后一个值为x 的结点的逻辑序号。

并分析算法的时间和空间复杂度。

实验步骤: (1)启动Visual Studio 2010,创立窗体应用程序。

(2) 增加单链表类,代码参考如下:public class LinkList(public string data; public LinkList next;}; class LinkListClasspublic LinkList head = new LinkList();〃单链表头结点//-单链表的基本运算算法public void CrcatcListF(string[] split) 〃头插法建立单链表 {LinkList s;int i;=null;〃将头结点的next 字段置为null for (i = 0; i < h; i++)〃循环建立数据结点{s = new LinkList();s.data = split[i];〃创立数据结点ss.next =; 〃将s 结点插入到开始结点之HU,头结点之后public void CrcatcListR(string[] split) 〃尾插法建立单链表{LinkList s, r;int i;r = head;//r 始终指向尾结点,开始时指向头结点for (i = 0; i < h; i++) 〃循环建立数据结点{s = new LinkList();s.data = splitfi];〃创立数据结点s r.next = s;〃将s 结点插入r 结点之后r.next = null;〃将尾结点的next 字段置为null〃定义单链表结点类〃存放数据元素//指向下一个结点的字段string str = LinkList p; P =;//p 指向开始结点if (p == null) str ="空串"; while (p != null)//p 不为null,输出p 结点的data 字段str += p.data + " p =p.next; 〃p 移向下一个结点 return sir;1public int ListLength() 〃求单链表数据结点个数int n = 0;LinkList p; p = head; //p 指向头结点,n 置为0(即头结点的序号为0)while (p.next != null) (n++;p = p.next; }return (n);〃循环结束,p 指向尾结点,其序号n 为结点个数public bool GetElem(int i, ref string e) 〃求单链表中某个数据元素值 {intj = O;LinkList p;p = head; while (j < i && p != null) //p 指向头结点,j 置为0(即头结点的序号为0) 〃找第i 个结点pj++; p = p.next;}if (p == null) return false; 〃不存在第i 个数据结点,返回falseelse//存在第i 个数据结点,返回true c = p.data; return true;public int LocateElcm(string c)int i= 1;LinkList p;p = ;〃p 指向开始结点,i 置为1(即开始结点的序号为1)while (p != null && p.data != e) 〃查找data 值为e 的结点,其序号为i {p = p.next; i++; }if (p == null)//不存在元素值为e 的结点,返回0return (0);public stringDispList()〃将单链表所有结点值构成一个字符串返同//按元素值查找else〃存在元素值为e的结点,返回其逻辑序号ireturn (i);} _public bool Listlnsert(int i, string e) //插入数据元素{ int j = 0;LinkList s, p;if(i< 1)//i<l 时i 错误,返回falsereturn false;p = head;//p指向头结点,j置为0(即头结点的序号为0) while (j < i - 1 && p != null)〃查找第i-1 个结点{j++;p = p.next;}if(p ==null)〃未找到第i-l个结点,返回falsereturn false;else〃找到第i-l个结点p,插入新结点并返回true(s = new LinkList();s.data = e;〃创立新结点s,其data字段置为es.ncxt = p.next;〃将s结点插入到p结点之后p.next = s;return true;}}public bool ListDele(e(inl i, ref string e) 〃删除数据元素{ int j = 0;LinkList q, p;if (i < 1)〃ivl 时i 错误,返回falsereturn false;p = head;//p指向头结点j置为0(即头结点的序号为0) while (j < i - 1 && p != null)//查找第i-l 个结点j++;public int Findlast(LinkListClass L. stringx)LinkList p = L.; inti = O,j = i; while (p != null)i++;if (p.data == x) j = i ;p = p.next; return j;}(3)设计窗体,界面参考如下:p =p.ncxt;if (p == null) return false; else 〃未找到第i-1个结点,返回fa lse〃找到第i-1个结点p q = p.next; if (q == null) return false; c = q.data; p.next= q.next;q = null; return true; 〃q 指向第i 个结点〃假设不存在第i 个结点,返回false〃从单链表中删除q 结点〃释放q 结点〃返回(rue 表示成功删除第i 个结点(4) 编写窗体中按钮等控件的代码,调用单链表类,参考如下:LinkListClass L = new LinkListClassO;private〃单链表Lvoid Forml_Load(object sender, Event Args e)(=”2,3,1,5,6,2,3,8”;}private void buttonl_Click(object sender, Event Args e)(string str = .Trini();if (str ===”操作提示:必须输入元素”;else{string[] split = (new Char[] {'});L.CreateListR(split);ed = false;ed = true;=”操作提示:成功创立单链表”;}}private void button2_Click(object sender, Event Args e)(int i;string elem;elem =;i = L.Findlast(L, elem);if(i == 0)=”操作提示:在单链表中没有找到该元素”;else=i.ToStringO;=”操作提示:在单链表中找到该元素”;(5)选择【调试】—►【开始执行(不调试)】命令或按【CtH+F5】组合键运行程序,并观察运行情况。

实验二:单链表基本运算实现

实验二:单链表基本运算实现
typedef struct node
{
int data; //存放表结点值
struct node *next; //存放表结点的直接后驱元素的地址
} ListNode,*LinkList;
//头插法创建初始链表
LinkList create_h(int size)
{
;//将工作指针p指向后一个结点
;//计数器累加
}
return i;
}
//打印链表中的现有元素
printList(LinkList head)
{
LinkList p;
;//将工作指针p指向第1个结点
{
p=(LinkList)malloc(sizeof(ListNode));//申请新结点的存储空间
scanf("%d",&p->data);//读入新结点的值到data域中
;//将新增结点插到头结点的后面
;//将新增结点插到头结点的后面
printf("————头插法建立链表(1)\n");
printf("————尾插法建立链表(2)\n");
printf("————按位查找元素(3)\n");
printf("————按值查找元素(4)\n");
printf("————插入元素(5)\n");
printf("————删除元素(6)\n");
printList(h);
break;
case 5:
printf("插入元素,请输入要插入元素的值:\n");

实验二(链表的操作)

实验二(链表的操作)

程序:#include<stdio.h>#include<malloc.h>#include<stdlib.h>#include<iostream>usingnamespace std;typedefstruct LNode //链表结点{int data;struct LNode *next;}LNode,*LinkList;int over_flag=0;void create(LinkList &L);void chazhao(LinkList L);void charu(LinkList &L);int lengthList(LinkList L);void shanchu(LinkList &L);void shanchu1(LinkList &L);void shanchu2(LinkList &L);void zhuanhua(LinkList &L);void fenjie(LinkList &L);int lengthList(LinkList L){int i=0;LinkList p=L->next;while(p){p=p->next;i++;}return i;}void create(LinkList &L){int i,n,temp;printf("\n请输入链表的结点数量:");scanf("%d",&n);L = (LinkList)malloc(sizeof(LNode));L->next = NULL;LinkList q=L;printf("创建链表:\n请输入创建链表所需的整数值:\n"); for(i=1;i<=n;i++){scanf("%d",&temp);LinkList p;p = (LinkList)malloc(sizeof(LNode));p->data = temp;p->next = NULL;q->next = p;q = q->next;}printf("所建立的单链表为:\n");LinkList p=L->next;for(i=1;i<=n;i++){printf("%d ",p->data);p=p->next;}}void chazhao(LinkList L){ if(!L)printf("错误:链表未创建!");int element;printf("查询数值:\n输入要查询的数值:");scanf("%d",&element);LinkList p=L->next;int i =1;while(p){if(p->data==element){printf("找到了,它是链表的第%d个元素。

实验二 单链表操作

实验二 单链表操作

注意事项:在磁盘上创建一个目录,专门用于存储数据结构实验的程序。

因为机房机器有还原卡,请同学们将文件夹建立在最后一个盘中,以学号为文件夹名。

实验二单链表操作一、实验目的掌握单链表的基本操作:插入、删除、查找等运算。

二、实验要求1.认真阅读和掌握单链表相关操作的算法。

2.将操作函数的算法转成程序并运行(将函数剩余部分补齐)。

三、实验内容程序1:线性单链表基本操作的实现(以带头结点的单链表为例)实现单链表的创建、插入、删除和查找。

参考程序如下:#include<iostream.h>#include<malloc.h>#include<conio.h>#define ERROR 0#define OK 1typedef int ElemType;struct LNODE{ElemType data;struct LNODE *next;};typedef struct LNODE LNode;typedef struct LNODE *LinkList;//初始化单链表int init(LinkList &L){L=(LNode *)malloc(sizeof(LNode));if(!L) return(ERROR);L->next=NULL;return OK;}/*init *///求表长int ListLength(LinkList L){}//获取表中第i个元素的值int GetElem(LinkList L,int i,ElemType &e) {}//确定元素e在该链表中的位序int LocateElem(LinkList La,ElemType e){LinkList p;p=La;int i=0;while(p->next){p=p->next;i++;if(p->data==e)return i;}return 0;}//打印表中元素值void PrintList(LinkList L){LinkList p;p=L;while(p->next){p=p->next;cout<<p->data<<ends;}cout<<endl;}//插入操作int ListInsert(LinkList &L,int i,ElemType e) {}/*ListInsert Before i *///删除操作Int ListDelete(LinkList &L,int i,ElemType &e) {}//建表(头插法或尾插法都可)int CreateList(LinkList &L,int n){}//合并两个有序表void MergeList(LinkList La,LinkList Lb,LinkList &Lc){}void main(){LinkList La,Lb,Lc;ElemType e;cout<<"\n\n-------------------List Demo is running...----------------\n\n";cout<<"First is InsertList function.\n";init(La);int n;cout<<"请输入La表中元素个数:";cin>>n;cout<<endl<<"请输入"<<n<<"个元素值:";CreateList(La,n);PrintList(La);cout<<"La的表长为:"<<ListLength(La)<<endl;//取值cout<<"取第i位元素的值:\n请输入位序:";cin>>n;GetElem(La,n,e);cout<<endl<<"第"<<n<<"位元素的值为:"<<e<<endl;//定位cout<<"定位操作:\n请输入要查找的元素:";cin>>e;cout<<endl<<" 所要查找的元素在表中第"<<LocateElem(La,e)<<"位\n"; //删除cout<<"删除操作:\n输入要删除元素的位序:";cin>>n;ListDelete(La,n,e);cout<<"\n要删除的元素值为:"<<e<<endl;cout<<"删除后表中值有:"PrintList(La);init(Lb);cout<<"请输入Lb表中元素个数:";cin>>n;cout<<endl<<"请输入"<<n<<"个元素值:";CreateList(Lb,n);PrintList(Lb);cout<<"Lb的表长为:"<<ListLength(Lb)<<endl; cout<<"合并两个有序表:\n";MergeList(La,Lb,Lc);PrintList(Lc);getch();}。

数据结构 实验二:单链表的基本操作

数据结构 实验二:单链表的基本操作

数据结构实验二:单链表的基本操作数据结构实验二:单链表的基本操作实验二:单链表的基本操作一、【实验目的】1、理解和掌握单链表的类型定义方法和结点生成方法。

2、掌握建立单链表和显示单链表元素的算法。

3、掌握单链表的查找、插入和删除算法二、【实验内容】1、建立一个整形数的单链表,手动输入10个数,并从屏幕显示单链表元素列表。

2、从键盘输入一个数,查找在以上创建的单链表中是否存在该数;如果存在,显示它的位置;如果不存在,给出相应提示。

3、删除上述单链表中指定位置的元素。

以下就是程序部分代码,恳请调试并补足并使之恰当运转:1.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.掌握握单链表的基本操作:插入、删除、查找等运算。

二、实验要求1.认真阅读和掌握本实验的程序。

2.上机运行本程序。

3.保存和打印出程序的运行结果,并结合程序进行分析。

4.按照你对单链表的操作需要,重新改写主程序并运行,打印出文件清单和运行结果三、实验内容单链表基本操作的实现四、实验步骤1、定义单链表的结构typedef struct Lnode{int *base;int *top;int stacksize;} *LinkList;2、定义单链表的几个常用操作:单链表的创建、插入、删除和查找。

void CreateList_L(LinkList &L,int n){L=(LinkList)malloc(sizeof(LNode));L->next=NULL;LNode *p;printf("请输入%d个元素\n",n);for(int i=n;i>0;--i){p=(LinkList)malloc(sizeof(LNode));scanf("%d",&p->data);p->next=L->next;L->next=p;}}单链表插入,删除和查找int ListInsert_L(LinkList &L,int i,int e){//找到第i-1个元素,让p指向它LNode *p=L;int j=0;while(p&&j<i-1){p=p->next;j++;}//没有找到的情况,i<1或者i>表长if(!p||j>i-1)return -1;//为新结点申请内存LNode *s=(LinkList)malloc(sizeof(LNode));s->data=e;//插入新结点s->next=p->next;p->next=s;return 1;}3、编写主函数测试单链表的操作void main(){LinkList L;int length;printf("输入你要创建单链表的长度\n");scanf("%d",&length);CreateList_L(L,length);Output(L);length=Listlen(L);printf("单链表的长度是:%d\n",length);int i;ElemType element;printf("输入你要查找的元素的位置:\n");scanf("%d",&i);GetElem_L(L,i,element);printf("第%d个元素的值是: ",i);printf(" %d\n",element);printf("输入你要插入的元素的位置:\n");scanf("%d",&i);printf("输入你要插入的元素的值:\n");scanf("%d",&element);ListInsert_L(L,i,element);printf("插入后的线性表是: ");Output(L);printf("输入你要删除的元素的位置:\n");scanf("%d",&i);ListDelete_L(L,i,element);printf("删除后的线性表是: ");Output(L);五、实验总结:附录:完整程序#include<malloc.h>#include <stdio.h>typedef int ElemType; //定义数据元素的类型为int,你也可以在这里把它改成其它数据类型//单链表结点的定义typedef struct LNode{int *base;int *top;int stacksize;} *LinkList;/*创建单链表*****************************************/void CreateList_L(LinkList &L,int n){L=(LinkList)malloc(sizeof(LNode));L->next=NULL;LNode *p;printf("请输入%d个元素\n",n);for(int i=n;i>0;--i){p=(LinkList)malloc(sizeof(LNode));scanf("%d",&p->data);p->next=L->next;L->next=p;}}/*输出单链表*****************************************/void Output(LinkList &L){//……//部分代码printf("开始输出单链表各个元素\n");//……printf("\n单链表结束!\n");}/*单链表的长度*****************************************/int Listlen(LinkList &L){//1、分配内存L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L.elem)//申请内存失败的情况exit(OVERFLOW);L.length=0; //线性表的长度L.listsize=LIST_INIT_SIZE;//线性表L的容量return OK;}/*得到单链表中第i个元素的值*****************************************/ int GetElem_L(LinkList &L,int i,ElemType &e){}/*删除第i个元素*****************************************/int ListDelete_L(LinkList &L,int i,ElemType &e)/*在第i个位置上插入一个新的元素*****************************************/int ListInsert_L(LinkList &L,int i,ElemType e){//1、判断插入位置i是不是正确if(i<1||i>L.length+1)return ERROR;//2、判断线性表的存储空间是否已满if(L.length>=L.listsize){//满则追加内存ElemType *newbase=(ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType) );//判断申请内存是否成功if(!newbase)//申请失败exit(OVERFLOW);//申请成功L.elem=newbase;L.listsize+=LISTINCREMENT;}//从第n个元素至第i个元素依次向后移动一个位置ElemType * q= &(L.elem[i-1]);//用q保存第i个元素的地址ElemType *p=&(L.elem[L.length-1]);//用p保存第n个元素的地址for( ;p>=q;--p){*(p+1)=*p;}*q=e;//将q插入到第i个位置++L.length;return OK;}/******************************************/void main(){LinkList L;int length;printf("输入你要创建单链表的长度\n");scanf("%d",&length);CreateList_L(L,length);Output(L);length=Listlen(L);printf("单链表的长度是:%d\n",length);int i;ElemType element;printf("输入你要查找的元素的位置:\n");scanf("%d",&i);GetElem_L(L,i,element);printf("第%d个元素的值是: ",i);printf(" %d\n",element);printf("输入你要插入的元素的位置:\n");scanf("%d",&i);printf("输入你要插入的元素的值:\n");scanf("%d",&element);ListInsert_L(L,i,element);printf("插入后的线性表是: ");Output(L);printf("输入你要删除的元素的位置:\n");scanf("%d",&i);ListDelete_L(L,i,element);printf("删除后的线性表是: ");Output(L);}。

实验二 单链表的逆转

实验二 单链表的逆转

实验二单链表的逆转一、实验要求逆转一个单链表二、数据结构使用了单向链表,链表的节点都使用的是结构体。

三、算法描述1、定义一个结构体struct node{int data;node *next;};定义一个名为node的结构体,为了简便起见,结构体中只包含一个int型数据和指针。

定义四个函数:node *Input() //数据录入函数void Output(node *head) //数据输出函数void Delete(node *h) //节点删除函数node *Reverse(node *head) //链表逆序函数2、建立一条无序链表node *Input():使用三个指针 p1、p2、head,head指向第一个节点,p2为最后一个节点,p1为新节点。

每次操作时使p2->next=p1,p2=p1。

当输入为-1时使p2->next=0。

由此链表建立完成。

返回新建链表的头指针。

3、单链表的逆转总的思想:1)首先,使p1、p、p2依次指向head开始的前三个node,然后使p1赋给p->next,由此实现了p1和p的逆转;2)再将三个指针依次向后移一个node。

p1的下一个是p,p的下一个是p2,p2的下一个是p2->next;3)重复步骤2和3直至p2->next==nil,node* Reverse(node *head){node *p1,*p,*p2;p1=head;p=p1->next;p1->next=0; //使用3个指针,p1、p和p2。

令p1->next=0if(p->next!=0){p2=p->next; //使p1、p、p2依次指向head开始的前三个nodewhile(p2->next!=0){p->next=p1; //p->next,由此实现了p1和p的逆转p1=p;p=p2;p2=p2->next; //将三个指针依次向后移一个node}p->next=p1; //当p2->next==nil,完成单链表的逆转,只需再将最后两个节点p、p2的指针再分别指向p1、p即可p2->next=p;return p2;}else{p->next=p1;return p;}}四、测试数据输入数据产生无序链表,以-1结束1378-1链表上各结点的数据:1 3 7 8逆转后链表上各结点的数据:8 7 3 1输入四个数据,成功实现逆转。

实验二 链表的基本操作

实验二 链表的基本操作

实验二链表的基本操作链表是一种常见的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。

链表的基本操作包括插入、删除和查找节点,这些操作在实际编程中非常常见且重要。

我们来看链表的插入操作。

链表的插入操作可以将新节点插入到链表的任意位置,包括链表的头部、尾部或者中间位置。

插入操作的具体步骤如下:1. 创建一个新节点,并为新节点赋值。

2. 将新节点的指针指向原链表中要插入位置的前一个节点。

3. 将原链表中要插入位置的前一个节点的指针指向新节点。

4. 将新节点的指针指向原链表中要插入位置的后一个节点。

接下来是链表的删除操作。

链表的删除操作可以删除链表中的任意节点,包括链表的头部、尾部或者中间位置。

删除操作的具体步骤如下:1. 找到要删除的节点的前一个节点。

2. 将要删除的节点的前一个节点的指针指向要删除的节点的下一个节点。

3. 释放要删除的节点的内存空间。

最后是链表的查找操作。

链表的查找操作可以根据节点的值或者位置来查找节点。

查找操作的具体步骤如下:1. 遍历链表,依次比较节点的值或者位置,直到找到目标节点。

2. 返回目标节点的值或者位置。

除了基本的插入、删除和查找操作,链表还有一些其他的操作,如获取链表的长度、反转链表等。

获取链表的长度可以通过遍历链表并计数节点的数量来实现。

反转链表可以通过修改节点的指针的指向来实现,具体步骤如下:1. 遍历链表,依次修改每个节点的指针的指向,将指针指向上一个节点。

2. 最后将头节点的指针指向空。

链表的基本操作在实际编程中非常常见且重要。

它们可以用于实现各种功能和算法,如链表的排序、合并两个链表等。

在使用链表的过程中,我们需要注意链表为空或者操作位置无效的情况,以避免出现错误。

链表是一种常见的数据结构,具有灵活性和高效性。

了解链表的基本操作对于编程非常重要,它们可以帮助我们实现各种功能和算法。

通过学习和掌握链表的基本操作,我们可以更好地应用链表来解决实际问题。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验二单向链表的基本操作
一.实验目的
(1)掌握线性表链式存储的方法及其基本操作
(2)掌握将算法在VC++语言环境下实现的过程
二.实验准备
(1)复习线性表的定义,掌握链式存储的方法及操作
(2)复习C语言中指针及结构体的概念。

定义方式
(3)V C++的编程环境
三.实验内容28,20,12,9,7,5,4,3,1
在你自己的文件下,建立一个C语言程序LL.C,完成下列要求:(1)定义一个单链表LLIST,按数据1,3,4,5,7,9,12,20,28的次序建立各结点,形成单链表LLIST,然后按链表顺序输出九个结点的
存储单元地址和相应的数值;
(2)建立一个插入函数,将数据15作为结点按照从小到大的次序自动插入到链表的相应位置上,完成插入结点的操作,形成新的
链表LLIST,然后输出链表结点的存储单元地址和相应的数值;(3)建立一个删除函数,将链表中第七个结点删除,形成新的链表LLIST,然后输出链表结点的存储单元地址和相应的数值;
程序清单如下:
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#define NULL 0
typedef struct node {
int data;
sttuct node *next;
} llist;
main()
{
llist *h, *crtll(),*insll(), *dltll(); outll();
h=NULL;
h=crtll(h);
outll(h);
h=insll(h);
outll(h);
h=dltll(h);
outll(h);
}
llist *crtll( llist *h)
}
void outll(llist *h)
{
llist *y, *p;
int i=1;
y=h;
while (y!=NULL)
{
printf(“N=%d AD=%x DATA=%d AD->=%x\n”, i, y, y->data, y->next);
y=y->next; i++;
}
}
llist *insll(llist *h)
{
}
llist *dltll(llist *h)
{
#include "stdafx.h"
#include<stdio.h>
#include"stdlib.h"
typedef struct Lnode
{
int data;
struct Lnode *next;
}Lnode,*Link;
void create_list(Link &L)
{
Link p,current;
int a[ ]={28,20,12,9,7,5,4,3,1},j=8;
L=(Link)malloc(sizeof(Lnode));
L->next=NULL;
current=L;
while(j>=0)
{
p=(Link)malloc(sizeof(Lnode));
p->data=a[j];
current->next=p;
current = p;
j--;
}
p->next=NULL;
}
void printf_list(Link head)
{
Link p;
p=head->next;
while(p!=NULL)
{
printf("%d=",p);
printf("%d\n",p->data);
p=p->next;
}
}
void insert(Link &L)
{
int a=0;
int n;
Link current,p,q;
q=(Link)malloc(sizeof(Lnode));
printf("输入一个插入的数\n");
scanf("%d",&n);
q->data=n;
p=L;
current=L->next;
while((current!=NULL)&&a==0) {
if(q->data<current->data)a=1;
else
{
p=p->next;
current=current->next;
}
}
p->next=q;
q->next=current;
}
void Delete(Link &L)
{
int n;
printf("输入一个删除的数\n");
scanf("%d",&n);
Link current,p;
p=L;
current=L->next;
while(n!=current->data)
{
p=p->next;
current=current->next;
}
p->next=current->next;
free(current);
}
void main()
{
Link head;
create_list(head);
printf_list(head);
insert(head);
printf_list(head);
Delete(head);
printf_list(head);
}
#include "stdafx.h"
#include<stdio.h>
#include"stdlib.h"
typedef struct Lnode
{
int data;
struct Lnode *next;
}Lnode,*Link;
void create_list(Link &L)
{
Link p,current;
int a[ ]={28,20,12,9,7,5,4,3,1},j=8;
L=(Link)malloc(sizeof(Lnode));
L->next=NULL;
current=L;
while(j>=0)
{
p=(Link)malloc(sizeof(Lnode));
p->data=a[j];
current->next=p;
current = p;
j--;
p->next=NULL;
}
void printf_list(Link head)
{
Link p;
p=head->next;
while(p!=NULL)
{
printf("%d=",p);
printf("%d\n",p->data);
p=p->next;
}
}
void insert(Link &L)
{
int a=0;
int n;
Link current,p,q;
q=(Link)malloc(sizeof(Lnode));
printf("输入一个插入的数\n");
scanf("%d",&n);
q->data=n;
p=L;
current=L->next;
while((current!=NULL)&&a==0) {
if(q->data<current->data)a=1;
else
{
p=p->next;
current=current->next;
}
}
p->next=q;
q->next=current;
}
void Delete(Link &L)
{
int n;
printf("输入一个要删除的数的位置\n");
scanf("%d",&n);
Link current,p;
p=L;
current=L->next;
for(int i=1;i<n;i++)
{
p=p->next;
current=current->next;
}
p->next=current->next;
free(current);
}
void main()
{
Link head;
create_list(head);
printf_list(head);
insert(head);
printf_list(head);
Delete(head);
printf_list(head);
}。

相关文档
最新文档