实验2 单链表的操作及其应用

合集下载

实验2 链表基本操作

实验2  链表基本操作

实验2 链表基本操作一、实验目的1.定义单链表的结点类型。

2.熟悉对单链表的一些基本操作和具体的函数定义。

3.通过单链表的定义掌握线性表的链式存储结构的特点。

4.掌握循环链表和双链表的定义和构造方法。

二、实验内容该程序的功能是实现单链表的定义和操作。

该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。

程序中的单链表(带头结点)结点为结构类型,结点值为整型。

/* 定义DataType为int类型 */typedef int DataType;/* 单链表的结点类型 */typedef struct LNode{DataType data;struct Lnode *next;}Lnode,*LinkedList;/* 初始化单链表 */LinkedList LinkedListInit()/* 清空单链表 */void LinkedListClear(LinkedList L)/* 检查单链表是否为空 */int LinkedListEmpty(LinkedList L)/* 遍历单链表 */void LinkedListTraverse(LinkedList L)/* 求单链表的长度 */int LinkedListLength(LinkedList L)/* 从单链表表中查找元素 */LinkedList LinkedListGet(LinkedList L,int i)/* 从单链表表中查找与给定元素值相同的元素在链表中的位置 */ LinkedList LinkedListLocate(LinkedList L, DataType x)/* 向单链表中插入元素 */void LinkedListInsert(LinkedList L,int i,DataType x)/* 从单链表中删除元素 */void LinkedListDel(LinkedList L,DataType x)/* 用尾插法建立单链表 */LinkedList LinkedListCreat( )//---------------------程序示例---------------------//#include<stdlib.h>#include<stdio.h>/* 定义ElemType为int类型 */typedef int ElemType;#define TRUE 1#define FALSE 0#define flag -1/* 单链表的结点类型 */typedef struct LNode{ElemType data;struct LNode *next;} LNode,*LinkedList;/* 初始化单链表 */LinkedList LinkedListInit(){LinkedList L;L=(LinkedList)malloc(sizeof(LNode));L->next=NULL;printf("成功初始化链表\n");return L;}/* 清空单链表 */void LinkedListClear(LinkedList L){L->next=NULL;}/* 检查单链表是否为空 */int LinkedListEmpty(LinkedList L){if (L->next==NULL) return TRUE;else return FALSE;}/* 遍历单链表 */void LinkedListTraverse(LinkedList L){LinkedList p;p=L->next;while (p!=NULL){printf("%d ",p->data);p=p->next;}}//求链表长度int LinkedListLength (LinkedList L){LinkedList p;int j;p=L->next;j=0;while (p!=NULL){j++;p=p->next;}return j;}//LinkedList LinkedListGet (LinkedList L, int i){LinkedList p;int j;p=L->next;j=1;while (p!=NULL && j<i ){p=p->next;j++;}if (j==i) return p;else return NULL;}LinkedList LinkedListLocate ( LinkedList L, ElemType x) {LinkedList p;p=L->next;while ( p!=NULL && p->data != x)return p;}void LinkedListInsert(LinkedList L, int i, ElemType x) {LinkedList pre,p,s;int j;pre=L;j=1;p=L->next;while (pre&&j<i){pre=p;p=p->next;j++;}if (pre==NULL){printf("给的i值超过了表长");exit(0);}s=(LNode *)malloc(sizeof(LNode));s->data=x;pre->next=s;s->next=p;}void LinkedListDel (LinkedList L,ElemType x){LinkedList pre,p;int j;pre=L;j=1;p=L->next;while (p&&p->data!=x){pre=p;p=p->next;j++;}if (p==NULL){printf("表中没有值为x的结点");}pre->next=p->next;free(p);}LinkedList LinkedListCreat( ){LinkedList L=LinkedListInit(),p,r;ElemType x;r=L;printf("please input data,input -1 is end\n");scanf("%d",&x);while (x!=flag){p=(LinkedList)malloc(sizeof(LNode));p->data=x;r->next=p;r=p;scanf("%d",&x);}r->next=NULL;return L;}int main1(){int quit=0;int i;ElemType e;LinkedList L;while (!quit){int d;printf("please input the operation\n");printf("1.初始化链表 2.清空链表3.求链表长度4.检查链表是否为空\n"); printf("5.遍历链表 6.从链表中查找元素\n");printf("7.从链表中查找与给定元素值相同的元素在顺序表中的位置\n"); printf("8.向链表中插入元素9. 从链表中删除元素10.创建一个单链表\n"); printf("其他键退出。

实验报告2(单链表)

实验报告2(单链表)
设计分析:
1、定义结点指针类型:结点包括两个域,即数据域(用来存储结点的值)和指针域(用来存储数据元素的直接后继的地址)。
2、链表的创建(1)头插入法:从一个空表开始,每次读入数据,生成新结点,将读入数据存放到新结点的数据域中,然后将新结点插入到当前链表的表头结点之后,直到读入结束标志为止;(2)尾插入法:将新结点依次插到当前单链表的表尾上;
printf("|[2]尾部插入|\n");
printf("|[3]输出链表|\n");
printf("|[4]序号查找|\n");
printf("|[5]按值查找|\n");
printf("|[6]插入结点|\n");
printf("|[7]删除结点|\n");
printf("|[8]链表长度|\n");
{
Node *r,*s;
int c=0,flag;
r=L;
printf("请顺序输入一串数字,以负数结束:");
while(flag)
{
scanf("%d",&c);
if(c>-1)
{
}
void output(LinkList L)//链表输出
{
Node *p;
p=L->next;
printf("Head->");
{
Node *p;
p=L;
int j=0;
if(p->next ==NULL)
printf("NULL!");
while(p!=NULL)

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

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

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

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

三、实验要求
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. 编译运行程序,观察运行情况和输出结果。

实验二 单链表基本操作

实验二  单链表基本操作

实验二单链表基本操作一、实验目的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);}}。

实验报告二——单链表

实验报告二——单链表
三、源程序及注释:
#include <stdio.h>
#include <stdlib.h>
//单链表的定义:
typedef int DataType;//DataType可以是任何相应的数据类型如int, float或char
typedef struct node//结点类型定义
{DataType data;//结点的数据域
struct node *next;//结点的指针域
}ListNode;
typedef ListNode *LinkList;
int a[10];
void main()
{
int i;
DataType key;
DataType x;
LinkList head;
ListNode *p;
LinkList CreateList(void);//单链表的建立
从键盘输入2个整数一个表示欲插入的位置i另一个表示欲插入的数值x从键盘输入1个整数表示欲删除结点的位巻输出单链表所有结点值观链表中含有原链表中序号为奇数的元链表中含有原链表中序号为偶数的元素且保持原来的相对顺序分别输出单链和单链表b的所有结点值观察输出结果
《数据
实验二—单链表
分校:上海第二工业大学
班级:09安全01
p->next=s;
}
//单链表的删除:
void DeleteList(LinkList head,int i)
{
ListNode *p,*r;
int j;
p=head;j=1;
while(p&&j<i-1)
{
p=p->next;
j++;

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

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

《数据结构》实验指导实验二:单链表的存储及操作一、实验目的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");

实验二 单链表基本操作

实验二单链表基本操作一实验目的1.学会定义单链表的结点类型,实现对单链表的一些基本操作和具体的函数定义,了解并掌握单链表的类定义以及成员函数的定义与调用。

2.掌握单链表基本操作及两个有序表归并、单链表逆置等操作的实现。

二实验要求1.预习C语言中结构体的定义与基本操作方法。

2.对单链表的每个基本操作用单独的函数实现。

3.编写完整程序完成下面的实验内容并上机运行。

4.整理并上交实验报告。

三实验内容1.编写程序完成单链表的下列基本操作:(1)初始化单链表La。

(2)在La中第i个元素之前插入一个新结点。

(3)删除La中的第i个元素结点。

(4)在La中查找某结点并返回其位置。

(5)打印输出La中的结点元素值。

2 .构造两个带有表头结点的有序单链表La、Lb,编写程序实现将La、Lb合并成一个有序单链表Lc。

合并思想是:程序需要3个指针:pa、pb、pc,其中pa,pb分别指向La表与Lb表中当前待比较插入的结点,pc 指向Lc表中当前最后一个结点。

依次扫描La和Lb中的元素,比较当前元素的值,将较小者链接到*pc 之后,如此重复直到La或Lb结束为止,再将另一个链表余下的内容链接到pc所指的结点之后。

3.构造一个单链表L,其头结点指针为head,编写程序实现将L逆置。

(即最后一个结点变成第一个结点,原来倒数第二个结点变成第二个结点,如此等等。

)四思考与提高1.如果上面实验内容2中合并的表内不允许有重复的数据该如何操作?2.如何将一个带头结点的单链表La分解成两个同样结构的单链表Lb,Lc,使得Lb中只含La表中奇数结点,Lc中含有La表的偶数结点?1.编写程序完成单链表的下列基本操作:(1)初始化单链表La。

(2)在La中第i个元素之前插入一个新结点。

(3)删除La中的第i个元素结点。

(4)在La中查找某结点并返回其位置。

(5)打印输出La中的结点元素值。

#include<stdio.h>#include<stdlib.h>#include <malloc.h>#define OK 1#define ERROR 0typedef int Status;typedef int ElemType;//定义存储结构typedef struct Lnode{int data; /*每个元素数据信息*/struct Lnode *next; /*存放后继元素的地址*/} LNode,*LinkList;int main(){void Create_L(LinkList &L,int n);void Print_L(LinkList L);Status ListInsert_L(LinkList &L,int i,ElemType e);Status ListDelete_L(LinkList &L,int i,ElemType &e);Status Find_L(LinkList L,int e);LinkList La;//创建单链表Laint n;printf("请输入链表La中的元素个数:\n");scanf("%d",&n);Create_L(La,n);//初始化单链表printf("现在La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("现在准备插入元素,请输入插入位置及所插入元素的值\n");int i,e;scanf("%d %d",&i,&e);ListInsert_L(La,i,e);printf("插入后La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("现在准备删除元素,请输入删除位置\n");scanf("%d",&i);ListDelete_L(La,i,e);printf("删除后La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("请输入所要查找元素的值:\n");scanf("%d",&e);Find_L(La,e);printf("所要查找元素的位置为:%d\n",Find_L(La,e)); }void Create_L(LinkList &L,int n){int j=1;L=(LinkList)malloc(sizeof(Lnode));L->next =NULL;//先建立一个带头结点的单链线性表L for(int i=n;i>0;--i){LinkList p=(LinkList)malloc(sizeof(Lnode));printf("请输入链表La中的第%d个元素:\n",j++);scanf("%d",&p->data);p->next=L->next;L->next =p;}//(逆序实现)/*LinkList q=L;for(int i=1;i<=n;i++){LinkList p=(LinkList)malloc (sizeof(Lnode));q->next=p;p->next=NULL;q=q->next ;printf("请输入链表La中的第%d个元素:\n",i);scanf("%d",&p->data);}//(正序实现)*/}//初始化单链表//输出单链表void Print_L(LinkList L){LinkList p;p=L->next;while(p){printf("%d ",p->data );p=p->next;}printf("\n");}//在单链表L的第i个位置前插入元素eStatus ListInsert_L(LinkList &L,int i,ElemType e) {LinkList p=L;int j=0;while(p&&j<i-1){p=p->next; ++j;}if(!p||j>i-1) return ERROR;LinkList s=(LinkList)malloc(sizeof(LNode));s->data=e; s->next=p->next;p->next=s;return OK;} //ListInsert_L//删除单链表L中第i个位置上的元素Status ListDelete_L(LinkList &L,int i,ElemType &e) {LinkList p=L;int j=0;while( p->next && j<i-1){p=p->next; ++j;}if(!p->next||j>i-1) return ERROR;LinkList q=p->next; p->next=q->next;e=q->data;free(q);return OK;}//LinkDelete_L/*查找元素并返回位置*/Status Find_L(LinkList L,int e){LinkList p=L->next;int j=1;while(p->data!=e&&p->next){p=p->next;j++;}if(p->data==e) return j;else{printf("无当前元素\n");return ERROR;}if(!p){printf("无当前元素\n");return ERROR;}}//定位2 .构造两个带有表头结点的有序单链表La、Lb,编写程序实现将La、Lb合并成一个有序单链表Lc。

实验二 链表的基本操作

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

链表的基本操作包括插入、删除和查找等。

本文将围绕链表的基本操作展开讲解,并以此为标题展开内容。

一、链表的插入操作链表的插入操作是指在链表中插入一个新的节点。

插入操作可以分为头插法和尾插法。

1. 头插法:将新节点插入链表的头部,即将新节点的指针指向原链表的头节点,再将链表的头指针指向新节点。

这样可以在常数时间内完成插入操作。

2. 尾插法:将新节点插入链表的尾部,即将原链表的尾节点指针指向新节点,再将新节点的指针指向空。

这样也可以在常数时间内完成插入操作。

二、链表的删除操作链表的删除操作是指删除链表中的一个节点。

删除操作可以分为删除指定节点和删除指定数值的节点两种情况。

1. 删除指定节点:找到待删除节点的前一个节点,将其指针指向待删除节点的下一个节点,再释放待删除节点的内存空间。

2. 删除指定数值的节点:遍历链表,找到数值匹配的节点并删除,具体操作与删除指定节点类似。

三、链表的查找操作链表的查找操作是指在链表中寻找某个节点或数值。

链表的查找操作与数组的查找操作不同,需要从头节点开始遍历整个链表。

1. 查找指定节点:遍历链表,逐个比较节点的值,直到找到目标节点或遍历到链表末尾。

2. 查找指定数值的节点:同样遍历链表,逐个比较节点的值,直到找到目标数值或遍历到链表末尾。

四、链表的其他操作除了插入、删除和查找操作外,链表还可以进行其他操作,如获取链表长度、反转链表和合并链表等。

1. 获取链表长度:遍历链表,计数节点的个数,即为链表的长度。

2. 反转链表:遍历链表,将每个节点的指针指向前一个节点,最后将链表的头指针指向原链表的尾节点。

3. 合并链表:将两个有序链表合并成一个新的有序链表。

遍历两个链表,逐个比较节点的值,将较小值的节点插入新链表中,直到其中一个链表遍历完毕,然后将另一个链表的剩余部分直接插入新链表的尾部。

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

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

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

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

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

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

以下是程序部分代码,请调试并补充使之正确运行:1.LinList.htypedef struct Node{DataType data;struct Node *next;} SLNode;void ListInitiate(SLNode **head) /*初始化*/{/*如果有内存空间,申请头结点空间并使头指针head指向头结点*/if((*head = (SLNode *)malloc(sizeof(SLNode))) == NULL) exit(1);(*head)->next = NULL; /*置链尾标记NULL */}int ListLength(SLNode *head){SLNode *p = head; /*p指向首元结点*/int size = 0; /*size初始为0*/while(p->next != NULL) /*循环计数*/{p = p->next;size ++;}return size;}int ListInsert(SLNode *head, int i, DataType x)/*在带头结点的单链表head的数据元素ai(0 ≤i ≤size)结点前*//*插入一个存放数据元素x的结点*/{SLNode *p, *q;int j;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("插入位置参数错!");return 0;}/*生成新结点由指针q指示*/if((q = (SLNode *)malloc(sizeof(SLNode))) == NULL) exit(1);q->data = x;q->next = p->next; /*给指针q->next赋值*/p->next = q; /*给指针p->next重新赋值*/return 1;}int ListDelete(SLNode *head, int i, DataType *x)/*删除带头结点的单链表head的数据元素ai(0 ≤i ≤size - 1)结点*/ /*删除结点的数据元素域值由x带回。

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

仲恺农业工程学院实验报告纸
计算机科学与工程学院(院、系)计算机科学与技术专业计机092 班组数据结构课
实验二链表的操作及其应用
一、实验目的
了解单链表的基本概念、结构的定义及在单链表上的基本操作(插入、删除、查找以及线性表合并),通过在Turbo C实现以上操作更好的了解书本上的内容并体会线性表的两种存储结构的区别。

二、实验内容
⑴单链表的插入算法
⑵单链表的删除算法
⑶循环链表的插入和删除算法(选做)
源程序:
#include <conio.h>
#include <dos.h>
#include <stdio.h>
#include <stdlib.h>
#define LEN sizeof(LNode) //定义LEN为一个节点的长度
enum BOOL{False,True}; //定义BOOL型
typedef struct node
{char data; //数据域
struct node *next;//指向下一个节点的指针
}LNode,*LinkList;
void CreatList(LinkList &,int); //生成一个单链表
BOOL ListInsert(LinkList &,int,char); //在单链表中插入一个元素
BOOL ListDelete(LinkList &,int,char &); //在单链表中删除一个元素
void ListPrint(LinkList); //显示单链表所有元素
void main()
{LinkList L;
BOOL temp;
int num,loc,flag=1;
char j,ch;
//---------------------程序解说-----------------------
printf("本程序实现链式结构的线性表的操作。

\n");
printf("可以进行插入,删除等操作。

\n");
//----------------------------------------------------
printf("请输入初始时链表长度:"); //输入生成单链表时的元素个数
scanf("%d",&num);
CreatList(L,num); //生成单链表
ListPrint(L);
while(flag)
{ printf("请选择:\n");
printf("1.显示所有元素\n"); //显示链表元素
printf("2.插入一个元素\n"); //插入链表元素
printf("3.删除一个元素\n"); //删除链表元素
printf("4.退出程序\n"); //退出
scanf(" %c",&j);
switch(j)
{case '1':ListPrint(L); break;
case '2':{printf("请输入元素(一个字符)和要插入的位置:\n");
printf("格式:字符,位置;例如:a,3\n");
scanf(" %c,%d",&ch,&loc); //输入要插入的元素和要插入的位置
temp=ListInsert(L,loc,ch); //插入
if(temp==False) printf("插入失败!\n"); //插入失败
else printf("插入成功!\n"); //成功插入
ListPrint(L);
break;
}
case '3':printf("请输入要删除的元素所在位置:");
scanf("%d",&loc); //输入要删除的节点的位置
temp=ListDelete(L,loc,ch); //删除
if(temp==False) printf("删除失败!\n"); //删除失败
else printf("成功删除了一个元素:%c\n",ch); //删除成功,显示该元素
ListPrint(L);
break;
default:flag=0;printf("程序结束,按任意键退出!\n");
}
}
getch();
}
void CreatList(LinkList &v,int n)
{//生成一个带头结点的有n个元素的单链表
int i;
LinkList p;
v=(LinkList)malloc(LEN); //生成头结点
v->next=NULL;
printf("请输入%d个字符:例如:abcdefg\n",n);
getchar();
for(i=n;i>0;--i)
{p=(LinkList)malloc(LEN); //生成新结点
scanf("%c",&p->data);
p->next=v->next;
v->next=p;
}
}
BOOL ListInsert(LinkList &v,int i,char e)
{//在单链表的第i各位置插入元素e,成功返回True,失败返回False
LinkList p,s;
int j=0;
p=v;
while(p&&j<i-1) {p=p->next;++j;} //查找第i-1个元素的位置
if(!p||j>i-1) return False; //没有找到
s=(LinkList)malloc(LEN); //生成一个新结点
s->data=e;
s->next=p->next; //将新结点插入到单链表中
p->next=s;
return True;
}
BOOL ListDelete(LinkList &v,int i,char &e)
{//在单链表中删除第i个元素,成功删除返回True,并用e返回该元素值,失败返回False
LinkList p,q;
int j=0;
p=v;
while(p->next&&j<i-1) //查找第i-1个元素位置
{p=p->next;++j;}
if(!(p->next)||j>i-1) return False; //查找失败
q=p->next;p->next=q->next; //删除该元素
e=q->data; //e取得该元素值
free(q); //释放该元素空间
return True;
}
void ListPrint(LinkList v)
{//显示链表所有元素
LinkList q;
q=v->next;
printf("链表所有元素:");
while(q!=NULL)
{printf("%c ",q->data);q=q->next;}
printf("\n");
}
运行截图:
主菜单与创建链表:
1.输出链表:
2.插入元素:
3.删除链表:
三、实验总结:
问题:
1.创建链表时,运用前插法,使得最后输出时是反过来输出的;
2.在调用函数ListInsert_L(L,i,e);时忘记写输入e的语句scanf("%d",&e); (就
是要插入的元素),使得在最后输出了一个负数或者说是乱码;
解决方法:1.通过看书和上网学到了尾插法,就是说尾插法的作用是使得最后输出时的数值是按照输入的顺序输出的;
3.第二个问题的解决方法是最后加上了scanf("%d",&e);这个语句,这样才不
会出现乱码,输出如我所愿;
心得体会:通过对实验一的学习后,我对数据结构有了更深刻的认识,使得我在做实验的过程中速度加快了很多,掌握了各种函数的应用,能够更深刻地
了解单链表的操作及其应用。

相关文档
最新文档