数据结构实验二链表

合集下载

链表实验报告

链表实验报告

《数据结构》实验报告二系别:嵌入式系统工程系班级:嵌入式11003班学号:11160400314 姓名:孙立阔日期:2012年4月9日指导教师:申华一、上机实验的问题和要求:单链表的查找、插入与删除。

设计算法,实现线性结构上的单链表的产生以及元素的查找、插入与删除。

具体实现要求:1.从键盘输入10个字符,产生不带表头的单链表,并输入结点值。

2.从键盘输入1个字符,在单链表中查找该结点的位置。

若找到,则显示“找到了”;否则,则显示“找不到”。

3.从键盘输入2个整数,一个表示欲插入的位置i,另一个表示欲插入的数值x,将x插入在对应位置上,输出单链表所有结点值,观察输出结果。

4.从键盘输入1个整数,表示欲删除结点的位置,输出单链表所有结点值,观察输出结果。

5.将单链表中值重复的结点删除,使所得的结果表中个结点值均不相同,输出单链表所有结点值,观察输出结果。

6.删除其中所有数据值为偶数的结点,输出单链表所有结点值,观察输出结果。

7.(★)将单链表分解成两个单链表A和B,使A链表中含有原链表中序号为奇数的元素,而B链表中含有原链表中序号为偶数的元素,且保持原来的相对顺序,分别输出单链表A和单链表B的所有结点值,观察输出结果。

二、程序设计的基本思想,原理和算法描述:(包括程序的结构,数据结构,输入/输出设计,符号名说明等)创建一个空的单链表,实现对单链表的查找,插入,删除的功能。

三、源程序及注释:#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define TRUE 1#define FALSE 0#define List_Init_Size 10#define ListIncrement 2typedef char ET;typedef ET * Ep;typedef int Status;typedef struct LNode{ET data;struct LNode *next;}LNode, *LinkList;/*LinkList La,Lb,Lc;*/#include "stdio.h"#include "alloc.h"/*Display the linklist's elements. */void printlk(LinkList L) {LinkList p;p=L->next;while (p) {printf("%c -> ",p->data);p = p->next;}printf("NULL\n");}/*Creat linklist from head node. */void CreatList( LinkList *L,int n){int i;LinkList p,q;ET str[20],c;p=(LinkList)malloc(sizeof(LNode));p->next=NULL;*L = q = p;printf("Please input the data : ");for (i=n;i>0;i--) {p=(LinkList)malloc(sizeof(LNode));c = getche(); /*scanf("%c",&c);*/printf("\n\n");p->data = c;p->next = q->next;q->next = p;}}/*Init the linklist. */void Init(LinkList *L) {int n;printf("Please input the number of the node : "); scanf("%d",&n);CreatList(L,n);}/* Get the value of element I; */int GetElem(LinkList L,int i,ET *e) {int j=1;LinkList p;p=L->next;while(p&&j<i) {p=p->next;++j;}if(!p||j>i) return TRUE;*e=p->data;return FALSE;}/*Insert a element after I */int ListInsert(LinkList *L,int i,ET e) {/* Add your own codes. */}/*Delete the element I */int ListDelete(LinkList *L,int i,ET *e) {/* Add your own codes. */}int Insert(LinkList *L) {int i,flag;ET data;printf("Please input the position : "); scanf("%d",&i);printf("Please input the data : ");data = getche(); /*scanf("%c",&data);*/ flag = ListInsert(L,i,data);return flag;}Status Delete(LinkList *L) {int i,flag;ET e;printf("Please input the number : "); scanf("%d",&i);flag = ListDelete(L,i,&e);printf("Deleted element is %c\n",e); return flag;}/*Find the element's position. */int LocateElem(LinkList L,ET e) {int i=0;LinkList p;p = L->next;while (p) {i++;if (p->data == e) return i;}return 0;}/*Add the Lb after the La. */void Union( LinkList *La ,LinkList *Lb){LinkList pa,pb;/* Add your own codes. */}/*Merge two sequence into one,don't change any elements in these two link lists. Join two sequence to one. */void MergeList(LinkList *L1,LinkList *L2,LinkList *L3) { LinkList pa,pb,pc;/* Add your own codes. */}/*List the Menu*/void MenuList() {printf("\n\n\n==========================\n"); printf(" 1 ******* Insert LA\n");printf(" 2 ******* Insert LB\n");printf(" 3 ******* Delete LA\n");printf(" 4 ******* Delete LB\n");printf(" 5 ******* Union LA and LB\n");printf(" 6 ******* Merge LA and LB to LC\n"); printf(" 7 ******* print LinkList\n");printf(" 8 ******* Exit\n");printf("==========================\n");}/*Select the menu */void MenuSelect(LinkList *La,LinkList *Lb){int select,done=1;LinkList Lc;while (done) {MenuList( );printf("input the operating code : ");scanf("%d",&select);switch(select){case 1: Insert(La);break;case 2: Insert(Lb);break;case 3: Delete(La);break;case 4: Delete(Lb);break;case 5: Union(La,Lb);break;case 6: MergeList(La,Lb,&Lc);printf("LC: ");printlk(Lc);break;case 7: printf("LA: ");printlk(*La);printf("LB: ");printlk(*Lb);break;case 8: done=0;break;default: printf(" ERROR\n");}}}main( ){LinkList La,Lb;printf("LA ");Init(&La) ;printlk(La);printf("LB ");Init(&Lb) ;printlk(Lb);MenuSelect(&La,&Lb);}调试后的代码:#include<stdio.h>#include<malloc.h>typedef int DataType;typedef struct LinkList{int data;struct LinkList *next;}LinkList;void PrintList(LinkList *h);LinkList* InitList();void InsList(LinkList *h,int i,DataType x); void LocList(LinkList *h,int i);void DelList(LinkList *h,int i);void main(){int i,n,x;LinkList *h;h=InitList();PrintList(h);printf("\n===========\n");printf("0------EXIT\n");printf("1------INSERT\n");printf("2------DELERT\n");printf("3------LOCERT\n");printf("\n===========\n\n\n");while(1){printf("\nSelect\n");scanf("%d",&n);switch(n){case 0:exit(0);break;case 1:printf("please input the position:\n");scanf("%d",&n);printf("please input the data:\n");scanf("%d",&x);InsList(h,n,x);PrintList(h);break;case 2:printf("please input you want to delete position:\n");scanf("%d",&i);DelList(h,i);PrintList(h);break;case 3:printf("please input you want to search position:\n");scanf("%d",&i);LocList(h,i);PrintList(h);break;default :printf("error\n");break;}}}LinkList* InitList(){LinkList *h,*s,*r;int a,c,i;h=(LinkList*)malloc(sizeof(LinkList));h->next=NULL;r=h;printf("please input some link's length:");scanf("%d",&c);for(i=0;i<c;i++){scanf("%d",&a);s=(LinkList*)malloc(sizeof(LinkList));s->data=a;s->next=r->next;r->next=s;r=r->next;}return h;}void InsList(LinkList *h,int i,DataType x){LinkList *s,*p;int j=1;p=h;s=(LinkList*)malloc(sizeof(LinkList));for(j=1;j<i && p!=NULL;j++)p=p->next;if(p==NULL)printf("error!\n");else{s->data=x;s->next=p->next;p->next=s;}}void DelList(LinkList *h,int i){LinkList *p,*q;int j=1;p=h->next;q=p->next;while(j!=i-1 && q!=NULL){p=p->next;q=q->next;j++;}if(q==NULL)printf("error!\n");else{p->next=q->next;free(q);}}void LocList(LinkList *h,int i){LinkList *p;int j=1;p=h->next;while(p!=NULL){if(p->data==i){printf("position is %d\n",j);break;}p=p->next;j++;}if(p==NULL)printf("NO this data in the link\n"); }void PrintList(LinkList*h){LinkList *p;p=h->next;while(p!=NULL){printf(" %d ->",p->data);p=p->next;}}四、运行输出结果:五、调试和运行程序过程中产生的问题及采取的措施:问题:子函数和主函数前后的调用出现问题,指针的调用不是太明白。

数据结构实验二链表的链式存储结构

数据结构实验二链表的链式存储结构

贵州大学实验报告#include<iostream>using namespace std;typedef int Elemtype;struct LNode{Elemtype data;LNode *next;};void BuildLNode(LNode *&hl)/*建立带头结点单链表*/{hl=new LNode;hl->data=NULL;hl->next=NULL;}void ClearList(LNode *&hl)/*清空线性表*/ {LNode *p=hl;LNode *q;while(p!=NULL){q=p->next;delete p;p=q;}hl=NULL;}bool InsertList(LNode *&hl,Elemtype item,int pos)/*在线性表中插入一个元素*/{if(pos<-1){cout<<"位置无效"<<endl;return false;}if(pos==-1||pos==0)pos=1;LNode *p;int i=1;p=hl;while(p!=NULL&&i<pos){p=p->next;i++;}if(p==NULL){cout<<"位置无效"<<endl;return false;}LNode *q;q=new LNode;q->data=item;q->next=p->next;p->next=q;return true;}bool DeleteList(LNode *&hl,int pos)/*删除线性表中的一个元素*/{if(pos<-1){cout<<"位置无效"<<endl;return false;}if(pos==-1||pos==0)pos=1;LNode *p=hl,*q;int i=1;while(p->next!=NULL&&i<pos){p=p->next;i++;}if(p->next==NULL){cout<<"位置无效或该链表为空"<<endl;return false;}q=p->next;p->next=q->next;delete q;return true;}bool GetList(LNode *p,Elemtype &item,int pos)/*线性表中数据的定位*/{if(pos<-1){cout<<"位置无效"<<endl;return false;}if(pos==-1||pos==0)pos=1;int i=0;while(p!=NULL&&i<pos){p=p->next;i++;}if(p==NULL){cout<<"位置无效"<<endl;return false;}item=p->data;return true;}int FindList(LNode *p,Elemtype item)/*线性表中数据的查找*/{int i=0;while(p!=NULL){if(p->data==item)break;i++;p=p->next;}if(p==NULL){cout<<"找不到该元素"<<endl;return 0;}return i;}void DisplayList(LNode *hl)/*显示线性表中所有数据*/{if(hl==NULL){cout<<"该表为空"<<endl;}LNode *p=hl->next;while(p!=NULL){cout<<p->data<<" ";p=p->next;}} void main(){LNode *head;BuildLNode(head);int pos;Elemtype data;for(int i=0;i<10;i++)InsertList(head,2*i+1,i+1);DisplayList(head);cout<<endl;cout<<"一、插入操作"<<endl;cout<<"位置:";cin>>pos;cout<<"数据:";cin>>data;if(InsertList(head,data,pos))cout<<"插入成功"<<endl;elsecout<<"插入失败"<<endl;DisplayList(head);cout<<endl<<endl;cout<<"二、删除操作"<<endl;cout<<"位置:";cin>>pos;if(DeleteList(head,pos))cout<<"删除成功"<<endl;elsecout<<"删除失败"<<endl;DisplayList(head);cout<<endl<<endl;cout<<"三、定位操作:"<<endl;cout<<"位置:";cin>>pos;if(GetList(head,data,pos))cout<<"该位置数据为"<<data<<endl;elsecout<<"定位失败"<<endl;cout<<"四、查找操作:"<<endl;cout<<"数据:";cin>>data;if(FindList(head,data))cout<<"线性表中第一个等于该数据的位置为"<<FindList(head,data)<<endl;elsecout<<"查找失败"<<endl;ClearList(head);}。

数据结构实验报告2

数据结构实验报告2

数据结构实验报告2一、实验目的本次数据结构实验旨在通过实际操作和编程实践,深入理解和掌握常见的数据结构,如链表、栈、队列、树等,并能够运用所学知识解决实际问题,提高编程能力和算法设计能力。

二、实验环境本次实验使用的编程语言为C++,开发环境为Visual Studio 2019。

三、实验内容(一)链表的实现与操作1、单向链表的创建首先,定义了链表节点的结构体,包含数据域和指向下一个节点的指针域。

然后,通过函数实现了单向链表的创建,从用户输入获取节点的数据,依次创建新节点并连接起来。

2、链表的遍历编写函数实现对单向链表的遍历,依次输出每个节点的数据。

3、链表的插入与删除实现了在指定位置插入节点和删除指定节点的功能。

插入操作时,需要找到插入位置的前一个节点,修改指针完成插入。

删除操作时,同样找到要删除节点的前一个节点,修改指针并释放删除节点的内存。

(二)栈的实现与应用1、栈的基本操作使用数组实现了栈的数据结构,包括入栈、出栈、判断栈空和获取栈顶元素等操作。

2、表达式求值利用栈来实现表达式求值的功能。

将表达式中的数字和运算符分别入栈,按照运算规则进行计算。

(三)队列的实现与应用1、队列的基本操作使用循环数组实现了队列,包括入队、出队、判断队空和队满等操作。

2、模拟银行排队系统通过创建队列来模拟银行客户的排队情况,实现客户的入队和出队操作,统计平均等待时间等。

(四)二叉树的遍历1、二叉树的创建采用递归的方式创建二叉树,用户输入节点数据,构建二叉树的结构。

2、先序、中序和后序遍历分别实现了二叉树的先序遍历、中序遍历和后序遍历,并输出遍历结果。

四、实验结果与分析(一)链表实验结果成功创建、遍历、插入和删除单向链表。

通过对链表的操作,深入理解了链表的动态存储特性和指针的运用。

在插入和删除操作中,能够正确处理指针的修改和内存的释放,避免了内存泄漏和指针错误。

(二)栈实验结果栈的基本操作运行正常,能够正确实现入栈、出栈等功能。

实验二 链表的基本操作

实验二 链表的基本操作

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

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

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

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

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

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

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

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

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

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

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

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

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

最后是链表的查找操作。

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

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

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

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

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

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

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

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

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

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

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

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

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

双向链表的算法设计与实现实验报告

双向链表的算法设计与实现实验报告

数学与计算科学学院实验报告
实验项目名称双向链表的算法设计与实现
所属课程名称__数据结构A
实验类型设计型
实验日期__
班级信计1402
学号201453100214
姓名俞凯烨
成绩
【实验小结】(收获体会)
附录1:源程序
附录2:实验报告填写说明
1.实验项目名称:要求与实验教学大纲一致。

2.实验目的:目的要明确,要抓住重点,符合实验教学大纲要求。

3.实验原理:简要说明本实验项目所涉及的理论知识。

4.实验环境:实验用的软、硬件环境。

5.实验方案(思路、步骤和方法等):这是实验报告极其重要的内容。

概括整个实验过程。

对于验证性实验,要写明依据何种原理、操作方法进行实验,要写明需要经过哪几个步骤来实现其操作。

对于设计性和综合性实验,在上述内容基础上还应该画出流程图、设计思路和设计方法,再配以相应的文字说明。

对于创新性实验,还应注明其创新点、特色。

6.实验过程(实验中涉及的记录、数据、分析):写明具体实验方案的具体实施步骤,包括实验过程中的记录、数据和相应的分析。

7.实验结论(结果):根据实验过程中得到的结果,做出结论。

8.实验小结:本次实验心得体会、思考和建议。

9.指导教师评语及成绩:指导教师依据学生的实际报告内容,给出本次实验报告的评价。

数据结构-实验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、 采用表尾挂入法建立一个以LA为头指针的单链表:2、3、 就地逆转以LB 为头指针的单链表,即得到如下形式的单链表:4、 将逆转后的LB 表接到LA 表之尾并构成循环链:LA二、实验要求:1. 每一个子问题用一个C 语言的函数来完成。

2. 对每一个子问题的结果用一个打印函数输出其结果以验证程序运行是否正确。

打印函数必须是公共的,即:用一个输出函数,既可以对单链表又可对循环链表实现,打印输出。

3.用主函数调用各个子函数,以完成题目要求。

4.程序设计时应尽量考虑通用性,若改变题给数据仍能实现要求。

[实现提示]:.第3小题题中的“就地逆转”即只允许引入除LB外的两个工作指针来实现。

即可以以循环方式从链表首部起逐个地修改各个结点的指针:从NEXT(向后)指针改变为PRIOR(向前)的指针,并注意保存搜索时的指针。

三、实验环境Windows win7程序设计语言C四、实验过程(请学生认真填写):1. 实验设计的(各)流程图:2. 程序设计的代码及解释(必须给出):/*----------------------------------LinkList-------------------------------------*//*基本要求---------------------------------------------------------------------*/ /*采用表尾挂入法建立一个以LA为头指针的单链表--------------*/ /*采用表首插入法建立一个以LB为头指针的单链表.---------------*/ /*就地逆转以LB为头指针的单链表,即得到如下形式的单链表.*/ /*将逆转后的LB表接到LA表之尾并构成循环链-------------------*/ /*每一个子问题用一个C语言的函数来完成--------------------------*/ /* 打印函数必须是公共的-------------------------------------------------*/ /*-------------------------------------Start-------------------------------------*//*--------------------------------------------------------------------------------*/#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define LIST_SIZE 10/*--------------------------------------------------------------------------------*//*定义链表类型--------------------------------------------------------------*/ typedef struct LNode{int data;struct LNode *next;}LinkList;/*--------------------------------------------------------------------------------*//*--------------------------------------------------------------------------------*/ main(){LinkList *InitialList1();LinkList *InitialList2();LinkList *reverse(LinkList *L);void connect(LinkList *L1,LinkList *L2);void putList(LinkList *L);LinkList *L1,*L2;L1=InitialList1();L2=InitialList2();printf("The original of list L1:\n");putList(L1);printf("The original of list L2:\n");putList(L2);L2=reverse(L2);printf("After reverse of list L2:\n");putList(L2);connect(L1,L2);printf("After the connection of L1 and L2:\n");putList(L1);getchar();}/*--------------------------------------------------------------------------------*//*--------------------------------------------------------------------------------*/ /* 表首挂入法创建链表L1-----------------------------------------------*/ LinkList *InitialList1(){LinkList *p,*L;int i;L=(LinkList *)malloc(sizeof(LinkList));L->next=NULL;for(i=0;i<LIST_SIZE;i++){p=(LinkList *)malloc(sizeof(LinkList));p->data=rand()%LIST_SIZE+1;p->next=L->next;L->next=p;}return L;}/*--------------------------------------------------------------------------------*//*--------------------------------------------------------------------------------*/ /* 表尾挂入法创建链表L2-----------------------------------------------*/ LinkList *InitialList2(){LinkList *L,*p,*q;int i;L=p=(LinkList *)malloc(sizeof(LinkList));for(i=0;i<LIST_SIZE;i++){q=(LinkList *)malloc(sizeof(LinkList));q->data=rand()%LIST_SIZE+1;q->next=NULL;p->next=q;p=q;}return L;}/*--------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------*/ /* 就地逆转------------------------------------------------------------------*/ LinkList *reverse(LinkList *L){LinkList *p,*q,*r;p=L->next;q=NULL;while(p){r=q;q=p;p=p->next;q->next=r;}L->next=q;return L;}/*--------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------*/ /* 连接------------------------------------------------------------------------*/ void connect(LinkList *L1,LinkList *L2){LinkList *p,*q;p=L1;q=L2;while(p->next) {p=p->next;q=q->next;}p->next=L2->next;q->next=L1;}/*--------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------*/ /* 输出链表------------------------------------------------------------------*/ void putList(LinkList *L){LinkList *p;p=L->next;while(p&&p!=L){printf("%3d",p->data);p=p->next;}printf("\n");}/*----------------------------------------END----------------------------------*/3. 实验结果(请剪贴你的实验运行结果):The original of list L1:5 3 9 9 5 10 1 5 8 2The original of list L2:6 6 2 8 2 2 6 3 8 7After reverse of list L2:7 8 3 6 2 2 8 2 6 6After the connection of L1 and L2:5 3 9 9 5 10 1 5 8 2 7 8 36 2 2 8 2 6 6五、实验总结1.遇到的问题及分析:①问题:在输出函数中用for循环可以正确输出链表,而使用while循环出现死循环或没有值输出,又或者指针指到了链表外的地址。

实验二 链表操作实现

实验二 链表操作实现

实验二链表操作实现实验日期: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)); 。

数据结构第二章实验报告

数据结构第二章实验报告

数据结构第二章实验报告一、实验目的数据结构第二章主要涉及线性表的相关知识,本次实验的目的在于通过实际操作和编程实现,深入理解线性表的概念、存储结构以及基本操作,巩固所学的理论知识,并提高编程能力和问题解决能力。

二、实验环境本次实验使用的编程语言为C++,编程环境为Visual Studio 2019。

三、实验内容(一)顺序表的实现顺序表是一种用顺序存储方式实现的线性表。

在实验中,我们定义了一个结构体来表示顺序表,包括存储数据的数组和表示表长度的变量。

实现了顺序表的初始化、插入、删除、查找等基本操作。

(二)链表的实现链表是一种通过指针链接实现的线性表。

我们分别实现了单向链表和双向链表。

在单向链表中,每个节点包含数据和指向下一个节点的指针;双向链表则在此基础上增加了指向前一个节点的指针,使得链表的操作更加灵活。

(三)线性表的应用运用实现的线性表解决了一些实际问题,如数据排序、查找特定元素等。

四、实验步骤(一)顺序表的实现步骤1、定义顺序表结构体,包括数据数组和长度变量。

2、实现顺序表的初始化函数,将长度初始化为 0。

3、插入操作:首先判断表是否已满,如果未满,在指定位置插入元素,并将后续元素后移。

4、删除操作:首先判断指定位置是否合法,然后将该位置元素删除,并将后续元素前移。

5、查找操作:遍历表中的元素,找到目标元素返回其位置,否则返回-1。

(二)链表的实现步骤1、单向链表定义单向链表节点结构体,包含数据和指向下一个节点的指针。

实现链表的初始化函数,创建头节点。

插入操作:分为头插法和尾插法,根据插入位置的不同选择相应的方法。

删除操作:找到要删除的节点,将其前后节点连接起来,释放删除节点的内存。

查找操作:遍历链表,找到目标元素返回节点指针,否则返回NULL。

2、双向链表定义双向链表节点结构体,包含数据、指向前一个节点和指向下一个节点的指针。

初始化函数与单向链表类似,但需要同时处理前后指针。

插入和删除操作:在单向链表的基础上,同时更新前后节点的指针。

数据结构实验二链表

数据结构实验二链表

数据结构实验二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 得到新的单链表。

数据结构实验报告双链表

数据结构实验报告双链表

级数据结构实验报告实验名称:实验1 线性表学生姓名:班级:班内序号:学号:日期:1.实验要求1根据线性表的抽象数据类型的定义,选择下面任一种链式结构实现线性表,并完成线性表的基本功能。

1、双链表线性表的基本功能:1、构造:使用头插法、尾插法两种方法2、插入:要求建立的链表按照关键字从小到大有序3、删除4、查找5、获取链表长度6、销毁7、其他:可自行定义3编写测试main()函数测试线性表的正确性。

、4必须要有异常处理,比如删除空链表时需要抛出异常;5保持良好的编程的风格:代码段与段之间要有空行和缩近标识符名称应该与其代表的意义一致函数名之前应该添加注释说明该函数的功能关键代码应说明其功能递归程序注意调用的过程,防止栈溢出2. 程序分析2.1 存储结构2.2 关键算法分析 1.头插构造(一),自然语言1为将要插入的元素建立一个结点 2将结点连入头结点与原第二结点之间 (二),伪代码1初始化一个空链表2 为每个数组元素建立一个结点3将元素插进头结点与原第一结点间并连接上前后结点 4将原第一结点与头结点之间的连接断掉并连接到此元素上 (三),示意图first(b) 非空双循环链表 图2-19 双循环链表示意图(a) 空双循环链表图2-21双链表头插示意图(四),时间复杂度为O(1)2插入(一),自然语言1依次向后扫描直到目标位置,如果目标位置超出范围则抛出错误2更改目标位置前后指针,使插入元素连接进链表(二),伪代码1 定义工作指针p,计数器j清零2 执行下列操作,直到p超出链表范围或指向第i-1个结点2.1工作指针p后移;2.2j加1;3 更改目标位置的前后链接,连接上目标元素(三),具体代码template<class T>void LinkList<T>::Insert(int i,T x){Node<T> *p=first; int j=0;while(j<i-1){p=p->next;if(p==first)throw"x异常";j++;}{Node<T> *s=new Node<T>;s->data=x; s->next=p->next;s->prior=p;p->next->prior=s;p->next=s; //将元素链接在链表中}}(四),示意图双链表插入操作示意图(五),时间复杂度为O(n)3.删除(一),自然语言1依次向后扫描直到目标位置,如果目标位置超出范围则抛出错误2将目标元素删除(二),伪代码1 定义工作指针p,计数器j清零2 工作指针p后移2.1若p超出链表范围则抛出异常2.2 将p结点元素赋予x2.3 将p前驱后继从链表上摘下并将前驱后继相连2.4 释放被删除结点2.5返回x(三),具体代码template<class T>T LinkList<T>::Delete(int i){Node<T> *p=first;int j=0,x;while(j<i){p=p->next;if(p==first)throw"位置异常";//工作指针超过队尾则异常j++; //将工作指针移动到需删除元素的位子}if(p->next==first) cout<<"位置异常"<<endl;else{Node<T> *q=p;x=q->data;(p->prior)->next=p->next;(p->next)->prior=p->prior; //使该结点前后相连delete q; //删除该结点return x;}}(四)图2-22 双链表删除操作示意图(五),时间复杂度为O(n)2.3 其他3. 程序运行结果主函数流程自然语言1.定义a,b两个数组2. a,b分别头插尾插赋予list1 ,2两个双链表并输出3.获取List2中第二个节点4.在list2第二位插入8并输出List25.查找List2中3所在位置6.获取List2链表长度7.删除list2中第三个节点并输出执行结果4. 总结在这次实验中,我不仅更加深刻的了解了线性表表的结构,关于前驱,后继在表中的作用,与表中元素的联系,插入删除等操作的具体过程与使结构上发生的变化,查找,替换等操作的原理,而且对模板类这个上学期尚未学到的内容有了一个较为初步的认识。

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

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

《数据结构》实验指导实验二:单链表的存储及操作一、实验目的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】组合键运行程序,并观察运行情况。

实验2 链表的实现-本次实验需要填写报告

实验2 链表的实现-本次实验需要填写报告
4. 实验重点和难点
(1) 重点:单链表的数据元素添加和删除算法设计。 (2) 难点:双链表的数据元素添加和删除算法设计。
5. 实验结果与分析
(必须写这部分) 应用文字、表格、图形等将数据表示出来
6. 实验总结与体会
必须写这部分
7. 部分代码指导
1. 利用 C 语言结构体类型定义单链表如下:
typedef struct node{ ElemType data; struct node *next;
p=p->next; ++j; } if(!p || j>i) return False; //第 i 个元素不存在 e.sn=p->data.sn; strcpy(,p->); e.score=p->data.score; //查找成功,用 e 取 得第 i 个元素值 return True; }
3. 实验内容
1. 链式线性表的建立、插入、删除及查找。 2. 具体要求:
(1)建立含 n 个学生记录结点的链表; (2)可以在链表的任意合法位置 i 插入一个学生结点; (3)可以删除链表在任意合法位置 i 上的一个学生结点; (4)可以查找第 i 个结点的学生情况; (6)可以查找结点值为 e 的学生记录在链表中的第一个位置 i; (7)可以输出该链表中每个学生的情况; 3. 测试: 建立如下含 3 个学生记录的链表 L={(101,zhangsan,98.5),(102,lisi,90.0),(103,wangwu,89.7)} 进行测试 (1) 在第 1、第 2 位置插入两个学生记录; (2) 删除第 3 个位置的学生记录,并返回所删除学生的情况; (3) 删除值为(103,wangyuan,89.7)和(103,wangwu,89.7)的学生; (4) 查找第 1,2,3 位置的学生; (5) 查找值为(101,zhangsan,98.5),(102,lisi,90.0)的学生结点位置; (6) 遍历链表表,输入所有学生的情况。

实验二 链表的基本操作

实验二 链表的基本操作

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构实验四——二叉树链式

数据结构实验四——二叉树链式

实验报告四
实验课名称:数据结构与程序设计实验
实验名称:二叉树链式存储结构
班级:学号:姓名:时间:
一、问题描述
●二叉链表的C语言描述
●基本运算的算法——建立二叉链表、先序遍历二叉树、中序遍历二叉树、后序遍历二叉
树、后序遍历求二叉树深度
二、数据结构设计
typedef struct BiTNode{
ElemType data; //数据域
struct BiTNode *lchild ,*rchild; //左右孩子结点指针
}BiTNode,*BiTree; //树结点、树结构体变量
根据二叉链表的概念来设计数据结构,分为3个域,一个数据域,另外两个指针域分别指向左右孩子结点。

三、算法设计
1)建立二叉链表
2)先序遍历二叉树
3)中序遍历二叉树
4)后序遍历二叉树
5)后序遍历求二叉树深度。

数据结构实验报告-链表

数据结构实验报告-链表

数据结构实验报告-链表院系:计算机学院实验课程:数据结构实验实验项⽬:实验⼆利⽤链表实现学⽣健康系统指导⽼师:开课时间:专业:计算机类班级:学⽣:学号:实验⼆利⽤链表实现学⽣健康系统1.综设实验题⽬利⽤链表实现学⽣健康系统2.中⽂摘要本实验是利⽤链表这⼀经典的数据结构来实现⼀个学⽣健康系统,从⽽学⽣的健康信息和相应的个⼈信息可以很⽅便地通过这个系统进⾏增、删、查、改等操作。

3.关键词课程名称数据结构实验实验项⽬利⽤链表实现学⽣健康系统实验时间年⽉⽇实验指导⽼师实验评分链表健康系统C++4.前⾔实验⽬的:想要通过链表这⼀数据结构来实现学⽣健康情况管理的⼏个操作功能。

实验意义:⽅便相关⼈员对学⽣健康信息的管理和操作。

实验内容:主要是新建学⽣健康系统、插⼊学⽣的数据、删除学⽣的数据、从⽂件读取学⽣健康数据、将学⽣的健康等信息写⼊到⽂件、查询指定学⽣的相关信息、在屏幕上输出学⽣相关信息等功能。

健康表中学⽣的信息有学号、姓名、出⽣⽇期、性别、⾝体状况等。

5.实验设计由于该实验主要涉及到链表这⼀存储结构,因此整个实验的关键点便在于对链表这个数据结构的建⽴和操作上。

常见的链表的操作有:建⽴链表、往链表中插⼊数据、从链表中删除数据、查找链表中的元素、修改链表中的元素、销毁链表。

由此,经过对问题的仔细分析之后,发现我们所要实现的健康系统的增、删、查、改等功能与链表这⼀数据结构的关系是:增加学⽣数据相当于往链表中的插⼊数据的操作;删除学⽣数据相当于从链表中的删除数据的操作;查找学⽣数据相当于链表中的查找元素的操作;修改学⽣数据相当于链表中的修改元素的操作;因此,我们可以直接⽤链表来存储所有学⽣的信息,每⼀个学⽣的信息集就是链表中的⼀个节点,这样,就使得我们的健康系统的问题归约到了链表的实现问题上了。

在这个链表的设计上,每⼀个节点包含有相应学⽣的所有信息和⼀个指向下⼀个节点的指针,学⽣的信息包括:学号、姓名、出⽣⽇期、性别和健康信息,分别采⽤C++中的string, string, int, bool 和string类型来表⽰。

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

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

数据结构实验二:单链表的基本操作数据结构实验二:单链表的基本操作实验二:单链表的基本操作一、【实验目的】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带回。

链表-实验报告

链表-实验报告

实验2 链表实验概述:一、实验目的本次实习的主要目的是为了使学生熟练掌握链表的基本操作以及在链式存储结构上的实现,包括创建、插入、删除、查找、以及合并等操作。

二、实验要求掌握链表存储方式,熟悉链式存储结构。

三、实验步骤用链表结构实现对多项式初始化、创建、插入、删除等运算。

步骤:输入第一个多项式:7x+2x3输入第二个多项式:8x+9x5输出第一个多项式输出第二个多项式输出两个多项式相加的结果:15x+2x3+9x5实验结果如图:四、实验环境(使用的软件和设备)(1)实习器材:多媒体计算机。

(2)实习地点:校内多媒体机房。

(3)实习软件: Win-TC实验内容:【实验过程】(实验步骤、记录、数据、分析)实验过程(提示)输入第一个多项式:7x+2x3输入第二个多项式:8x+9x5输出第一个多项式输出第二个多项式输出两个多项式相加的结果:15x+2x3+9x5【结果实验记录】(图形或图像)1.说明掌握情况#include<stdio.h>#include<stdlib.h>typedef struct{int sat1,sat2,sat3,sat4;}ElemType;typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;LinkList InitList(){ LinkList L;L=(LinkList)malloc(sizeof(LNode)); L->next=NULL;return(L);}void InsLNode(LinkList L,ElemType x){ LinkList s,p;s=(LinkList)malloc(sizeof(LNode));s->data=x;p=L;while(p->next)p=p->next;s->next=NULL;p->next=s;}void AddPolyn(LinkList La,LinkList Lb){int sum;int a,b;LinkList pa,pb;pa=La->next;pb=Lb->next;a=pa->data.sat1;b=pb->data.sat1;sum=a+b;printf(" %dx%d exp",sum,pa->data.sat2);printf("+");printf(" %dx%d exp+",pa->data.sat3,pa->data.sat4); printf(" %dx%d exp\n",pb->data.sat3,pb->data.sat4);}void Print(LinkList L){ LinkList p;p=L->next;printf(" %dx%d exp",p->data.sat1,p->data.sat2); printf("+");printf(" %dx%d exp",p->data.sat3,p->data.sat4);}main() {LinkList La,Lb;ElemType c,b;int a,i;La=InitList();Lb= InitList();printf("Please input polynomial La:\n");scanf("%d %d",&c.sat1,&c.sat2);scanf("%d %d",&c.sat3,&c.sat4);InsLNode(La,c);printf("Please input polynomial Lb:\n");scanf("%d %d",&b.sat1,&b.sat2);scanf("%d %d",&b.sat3,&b.sat4);InsLNode(Lb,b);printf("polynomial La:");printf("\n");Print(La);printf("\n");printf("polynomial Lb:");printf("\n");Print(Lb);printf("\n");printf("La+Lb:");printf("\n");AddPolyn(La,Lb);printf("\n");getch();}2.裁图说明实验结果【心得体会、问题和建议】成绩:指导教师签名批阅日期:。

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

云南大学数学与统计学实验教学中心实 验 报 告一、实验目的:通过实验掌握线性链表的建立及基本操作,巩固课堂内容,练习其程序的设计与实现。

由于顺序存储结构的操作相对比较简单,而且在前期课程《高级语言程序设计》中使用得也多, 所以本次实验侧重于对线性链表存储结构上的操作及应用的实现。

二、实验内容:本实验包含以下几个子问题:1、 采用表尾挂入法建立一个以LA为头指针的单链表:2、3、 就地逆转以LB 为头指针的单链表,即得到如下形式的单链表:4、 将逆转后的LB 表接到LA 表之尾并构成循环链:LA二、实验要求:1. 每一个子问题用一个C 语言的函数来完成。

2. 对每一个子问题的结果用一个打印函数输出其结果以验证程序运行是否正确。

打印函数必须是公共的,即:用一个输出函数,既可以对单链表又可对循环链表实现,打印输出。

3.用主函数调用各个子函数,以完成题目要求。

4.程序设计时应尽量考虑通用性,若改变题给数据仍能实现要求。

[实现提示]:.第3小题题中的“就地逆转”即只允许引入除LB外的两个工作指针来实现。

即可以以循环方式从链表首部起逐个地修改各个结点的指针:从NEXT(向后)指针改变为PRIOR(向前)的指针,并注意保存搜索时的指针。

三、实验环境Windows win7程序设计语言C四、实验过程(请学生认真填写):1. 实验设计的(各)流程图:2. 程序设计的代码及解释(必须给出):/*----------------------------------LinkList-------------------------------------*//*基本要求---------------------------------------------------------------------*/ /*采用表尾挂入法建立一个以LA为头指针的单链表--------------*/ /*采用表首插入法建立一个以LB为头指针的单链表.---------------*/ /*就地逆转以LB为头指针的单链表,即得到如下形式的单链表.*/ /*将逆转后的LB表接到LA表之尾并构成循环链-------------------*/ /*每一个子问题用一个C语言的函数来完成--------------------------*/ /* 打印函数必须是公共的-------------------------------------------------*/ /*-------------------------------------Start-------------------------------------*//*--------------------------------------------------------------------------------*/#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define LIST_SIZE 10/*--------------------------------------------------------------------------------*//*定义链表类型--------------------------------------------------------------*/ typedef struct LNode{int data;struct LNode *next;}LinkList;/*--------------------------------------------------------------------------------*//*--------------------------------------------------------------------------------*/ main(){LinkList *InitialList1();LinkList *InitialList2();LinkList *reverse(LinkList *L);void connect(LinkList *L1,LinkList *L2);void putList(LinkList *L);LinkList *L1,*L2;L1=InitialList1();L2=InitialList2();printf("The original of list L1:\n");putList(L1);printf("The original of list L2:\n");putList(L2);L2=reverse(L2);printf("After reverse of list L2:\n");putList(L2);connect(L1,L2);printf("After the connection of L1 and L2:\n");putList(L1);getchar();}/*--------------------------------------------------------------------------------*//*--------------------------------------------------------------------------------*/ /* 表首挂入法创建链表L1-----------------------------------------------*/ LinkList *InitialList1(){LinkList *p,*L;int i;L=(LinkList *)malloc(sizeof(LinkList));L->next=NULL;for(i=0;i<LIST_SIZE;i++){p=(LinkList *)malloc(sizeof(LinkList));p->data=rand()%LIST_SIZE+1;p->next=L->next;L->next=p;}return L;}/*--------------------------------------------------------------------------------*//*--------------------------------------------------------------------------------*/ /* 表尾挂入法创建链表L2-----------------------------------------------*/ LinkList *InitialList2(){LinkList *L,*p,*q;int i;L=p=(LinkList *)malloc(sizeof(LinkList));for(i=0;i<LIST_SIZE;i++){q=(LinkList *)malloc(sizeof(LinkList));q->data=rand()%LIST_SIZE+1;q->next=NULL;p->next=q;p=q;}return L;}/*--------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------*/ /* 就地逆转------------------------------------------------------------------*/ LinkList *reverse(LinkList *L){LinkList *p,*q,*r;p=L->next;q=NULL;while(p){r=q;q=p;p=p->next;q->next=r;}L->next=q;return L;}/*--------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------*/ /* 连接------------------------------------------------------------------------*/ void connect(LinkList *L1,LinkList *L2){LinkList *p,*q;p=L1;q=L2;while(p->next) {p=p->next;q=q->next;}p->next=L2->next;q->next=L1;}/*--------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------*/ /* 输出链表------------------------------------------------------------------*/ void putList(LinkList *L){LinkList *p;p=L->next;while(p&&p!=L){printf("%3d",p->data);p=p->next;}printf("\n");}/*----------------------------------------END----------------------------------*/3. 实验结果(请剪贴你的实验运行结果):The original of list L1:5 3 9 9 5 10 1 5 8 2The original of list L2:6 6 2 8 2 2 6 3 8 7After reverse of list L2:7 8 3 6 2 2 8 2 6 6After the connection of L1 and L2:5 3 9 9 5 10 1 5 8 2 7 8 36 2 2 8 2 6 6五、实验总结1.遇到的问题及分析:①问题:在输出函数中用for循环可以正确输出链表,而使用while循环出现死循环或没有值输出,又或者指针指到了链表外的地址。

相关文档
最新文档