链表基本操作实验报告

合集下载

单链表的基本操作实验报告

单链表的基本操作实验报告

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

在本次实验中,我们将学习和实践单链表的基本操作,包括创建链表、插入节点、删除节点以及遍历链表等。

一、实验目的本次实验的主要目的是掌握单链表的基本操作,包括链表的创建、插入节点、删除节点和遍历链表。

通过实践操作,加深对单链表的理解,并掌握如何应用单链表解决实际问题。

二、实验过程1. 创建链表首先,我们需要创建一个空链表。

链表可以通过一个头节点来表示,头节点不存储数据,只用于标识链表的起始位置。

我们可以定义一个指针变量head,将其指向头节点。

2. 插入节点在链表中插入节点是常见的操作。

我们可以选择在链表的头部、尾部或者指定位置插入节点。

插入节点的过程可以分为以下几个步骤:a. 创建一个新节点,并为其赋值;b. 找到要插入位置的前一个节点;c. 将新节点的指针指向前一个节点的下一个节点;d. 将前一个节点的指针指向新节点。

3. 删除节点删除节点是另一个常见的操作。

我们可以选择删除链表的头节点、尾节点或者指定位置的节点。

删除节点的过程可以分为以下几个步骤:a. 找到要删除节点的前一个节点;b. 将前一个节点的指针指向要删除节点的下一个节点;c. 释放要删除节点的内存空间。

4. 遍历链表遍历链表是为了查看链表中的元素。

我们可以从头节点开始,依次访问每个节点,并输出节点的值。

三、实验结果在本次实验中,我们成功完成了单链表的基本操作。

通过创建链表、插入节点、删除节点和遍历链表等操作,我们可以方便地对链表进行增删改查操作。

四、实验总结通过本次实验,我们对单链表的基本操作有了更深入的了解。

单链表是一种非常重要的数据结构,广泛应用于各个领域。

掌握了单链表的基本操作,我们可以更好地解决实际问题,并且为以后学习更复杂的数据结构打下坚实的基础。

在实验过程中,我们还发现了一些问题和不足之处。

创建链表和链表操作实验报告

创建链表和链表操作实验报告

创建链表和链表操作实验报告数据结构实验报告报告名称创建链表和链表操作专业网络工程班级1001 学号20XX03120XX9 姓名张剑指导教师陈淑红李珍辉黄哲20XX年5月4 日、实验目的:掌握线性表的基本操作:插删除、查找以及线性表入、合并等运算在顺序存储结构和链接存储结构上的运算。

二、实验内容与基本要求:实验内容:1. 创建单链表2. 在链表上进行插入、删除操作;3 .设计一个程序,用两个单链表分别表示两个集合,并求出这两个集合的并集。

实验要求:1. 在上机前写出全部源程序; 2 .能在机器上正确运行程序;3 .用户界面友好;三、概要设计:1.单链表的存储结构:teypedef structLNode{ ElemType date;struct LNond *next; }LNode *LinkList;2. 单链表的插入操作:Status ListTnsert-L(LinkLIst &L, int i, ElemType e ){//再带头结点的单链线性表L中的第i个位置之前插入元素 e P=l; j=0;While(p&&jnext;++j;}//寻找第i-1个结点if(!p||j>i-1) return ERROR; //i 小小于1 或者大于表长+1 s=(LinkList) malloc (sizeof(LNode)); //生成新结点s->date=e; s->next=p->next; // 插入L 中p->next=s; return ok;}//ListTnsert L3. 单链表的删除操作:Status ListDelete-L(LinkLlst &L, int i, ElemType &e ){//在带头结点单链线性表L中,删除低i个元素,并e返回其值p=l; j=0;while(p->next&&jnext; ++j; }if(!(p->next)||j>i-1)return ERROR; // 删除位置不合理q=p->n ext ; p->n ext=q->n ext; //删除并释放结点e=q->date free(q); return OK;} //ListDelete-L4. 链表的合并操作:void MergeList-L(LinkList & La, LinkList & Lb, LinkList &Lc){ // 已知单链表La和Lb的元素值//合并单链表La和Lb,得到新的单链表Lc pa=La->next; pb=Lb->next;lc=pc=La; //用La的头结点作为Lc的头结点while(pa&&pb){ if(pa->datedate){pc->n ext =pa; pc=pa; pa=pa->n ext; }else {pc->n ext=pb;pc=pb;pb=pb->n ext;} }Pc->next=pa pa:pb; // 插入剩余段free(Lb); // 释放Lb头结点} //MergeList-L 四、详细设计:#include #include #include #include typedefint status;typedef char ElemType; typedef struct Lnode {ElemType data;//定义链表结点类型 struct Lnode *next; }Lnode,*Linklist;status initlist(Linklist *L) {// 单链表的初始化 *L=(Lnode *)malloc(sizeof(Lnode)); //创建头结点(*L)->next=NULL;return 1;}status Createlist(Linklist L) { Lnode *p,*q;int i,j=1,n;ElemType m,M; q=L;请输入你要输入单链中元素的个数\\n\{p=(Lnode *)malloc(sizeof(Lnode)); 请输入%个元素:\scanf(\p->n ext=q->n ext;j++;} return 1;}status Listinsert(Linklist { int j=0;输入错误!\\n\ returnscanf(\ scanf(\for(i=n;i>0;i--)scanf(\ p->data=M; q->n ext=p;q=p;L,int i,ElemType e)++j; }Lnode *p=L,*s; while(p&&jnext;0; }s=(Lnode *)malloc(sizeof(Lnode)); s->data=e;//创建自己规定长度的单链表//回车缓冲区//回车缓冲区//向单链表指定位置插入一个元素s->next=p->next; p->next=s; return 1; }status Listdelete(Linklist L,int i,ElemType *e){ //删除单链表指定位置的元素,返回删除后的。

单链表的基本操作实验报告

单链表的基本操作实验报告

湖南第一师范学院信息科学与工程系实验报告课程名称:数据结构与算法成绩评定:实验项目名称:单链表的基本操作指导教师:学生姓名:沈丽桃学号: 10403080118 专业班级: 10教育技术实验项目类型:验证实验地点:科B305 实验时间: 2011 年 10 月20 日一、实验目的与要求:实验目的:实现线性链表的创建、查找、插入、删除与输出。

基本原理:单链表的基本操作二、实验环境:(硬件环境、软件环境)1.硬件环境:奔ⅣPC。

2.软件环境:Windows XP 操作系统,TC2.0或VC++。

三、实验内容:(原理、操作步骤、程序代码等)#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct celltype{int element;struct celltype*next;};typedef int position;void main(){struct celltype*head,*p;int x,choice;void INSERT(int x,struct celltype*p);void LOCATE(int x,struct celltype*p);void DELETE(int x,struct celltype*p);p=(struct celltype*)malloc(sizeof(struct celltype));head=p;p->element=0;p->next=NULL;printf(“Please option:1:Insert 2:Locate 3:Delete\n”);printf(“Please choose:”);scanf(“%d”,&choice);switch(choice)case 1:printf(“Please input a node:”);scanf(“%d”,&x);p=head;INSERT(x,p);for(p=head;p!=NULL;p=p->next)printf(“%d”,p->element);printf(“\n”);break;case 2:printf(“Please input the data you want to locate:”); scanf(“%d”,&x);p=head;LOCATE(x,p);break;case 3:printf(“Please input the data you want to delete:”); scanf(“%d”,&x);DELETE(x,p);for(p=head;p!=NULL;p=p->next)printf(“%d”,p->next);printf(“\n”);break;}void INSERT(int x,struct celltype*p){struct celltype*t,*q;q=(struct celltype*)malloc(sizeof(struct celltype)); q->next=x;while((x>p->element)&&(p!=NULL)){t=p;p=p->next;}if((x>p->element)&&(p->next!=NULL)){p->next=q;q->next=NULL;}else{q->next=p;t->next=q;}}void LOCATE(int x,struct celltype*p){while(p->next!=NULL)if(p->next->element==x)printf(“the number %d is in %d\n”,x,p);else printf(“the number not exist!\n”);}void DELETE(int x,struct celltype*p){while((p->element!=x)&&(p->next!=NULL)){t=p;p=p->next;}if(p->element==x)t->next=p->next}error C2018:unknown character ’Oxal’error C2065:’Please’:undeclared identifiererror C4024:’printf’:different types for formal and actual parameter 1error C4047:’function’:’const*differs in levers of indirection from ’int’error C2146:syntaxerror:missing’)’before identifier’option’error C2017:illegal escape sequenceerror C2059:syntax error:’)’error C2143:syntax error:missing’)’before’%’出现了很多错误,主要是因为printf里的一对双引号不是英文状态下的。

链表实验报告

链表实验报告

C 语言程序设计实验报告实验一:链表的基本操作一·实验目的1. 掌握链表的建立方法2. 掌握链表中节点的查找与删除3. 掌握输出链表节点的方法4. 掌握链表节点排序的一种方法5. 掌握C 语言创建菜单的方法6. 掌握结构化程序设计的方法二·实验环境1. 硬件环境:当前所有电脑硬件环境均支持2. 软件环境:Visual C++6.0三.函数功能1. CreateList // 声明创建链表函数2.TraverseList // 声明遍历链表函数3. InsertList // 声明链表插入函数4.DeleteTheList // 声明删除整个链表函数5. FindList // 声明链表查询函数 四.程序流程图五.程序代码#include<stdio.h>#include<stdlib.h>typedef int Elemtype;typedef int Status;typedef struct node//定义存储节点{int data;//数据域struct node *next;//结构体指针} *linklist,node;//结构体变量,结构体名称linklist creat (int n)//创建单链表{linklist head,r,p;//定义头指针r,p,指针int x,i;head=(node *)malloc(sizeof(node));//生成头结点 声明函数 主函数 main 创建链表函数定义CreateList 定义链表遍历函数TraverseList定义链表查询函数FindList 定义链表插入函数在链表位置第pos 节点前插入包含数据val 的节点InsertList(PNode List, int pos, int val) 插入节点 定义删除整个链表函数 DeleteTheList定义删除链表元素函数删除链表中的第pos 节点DeleteList(PNode List, int pos) 删除节点r=head;//r指向头结点printf("输入数字:\n");for(i=n;i>0;i--)//for 循环用于生成第一个节点并读入数据{scanf("%d",&x);p=(node *)malloc(sizeof(node));p->data=x;//读入第一个节点的数据r->next=p;//把第一个节点连在头结点的后面r=p;//循环以便于生成第二个节点}r->next=0;//生成链表后的断开符return head;//返回头指针}void output (linklist head)//输出链表{linklist p;p=head->next;do{printf("%3d",p->data);p=p->next;}while(p);printf("\n")}Status insert ( linklist &l,int i, Elemtype e)//插入操作{int j=0;linklist p=l,s;while(j<i-1 && p){p=p->next;++j;}if(!p || j>i-1)return -1;else{s=(node *)malloc(sizeof(node));s->data=e;s->next=p->next;p->next=s;return 1;}}Status delect ( linklist &l,int i, Elemtype &e)//删除操作{int j=0;linklist p=l,q;while(j<i-1 && p->next){p=p->next;++j;}if(!p->next || j>i-1)return -1;else{q=p->next;p->next=q->next;e=q->data;free(q);return 1;}}void combine(linklist la,linklist lb)//合并单链表{node *pa,*pb,*pc;linklist lc;pa=la->next;pb=lb->next;lc=pc=la;while(pa && pb){if(pa->data<=pb->data){pc->next=pa;pc=pa;pa=pa->next;}else{pc->next=pb;pc=pb;pb=pb->next;} }pc->next=pa?pa:pb;free(lb);}Status GetElem(linklist l,int i,Elemtype &e )//查找操作 {linklist p;int j;p=l->next;j=1;while(p && j<i){p=p->next;++j;}if(!p || j>i)return -2;e=p->data;return e;}void main(){linklist la,lb;int n;int i,j;Elemtype e;printf("请输入第一个链表:\n");printf("输入链表元素的个数:\n");scanf("%d",&n);la=creat(n);printf("输出链表:\n");output(la);printf("请输入要查找元素的位置:\n");scanf("%d",&i);j=GetElem(la,i,e);printf("所要查找的元素是%d\n",j);printf("请输入插入位置和元素:\n");scanf("%d%d",&i,&e);insert(la,i,e);printf("插入后的链表:\n");output(la);printf("请输入要删除的位置:\n");scanf("%d",&i);delect(la,i,e);printf("删除的那个元素是:%d\n",e);printf("输出删除后的顺序表:\n");output(la);printf("请输入第一个非递减链表:\n");printf("输入链表元素的个数:\n");scanf("%d",&n);la=creat(n);printf("输出链表:\n");output(la);printf("请输入第二个非递减链表:\n");printf("输入链表元素的个数:\n");scanf("%d",&n);lb=creat(n);printf("输出链表:\n");output(lb);combine(la,lb);printf("输出合并后的链表:\n");output(la);六.运行结果七.心得体会通过本次实验我对链表有了更深的了解,对链表的插删操作、遍历、查找等基本上掌握了。

北工大实验报告

北工大实验报告

一、实验名称数据结构实验二:链表的基本操作二、实验目的1. 理解链表的基本概念和结构。

2. 掌握链表的创建、插入、删除、查找等基本操作。

3. 提高编程能力,巩固数据结构知识。

三、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 2019四、实验原理链表是一种常见的线性数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。

链表具有以下特点:1. 无固定长度,可以根据需要动态地添加或删除节点。

2. 链接方式灵活,便于实现各种操作。

3. 适合存储具有动态变化的数据。

本实验主要实现以下功能:1. 创建链表:根据用户输入的数据,创建一个单链表。

2. 插入节点:在链表的指定位置插入一个新节点。

3. 删除节点:删除链表中的指定节点。

4. 查找节点:在链表中查找一个指定的节点。

5. 打印链表:遍历链表并打印所有节点数据。

五、实验步骤1. 创建链表```cppstruct ListNode {int data;ListNode next;ListNode(int x) : data(x), next(nullptr) {}};ListNode createList() {ListNode head = nullptr, tail = nullptr;int data;cout << "请输入链表数据(输入-1结束):" << endl; while (cin >> data && data != -1) {ListNode node = new ListNode(data);if (head == nullptr) {head = node;tail = node;} else {tail->next = node;tail = node;}}return head;}```2. 插入节点```cppvoid insertNode(ListNode head, int data, int position) { ListNode node = new ListNode(data);if (position == 0) {node->next = head;head = node;} else {ListNode current = head;for (int i = 0; i < position - 1; ++i) {if (current == nullptr) {cout << "插入位置超出链表长度!" << endl; return;}current = current->next;}node->next = current->next;current->next = node;}}```3. 删除节点```cppvoid deleteNode(ListNode head, int position) {if (head == nullptr) {cout << "链表为空!" << endl;return;}if (position == 0) {ListNode temp = head;head = head->next;delete temp;} else {ListNode current = head;for (int i = 0; i < position - 1; ++i) {if (current == nullptr) {cout << "删除位置超出链表长度!" << endl; return;}current = current->next;}if (current->next == nullptr) {cout << "删除位置超出链表长度!" << endl;return;}ListNode temp = current->next;current->next = temp->next;delete temp;}}```4. 查找节点```cppListNode findNode(ListNode head, int data) { ListNode current = head;while (current != nullptr) {if (current->data == data) {return current;}current = current->next;}return nullptr;}```5. 打印链表```cppvoid printList(ListNode head) {ListNode current = head;while (current != nullptr) {cout << current->data << " ";current = current->next;}cout << endl;}```六、实验结果与分析通过以上步骤,成功实现了链表的基本操作。

数据结构单链表实验报告

数据结构单链表实验报告

数据结构单链表实验报告实验目的:掌握单链表的基本操作,学会使用单链表实现各种算法。

实验内容:实现单链表的基本操作,包括创建、插入、删除、访问等。

利用单链表完成以下算法:- 单链表逆序- 查找单链表中的中间节点- 删除单链表中的倒数第K个节点- 合并两个有序单链表为一个有序单链表实验步骤:1. 创建单链表在创建单链表时,先定义一个结构体Node来表示链表中的节点,节点包括数据域和指针域,指针域指向下一个节点。

然后,用指针p指向链表的头节点,将头节点的指针域初始化为NULL。

2. 插入节点在单链表中插入节点的操作分为两种情况:- 在链表头插入节点- 在链表中间或尾部插入节点无论是哪种情况,先将新节点的指针域指向要插入的位置的下一个节点,再将要插入的位置的指针域指向新节点即可。

3. 删除节点删除链表节点的操作同样分为两种情况:- 删除头节点- 删除中间或尾部节点要删除头节点,先用一个指针将头节点指向的下一个节点保存起来,再将头节点释放掉。

要删除中间或尾部节点,先用一个指针指向要删除节点的前一个节点,然后将指向要删除节点的前一个节点的指针域指向要删除节点的下一个节点,最后将要删除的节点释放掉。

4. 单链表逆序单链表逆序可以使用三个指针来完成,分别为pre指针、cur指针和next指针。

首先将pre指针和cur指针指向NULL,然后循环遍历链表,将cur指针指向当前节点,将next指针指向当前节点的下一个节点,然后将当前节点的指针域指向pre指针,最后将pre指针和cur指针向前移动一个节点,继续进行循环。

5. 查找单链表中的中间节点查找单链表中的中间节点可以使用双指针法,将两个指针p1和p2都指向链表头,然后p1每次向前移动一个节点,而p2每次向前移动两个节点,当p2指向了链表尾部时,p1指向的节点即为中间节点。

6. 删除单链表中的倒数第K个节点删除单链表中的倒数第K个节点可以使用双指针法,在链表中定义两个指针p1和p2,p1指向链表头,p2指向第K个节点,然后p1和p2同时向前移动,直到p2指向链表尾部,此时p1指向的节点即为要删除的节点。

c语言链表实验报告

c语言链表实验报告

c语言链表实验报告C语言链表实验报告引言:链表是一种常见的数据结构,它在计算机科学中有着广泛的应用。

通过链表,我们可以动态地存储和操作数据,实现各种复杂的算法和数据结构。

本实验旨在通过使用C语言,实现一个简单的链表结构,并演示其基本操作和应用。

一、链表的定义和基本概念链表是由一系列节点组成的数据结构,每个节点包含数据和指向下一个节点的指针。

相比于数组,链表具有动态性,可以根据需要动态地分配和释放内存空间。

链表的基本概念包括头节点、尾节点、节点插入和节点删除等。

二、链表的实现1. 定义节点结构体在C语言中,我们可以通过定义结构体来表示链表的节点。

结构体中包含一个数据成员和一个指向下一个节点的指针成员。

2. 创建链表为了创建一个链表,我们首先需要定义一个头节点,并将其指针指向NULL。

然后,通过动态分配内存,创建其他节点,并将它们按照一定的顺序链接起来。

3. 插入节点链表的插入操作可以在链表的任意位置进行。

我们可以在头节点之后或者指定节点之后插入新的节点。

插入操作的关键是修改指针的指向,使得新节点能够正确地链接到链表中。

4. 删除节点链表的删除操作可以删除链表中的任意节点。

删除操作的关键是修改指针的指向,使得被删除节点的前一个节点和后一个节点能够正确地链接起来,并释放被删除节点的内存空间。

三、链表的应用链表作为一种常见的数据结构,有着广泛的应用。

以下是链表的一些常见应用场景:1. 队列和栈链表可以用来实现队列和栈这两种常见的数据结构。

通过在链表的头部或尾部进行插入和删除操作,可以实现队列和栈的基本功能。

2. 图的表示在图的表示中,链表可以用来表示图的邻接表。

每个顶点对应一个链表,链表中存储该顶点的邻接点。

通过链表的插入和删除操作,可以方便地修改图的结构。

3. 文件系统在文件系统中,链表可以用来表示文件的目录结构。

每个目录对应一个链表,链表中存储该目录下的文件和子目录。

通过链表的插入和删除操作,可以方便地管理文件和目录。

实验报告1

实验报告1

实验一创建链表和链表操作一、实验目的掌握线性表的基本操作:插入、删除、查找、以及线性表合并等操作在顺序存储结构和链式存储结构上的实现。

二、实验内容:1. 创建单链表2.在链表上进行插入、删除操作;3.设计一个程序,用两个单链表分别表示两个集合,并求出这两个集合的并集。

四、测试数据:∙(3,9,5,6,11,8);在5之前插入4,7,并删除11∙求集合{1,12,8,6,4,9}和{2,5,12,7,4}的并集五、概要设计:本操作应完成如下功能:(1)创建链表说明:分配一定的空间,根据给定的链表长度输入值,创建链表。

(2)合并链表说明:将两个链表合并为一个链表只需修改链表头、尾指针即可实现。

(3)在链表中插入值说明:将给定的值插入到指定位置上,只需修改插入位置的前后结点的指针即可。

(4)在链表中删除值说明:将指定位置的值删除,只需修改删除位置的前后结点的指针即可。

六、详细设计:源代码:#include<stdio.h>#include<conio.h>#include<stdlib.h>#include<iostream.h>#define OK 1#define ERROR 0#define OVERFLOW 0//线性链表的存储结构,一个结点typedef struct LNode{int data; // 数据域struct LNode *next; // 指针域}LNode,*LinkList; //结点结构类型和指向结点的指针类型int TraverseList_L(LinkList L) //遍历单链表{LinkList p;p=L->next;while(p){printf("-->%d",p->data);p=p->next;}return OK;}//尾插法创建的带头结点的单链表。

void CreateList_L(LinkList &L,int &n){L=(LinkList)malloc(sizeof (LNode));//建立一个空链表L。

链表基本操作实验报告

链表基本操作实验报告
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 指向新开辟的结点,并将元素存
放到新开辟结点的数据域,

数据结构单链表实验报告

数据结构单链表实验报告

数据结构单链表实验报告一、实验目的1、深入理解单链表的数据结构及其基本操作。

2、掌握单链表的创建、插入、删除、查找等操作的实现方法。

3、通过实际编程,提高对数据结构和算法的理解和应用能力。

二、实验环境1、操作系统:Windows 102、编程语言:C 语言3、开发工具:Visual Studio 2019三、实验原理单链表是一种常见的数据结构,它由一系列节点组成,每个节点包含数据域和指针域。

指针域用于指向下一个节点,从而形成链表的链式结构。

单链表的基本操作包括:1、创建链表:通过动态分配内存创建链表的头节点,并初始化链表为空。

2、插入节点:可以在链表的头部、尾部或指定位置插入新的节点。

3、删除节点:根据给定的条件删除链表中的节点。

4、查找节点:在链表中查找满足特定条件的节点。

四、实验内容(一)单链表的创建```cinclude <stdioh>include <stdlibh>//定义链表节点结构体typedef struct Node {int data;struct Node next;} Node;//创建单链表Node createList(){Node head =(Node)malloc(sizeof(Node));if (head == NULL) {printf("内存分配失败!\n");return NULL;}head>data = 0;head>next = NULL;return head;}int main(){Node list = createList();//后续操作return 0;}```在创建单链表时,首先为头节点分配内存空间。

若内存分配失败,则提示错误信息并返回`NULL`。

成功分配内存后,初始化头节点的数据域和指针域。

(二)单链表的插入操作插入操作分为三种情况:头部插入、尾部插入和指定位置插入。

1、头部插入```cvoid insertAtHead(Node head, int data) {Node newNode =(Node)malloc(sizeof(Node));if (newNode == NULL) {printf("内存分配失败!\n");return;}newNode>data = data;newNode>next = head>next;head>next = newNode;}```头部插入时,创建新节点,将新节点的数据域赋值,并将其指针域指向原头节点的下一个节点,然后更新头节点的指针域指向新节点。

链表实验报告1

链表实验报告1

1、熟练掌握线性表的基本操作在两种存储结构上的实现。

2、会用线性链表解决简单的实际问题。

该程序的功能是实现单链表的定义和操作。

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

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

单链表操作的选择以菜单形式浮现,如下所示:please input the operation:1.初始化2.清空3.求链表长度4.检查链表是否为空5.检查链表是否为满 6.遍历链表(设为输出元素) 7.从链表中查找元素 8.从链表中查找与给定元素值相同的元素在表中的位置9.向链表中插入元素 10. 从链表中删除元素其他键退出。

设编号为 1,2,3,……, n 的 n(n>0)个人按顺时针方向围坐一圈,每一个人持有一个正整数密码。

开始时任选一个正整数做为报数上限 m,从第一个人开始顺时针方向自 1 起顺序报数,报到 m 时住手报数,报 m 的人出列,将他的密码作为新的m 值,从他的下一个人开始重新从 1 报数。

如此下去,直到所有人全部出列为止。

令n 最大值取 30。

要求设计一个程序摹拟此过程,求出出列编号序列。

struct node //结点结构{int number; /* 人的序号*/int cipher; /* 密码*/struct node *next; /* 指向下一个节点的指针*/};/* 定义 DataType 为 int 类型 */typedef int DataType;/* 单链表的结点类型 */typedef struct LNode{ DataType data;struct LNode *next;}LNode,*LinkedList;LinkedList LinkedListInit(){ //函数功能:对链表进行初始化参数:链表(linklist L) 成功初始化返回 1, 否则返回 0 }void LinkedListClear(LinkedList &L){//函数功能:把链表清空参数:链表(linklist L) 成功清空链表返回 1 }int LinkedListEmpty(LinkedList L){ //函数功能:判断链表是否为空参数:链表(linklist L) 链表为空时返回 0, 不为空返回 1 }void LinkedListTraverse(LinkedList L){ //函数功能:遍历链表,输出每一个节点的 elem 值参数:链表(linklist L) 通过循环逐个输出节点的 elem 值 }int LinkedListLength(LinkedList L){ //函数功能:返回链表的长度参数:链表(linklistL) 函数返回链表的长度 }LinkedList LinkedListGet(LinkedList L,int i){ //函数功能: 从链表中查找有无给定元素参数;链表(linklist L),给定元素 (int i) 如果链表中有给定元素(i)则返回 1,否则返回 0 }LinkedList LinkedListLocate(LinkedList L, DataType x){//函数功能: 从链表中查找给定元素的位置参数;链表(linklist L),给定元素(int i) 如果链表中有给定元素 i 则返回元素的位置, 没有则返回 0 }void LinkedListInsert(LinkedList &L,int i,DataType x)}void LinkedListDel(LinkedList &L,DataType x)i 个结点 }(二)、zhujiemian();cin>>a;do{switch(a){case 1:if(init(L)==1)cout<<"成功初始化! "<<endl;elsecout<<"初始化失败! "<<endl;break;case 2:if(makeempty(L)==1)cout<<"链表已清空! "<<endl;elsecout<<"链表清空失败! "<<endl;break;case 3:b=getlength(L);cout<<"链表的长度为: "<<b<<endl;break;case 4:if(isempty(L)==1)cout<<"链表不为空! "<<endl;elsecout<<"链表为空! "<<endl;break;case 5:if(isfull(L)==1)cout<<"链表不满! "<<endl;elsecout<<"链表已满! "<<endl;break;case 6:show(L);break;case 7:cout<<"输入您要查找的元素: ";cin>>b;if(find(L,b)==1)cout<<"链表中有该元素"<<b<<endl;elsecout<<"链表中没有您要查找的元素"<<b<<endl;break;case 8:cout<<"您要查找的元素为: "<<endl;cin>>b;if(location(L,b)==0)cout<<"没有您要查找的元素"<<b<<endl;elsecout<<"您查找的元素 "<<b<<"在第"<<location(L,b)<<"个位置。

实验一 链表操作实验报告

实验一 链表操作实验报告

实验内容按实验内容与步骤阅读理解数据结构及主函数,并完成各子函数的功能。

#include <stdio.h>#include <stdlib.h>typedef struct node{int num; //学号float height; //身高struct node *next;}Node,*Link;Link CreateLink();//创建链表Link Delete(Link H,int n); //删除节点Node *GetNode(Link H,int n);//获取节点Link Insert(Link H,Node *N);//插入节点int print(Link H);//输出/* 创建链表 */Link CreateLink(){Link H=NULL;Node *p,*q;int num=-1;//保存学号float hei=-1.0;//保存身高int min=1;//计数,至少插入3个节点printf("请输入学号:num=");scanf("%d",&num);fflush(stdin);//清空输入缓冲区,确保不影响后面的数据读取printf("请输入身高:hei=");scanf("%f",&hei);printf("\n");fflush(stdin);//清空输入缓冲区,确保不影响后面的数据读取while(num!=-1 || min<=3){if(H==NULL){p=(Node *)malloc(sizeof(Node));p->num=num;p->height=hei;p->next=NULL;min++; //计数加一H=p;}else{q=(Node *)malloc(sizeof(Node));q->num=num;q->height=hei;q->next=NULL;min++;p->next=q;p=p->next;}lab1: printf("请输入学号:num=");scanf("%d",&num);fflush(stdin);if(num==-1 && min<=3){printf("\n请至少输入3个节点\n\n");goto lab1; //跳到 lab1}if(num==-1 && min>3) //退出输入break;printf("请输入身高:hei=");scanf("%f",&hei);printf("\n");fflush(stdin);}return H;}/* 删除节点 *//* 参数 H 为表头节点 */ /* 参数 n 为删除第几个节点 */ Link Delete(Link H,int n){int i=1;Node *p,*q;if(n==1) //删除的是第一个节点{H=H->next;return H;}p=H;while(p!=NULL){if(i==(n-1)) //删除节点的前一个节点break;p=p->next;i++;}if(i==(n-1))//存在n-1个节点{q=p->next;p->next=q->next;free(q); //释放q节点}else{printf("不存在第%d个节点!\n",n);}return H;}/* 获取节点 *//* 参数 H 为表头节点 */ /* 参数 n 为第几个节点 */ Node *GetNode(Link H,int n){int i=1;Node *p,*q;p=H;q=H;if(n==1) //取的是第一个节点{p=p->next;return p;}while(p!=NULL){if(i==(n-1))//删除节点的前一个节点break;p=p->next;i++;}if(i==(n-1))//存在n-1个节点{q=p->next;p->next=q->next;return q;}else{printf("不存在第%d个节点!\n",n);return NULL;}}/* 输出 *//* 参数 H 为表头节点 */ /* 参数 N 为插入的节点节点 */Link Insert(Link H,Node *N){Node *p,*q; //q保存前一个节点if(N->num < H->num) //插入在表头之前{N->next=H;H=N;return H;}p=H;q=H;while(p!=NULL){if(N->num<=p->num){N->next=q->next;q->next=N;break;}q=p;p=p->next;}if(p==NULL) //插入在最后一个节点之后{q->next=N;N->next=NULL;}return H;}/* 输出 *//* 参数 H 为表头节点 */ int print(Link H){Node *p;p=H;if(p==NULL){printf("\n数据为空!!\n\n");return 0;}printf("\n\t学号\t\t身高\n");while(p){printf("\t %d \t\t%f\n",p->num,p->height);p=p->next;}return 0;}void main(){Link L1,L2;Node *N;printf("1:创建2个链表\n");printf("\n创建链表一\n\n");L1=CreateLink();printf("\n创建链表二\n\n");L2=CreateLink();printf("\n\n2:遍历2个链表\n");printf("\n遍历链表一:\n");print(L1);printf("\n遍历链表二:\n");print(L2);printf("\n\n3:删除第一个链表中的第二个节点 \n\n");L1=Delete(L1,2);printf("删除后的链表一:\n");print(L1);printf("\n\n 4:将第一个链表中的第二个结点移动到第二个链表适当的位置\n\n");printf("获取链表一的第二个节点...\n");N=GetNode(L1,2);printf("将链表一的第二个结点移动到链表二适当的位置");if(N!=NULL)L2=Insert(L2,N);printf("移动后的链表一\n");print(L1);printf("移动后的链表二\n");print(L2);}完成情况:(本部分详细描述运行结果情况,1)完成实验内容的要求;2)展示运行的结果。

c课程设计链表实验报告

c课程设计链表实验报告

c课程设计链表实验报告一、教学目标本节课的教学目标是让学生掌握链表的基本概念和操作,包括链表的定义、节点的结构、链表的创建、插入、删除和遍历等操作。

通过本节课的学习,学生应该能够理解链表的工作原理,熟练使用链表进行数据存储和操作,并能够编写相应的程序实现链表功能。

具体来说,知识目标包括:1.了解链表的定义和特点;2.掌握链表的基本操作及其时间复杂度;3.理解链表在数据存储和处理中的应用场景。

技能目标包括:1.能够使用编程语言实现链表的创建、插入、删除和遍历等基本操作;2.能够分析链表程序的正确性和性能;3.能够运用链表解决实际问题,如实现一个简单的链表排序算法。

情感态度价值观目标包括:1.培养学生的逻辑思维能力和问题解决能力;2.激发学生对计算机科学和编程的兴趣;3.培养学生的团队合作意识和代码规范意识。

二、教学内容本节课的教学内容主要包括链表的基本概念和操作。

具体安排如下:1.链表的定义和特点:介绍链表的概念、节点结构以及链表的两种类型(单向链表和双向链表);2.链表的创建:讲解如何创建一个链表,包括初始化节点和链接节点的方法;3.链表的插入操作:介绍如何在链表中插入一个新节点,包括头插法和中插法的实现;4.链表的删除操作:讲解如何删除链表中的一个节点,包括头删法和中删法的实现;5.链表的遍历操作:介绍如何遍历链表,实现链表中各个节点的访问和打印;6.链表的应用场景:举例说明链表在实际编程中的应用,如链表排序算法。

三、教学方法为了达到本节课的教学目标,将采用以下教学方法:1.讲授法:讲解链表的基本概念和原理,引导学生理解链表的工作方式;2.案例分析法:通过分析典型链表程序,让学生掌握链表的操作方法和技巧;3.实验法:让学生动手编写链表程序,培养学生的实际编程能力和问题解决能力;4.讨论法:学生进行小组讨论,分享学习心得和编程经验,提高学生的团队合作意识。

四、教学资源为了支持本节课的教学内容和教学方法的实施,将准备以下教学资源:1.教材:《数据结构与算法》;2.参考书:《链表:原理与实现》;3.多媒体资料:PPT课件、链表操作视频教程;4.实验设备:计算机、编程环境。

链表的基本操作实验报告

链表的基本操作实验报告

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

链表相较于数组拥有更灵活的操作,能够动态地增删节点。

本实验旨在通过实际操作链表,加深对链表基本操作的理解和掌握。

实验目的:1. 理解链表的基本概念和结构;2. 学会链表的插入、删除和遍历操作;3. 掌握链表的相关算法。

实验过程:1. 创建链表首先,我们需要创建一个链表。

链表可以是单链表、双链表或循环链表,本次实验我们选择创建一个单链表。

创建链表的过程如下:(1)定义一个链表的节点结构,包含数据和指向下一个节点的指针;(2)创建头节点,并将头节点的指针指向NULL,表示链表为空。

2. 插入节点链表的插入操作可以在链表的任意位置插入节点。

我们可以选择在链表的头部、尾部或指定位置插入节点。

下面以在链表头部插入节点为例,介绍插入节点的过程:(1)创建一个新节点,设置新节点的数据;(2)将新节点的指针指向原头节点;(3)将头节点的指针指向新节点,完成插入操作。

3. 删除节点链表的删除操作可以删除链表中的任意节点。

同样,我们可以选择删除链表的头部、尾部或指定位置的节点。

以下是删除链表头部节点的步骤:(1)将头节点的指针指向下一个节点,跳过原头节点;(2)释放原头节点的内存空间。

4. 遍历链表链表的遍历操作用于访问链表中的每个节点。

通过遍历链表,我们可以获取链表中的所有数据或执行特定的操作。

链表的遍历操作如下:(1)从链表的头节点开始,依次访问每个节点;(2)对每个节点执行相应的操作,如打印节点的数据。

实验结果:通过以上实验过程,我们成功地创建了一个链表,并实现了链表的插入、删除和遍历操作。

链表的基本操作能够灵活地处理数据,适用于各种场景。

链表的插入和删除操作可以在O(1)时间内完成,相较于数组的插入和删除操作具有更高的效率。

实验总结:链表作为一种常见的数据结构,具有灵活性和高效性的特点。

链表基本操作实验报告

链表基本操作实验报告

链表基本操作实验报告#include#include#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -1typedef int ElemType ;typedef int Status ;typedef struct LNode {ElemType data ;struct LNode *next ;} *Link,*Position ;typedef struct {Link head,tail;int len;} LinkList;Status InitList ( LinkList &L ){L.head=L.tail=new LNode;L.head->next=L.tail->next=NULL;if(!L.head||!L.tail)return OVERFLOW;L.len=0;return OK;}Status MakeNode(Link &p,ElemType e) { p=new LNode;if(!p)return ERROR;p->data=e;return OK;}void FreeNode(Link &p){delete p;p=NULL;}Status ClearList(LinkList &L) { Link p,q;if(L.head!=L.tail){p=q=L.head->next;L.head->next=NULL;while(p!=L.tail){p=q->next;delete q;q=p;}delete q;L.tail=L.head;L.len=0;}return OK;}Status DestroyList(LinkList &L) { ClearList(L);FreeNode(L.head);L.tail=NULL;L.len=0;return OK;}Status ListEmpty(LinkList L) {if(L.head==NULL)return OVERFLOW; if(L.len)return FALSE;elsereturn TRUE;}int ListLength(LinkList L){return L.len;}Position GetHead(LinkList L){return L.head;}Position GetLast(LinkList L){return L.tail;}Status InsFirst(LinkList &L,Link h,Link s) { h->next=s;s->next=h->next;if(h==L.tail)L.tail=h->next;L.len+=1;return OK;}Status DelFirst(LinkList &L,Link h,Link &q) { q=h->next;h->next=q->next;if(!q)L.tail=h;L.len-=1;return OK;}Status Append(LinkList &L,Link s){Link h;h=L.head;while(h->next!=L.tail)h=h->next;while(s->next!=NULL){h=s;s=s->next;h=h->next;L.len+=1;}s->next=L.tail;L.tail=NULL;return OK;}Status Remove(LinkList &L,Link &q) {Link h;if(ListEmpty(L)==0){q=NULL;return FALSE;}q=L.head;while(q->next!=L.tail)q=q->next;h=q;q=q->next;L.len-=1;return OK;}Position PriorPos(LinkList L,Link p) {Link q=L.head;if(p==q)return NULL;while(q->next!=L.tail){if(q->next==p)return q;q=q->next;}return q;}Status InsBefore(LinkList &L,Link &p,Link s) {Link q;q=PriorPos( L, p);if(!q)q=L.head;q->next=s;s->next=p;p=s;L.len+=1;return OK;}Status LocatePos(LinkList L,int i,Link &p){int j;if(i<=0||i>L.len)return ERROR;else{p=L.head;for(j=1;j<=i;j++)p=p->next;return OK;}}Status compare(ElemType c1,ElemType c2){if(c1==c2)return TRUE;elsereturn FALSE;}Position LocateElem(LinkList L,ElemType e,Status (*compare)(ElemType c1,ElemType c2)) //important{Link p=L.head;while(p!=L.tail){p=p->next;if(compare(e,p->data) )return p;}return FALSE;}int main(){LinkList L;Link p,h,q;int n,j;ElemType e,f;InitList (L);cout<<"请输入项数"<<endl;< bdsfid="292" p=""></endl;<> cin>>n;cout<<"请输入数据"<<endl;< bdsfid="295" p=""></endl;<> for(int i=0;i<n;i++)< bdsfid="297" p=""></n;i++)<>{cin>>e;MakeNode(p, e);InsFirst(L,L.tail,p);}cout<<"输入后的线性表的长度:"<<listlength(l)<<endl;< bdsfid="304" p=""></listlength(l)<<endl;<>DelFirst(L, L.head,q);cout<<"删除数据为:"<<endl;< bdsfid="307" p=""></endl;<> cout<data<<endl;< bdsfid="310" p=""></endl;<>cout<<"删除后的线性表的长度:"<<listlength(l)<<endl;<bdsfid="312" p=""></listlength(l)<<endl;<>cout<<"请输入要查找数据位序"<<endl;< bdsfid="314" p=""></endl;<>cin>>j;LocatePos( L,j,p);cout<data<<endl;< bdsfid="319" p=""></endl;<>cout<<"请输入要查找数据"<<endl;< bdsfid="321" p=""></endl;<>cin>>f;h=LocateElem(L,f,compare); //重要cout<data<<endl;< bdsfid="326" p=""></endl;<>ClearList(L);return 0;}。

C语言链表实验报告

C语言链表实验报告

链表实验报告一、实验名称链表操作的实现--学生信息库的构建二、实验目的(1)理解单链表的存储结构及基本操作的定义(2)掌握单链表存储基本操作(3)学会设计实验数据验证程序【实验仪器及环境】计算机 Window XP操作系统三、实验内容1、建立一个学生成绩信息(学号,姓名,成绩)的单链表,按学号排序2、对链表进行插入、删除、遍历、修改操作。

3、对链表进行读取(读文件)、存储(写文件)四、实验要求(1)给出终结报告(包括设计过程,程序)-打印版(2)对程序进行答辩五、实验过程、详细内容1、概念及过程中需要调用的函数(1)链表的概念结点定义结构的递归定义struct stud_node{int num;char name[20];int score;struct stud_node *next;};(2)链表的建立1、手动输入struct stud_node*Create_Stu_Doc(){struct stud_node *head,*p;int num,score;char name[20];int size=sizeof(struct stud_node);【链表建立流程图】2、从文件中直接获取 先建立一个(3)链表的遍历(4(5)删除结点(6)动态储存分配函数malloc () void *malloc(unsigned size)①在内存的动态存储区中分配一连续空间,其长度为size②若申请成功,则返回一个指向所分配内存空间的起始地址的指针 ③若申请不成功,则返回NULL (值为0) ④返回值类型:(void *) ·通用指针的一个重要用途·将malloc 的返回值转换到特定指针类型,赋给一个指针【链表建立流程图】ptrptrptr->numptr->score ptr=ptr->nexthead pt rs s->next = ptr->next ptr->next = s 先连后断 ptr2=ptr1->nextptr1->next=ptr2->nextfree (ptr2)(7)动态储存释放函数free()当某个动态分配的存储块不再用时,要及时将它释放void free(void *ptr)释放由动态存储分配函数申请到的整块内存空间,ptr为指向要释放空间的首地址。

链表实验报告

链表实验报告

C语言实验报告实验目的:链表的基本操作添加,删除,排序#include <iostream.h>#include <string.h>#include <stdlib.h>struct StuNode{char ID[10];char Name[10];int Height;StuNode *next;};typedef StuNode stulist;void Addafter (stulist * list,char * id,char * name,int height){if(!list||!id) return;StuNode *p=new StuNode;strcpy(p->ID,id);strcpy(p->Name,name);p->Height=height;StuNode *q=list;while(q->next){q=q->next;}q->next=p;p->next=NULL;}void ShowNode(stulist * list){cout<<"现有数据是:"<<endl;StuNode *p=list->next;while(p){cout<<p->ID<<" "<<p->Name<<" "<<p->Height<<endl;p=p->next;}cout<<endl<<"*************************************"<<endl; }void Insert (stulist * list){char Beid[10]="2014002";char id[10]="1112223";char name[10]="狗蛋";int height=177;if(!list||!id) return;StuNode *p=new StuNode;strcpy(p->ID,id);strcpy(p->Name,name);p->Height=height;StuNode *q=list;while(strcmp(q->ID,Beid)!=0){q=q->next;}p->next=q->next;q->next=p;}void Delete(stulist * list){char id[10]="2014001";StuNode *q=list;StuNode *d=q->next;while(strcmp(d->ID,id)!=0){q=q->next;d=d->next;}q->next=d->next;delete d;}void main(){stulist list_1;list_1.next=NULL;char name[10],id[10];int height;Addafter(&list_1,"2014001","张三",175);Addafter(&list_1,"2014002","李四",180);Addafter(&list_1,"2014003","王二",173);Addafter(&list_1,"2014004","麻子",179);ShowNode(&list_1);cout<<"现在添加马六"<<endl;Addafter(&list_1,"2014999","马六",180);ShowNode(&list_1);cout<<"现在把狗蛋插入到李四后面"<<endl;Insert(&list_1);ShowNode(&list_1);cout<<"现在删除张三"<<endl;Delete(&list_1);ShowNode(&list_1);}实验总结:通过学习链表的操作,让知道了C语言和C++是有着紧密联系的,让我能更加熟练了数组,指针,结构体等一些基本的c++语言知识,而且知道了怎么添加修改和排序的一些方法。

双向链表的基本操作和应用实验报告

双向链表的基本操作和应用实验报告

双向链表的基本操作和应用一、实验目的:1.掌握双向线性表的逻辑特征2.熟练掌握带头结点的双向链式表的指针操作、能完成双向链表的插入、删除、获取指定位序结点指针、遍历、和复杂应用;二、实验内容(双向链式线性表)1.熟悉Visual Studio 6.0,会设置断点,会查看运行过程中的指针情况;2.编写双向链表的插入、删除、获取指定位序的结点、遍历函数;3.实现将a1,a2,a3…an的双向链表转变为:a1,a3…a4,a2;三、实验结果#include <stdio.h>typedef struct DuLNode{char date;struct DuLNode *prior;struct DuLNode *next;}DuLNode,*DuLinkList;void DuLinkedListInsert_L(DuLinkList &L, int locate, char c){DuLNode* p=new DuLNode;p->date=c;DuLNode* q=L;for(int j=0;j<locate;j++)q=q->next;p->next=q->next;q->next->prior=p;p->prior=q;q->next=p;++L->date;}// DuLinkedListInsert_Lvoid DuLinkedListDelete_L(DuLinkList &L, int locate, char &e){DuLNode* q=L;for(int j=0;j<locate;j++)q=q->next;e=q->date;q->next->prior=q->prior;q->prior->next=q->next;--L->date;delete q;}// DuLinkedListDelete_Lvoid PrintfDuList(DuLinkList L){DuLNode*p=L->next;while(p!=L){printf("%2c",p->date);p=p->next;}printf("\n");}// PrintfDuListvoid DuLinkedListexchangete_L (DuLinkList &L){char e;DuLNode* q=L;for(int j=2;j< (L->date+3)/2;j++){DuLinkedListDelete_L(L, j, e);DuLinkedListInsert_L(L, L->date-j+2, e);}}// DuLinkedListexchangete_Lvoid main(){char c,e;int i,j;i=0;DuLNode* A=new DuLNode;A->date=0;A->next=A;A->prior=A;printf("请输入A单词,以回车结束:");scanf("%c",&c);while(c!=10){DuLinkedListInsert_L(A, i, c);i++;scanf("%c",&c);}printf("表A的元素个数为:%d\n",A->date);printf("带头结点的双向循环链表A的数据为:\n");PrintfDuList(A);DuLinkedListexchangete_L (A);PrintfDuList(A);printf("表A的元素个数为:%d\n",A->date);printf("请输入要删除在表中的位置:\n");scanf("%d",&j);DuLinkedListDelete_L(A,j,e);printf("被删除的数据为:%c\n",e);printf("被删除数据后的双向循环链表A的数据为:\n");PrintfDuList(A);printf("被删除数据后的双向循环链表A的元素个数为:%d\n",A->date);}四、实验中遇到的问题及解决方法遇到的问题:能不能利用修改原表实现数据重排功能。

链表-实验报告

链表-实验报告

实验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.裁图说明实验结果【心得体会、问题和建议】成绩:指导教师签名批阅日期:。

链表的基本操作实验报告

链表的基本操作实验报告

《数据结构》实验报告学号1445203105 姓名王胜博班级软件5班成绩实验名称实验三链表的基本操作是否原创是一、实验要求编程实现链表下教材第二章定义的线性表的基本操作,最好用菜单形式对应各个操作,使其编程一个完整的小软件。

二、实验目的通过该实验,深入理解链表的逻辑结构、物理结构等概念,掌握链表基本操作的编程实现,熟练掌握C语言中指针的操作。

和实验2对比,掌握线性结构两种不同存储方式的区别。

三、设计思想用函数执行各个功能,随机插入元素四、主要源代码#include<stdio.h>#include<stdlib.h>#include<time.h>typedef int ElemType;typedef struct Node{ElemType data;struct Node *next;}Node, *LinkList;void InitList(LinkList *L){*L=(LinkList)malloc(sizeof(Node));if(!(*L))printf("存储分配失败\n");(*L)->next=NULL;}void DestroyList(LinkList L){LinkList p;while(L){p=L->next;free(L);L=p;}}int ListLength(LinkList L){LinkList p;int i=0;p=L->next;while(p){i++;p=p->next;}return i;}int GetElem(LinkList L,int i,ElemType &e){ LinkList p;p=L->next;int j=1;while(p&&j<i){p=p->next;++j;}e=p->data;return e;}int GetElemLo(LinkList L,int i,ElemType &e){ LinkList p;p=L->next;int j=1;while(p->data!=i&&j<=ListLength(L)){p=p->next;++j;}e=j;return e;}void FindPre(LinkList L,int x){LinkList p;p=L;if(p->next->data==x){printf("第一个元素没有前驱\n");}else{while(p->next){if(p->next->data==x){printf("%d的前驱结点是:%d\n",x,p->data);break;}else{p=p->next;}}}}void FindNext(LinkList L,int x){LinkList p;p=L->next;while(p){if(p->data==x){printf("%d的后继结点是:%d\n",x,p->next->data);break;}else{p=p->next;}if(p->next==NULL){printf("最后一个元素没有后继\n");break;}}}void LinkInset_L(LinkList &L,int i,ElemType e){ LinkList p;p=L;int j=0;while(p&&j<i-1){p=p->next;++j;}if(!p||j>i-1)printf("i小于1或者i大于表长加1\n");LinkList s;s=(LinkList)malloc(sizeof (Node));s->data=e;s->next=p->next;p->next=s;}void ListDelete_L(LinkList &L,int i,ElemType &e){ LinkList p,q;p=L;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!p->next ||j>i-1)printf("删除位置不合理\n");q=p->next;p->next=q->next;e=q->data;free(q);printf("已删除的元素是:%d\n",e);}void visit(ElemType e){printf("%d,",e);}void ListTraverse(LinkList L){LinkList p=L->next;while(p){visit(p->data);p=p->next;}printf("\n");}void CreatListTail(LinkList *L,int n){LinkList p,r;int i;srand(time(0));*L=(LinkList)malloc(sizeof(Node));r=*L;for(i=0;i<n;i++){p=(Node *)malloc(sizeof(Node));p->data=rand()%100+1;r->next=p;r=p;}r->next=NULL;}int main(){LinkList L;int opp;printf("可执行的操作有:\n");printf("1.初始化或重置链表\n");printf("2.随机插入元素\n");printf("3.显示链表中数据元素个数\n");printf("4.输出所输入的链表元素\n");printf("5.所指位序的元素值\n");printf("6.链表已存在元素的位序\n");printf("7.请输入元素,求直接前驱\n");printf("8.请输入元素,求直接后继\n");printf("9.在第i个位置插入元素\n");printf("10.删除第i个元素\n");printf("11.销毁链表\n");printf("12.退出\n");printf("\n");printf("请输入你的选择:\n");do{scanf("%d",&opp);switch(opp){case 1:{InitList(&L);printf("链表已初始化\n");printf("下一步操作:");break;}case 2:{int n;printf("输入插入元素个数:");scanf("%d",&n);CreatListTail(&L,n);printf("下一步操作:");break;}case 3:{printf("链表中元素的个数是:%d\n",ListLength(L));printf("下一步操作:");break;}case 4:{ListTraverse(L);printf("下一步操作:");break;}case 5:{int m,e;printf("输入要取元素的位置:");scanf("%d",&m);if(m>ListLength(L)){printf("输入有误\n");}else{GetElem(L,m,e);printf("该元素是:%d\n",e);}printf("下一步操作:");break;}case 6:{int i,e;printf("输入要取的元素:");scanf("%d",&i);GetElemLo(L,i,e);printf("该元素的位置是:%d\n",e);printf("下一步操作:");break;}case 7:{int x;printf("要求哪个元素的前驱?");scanf("%d",&x);FindPre(L,x);printf("下一步操作:");break;}case 8:{int x;printf("要求哪个元素的后继?");scanf("%d",&x);FindNext(L,x);printf("下一步操作:");break;}case 9:{int i,e;printf("在哪个位置插入元素?");scanf("%d",&i);if(i>ListLength(L))printf("输入有误\n");else{printf("插入的新元素是:");scanf("%d",&e);LinkInset_L(L,i,e);printf("新链表:");ListTraverse(L);}printf("下一步操作:");break;}case 10:{int i,e;printf("要删除哪个位置的元素?");scanf("%d",&i);if(i>ListLength(L))printf("输入有误\n");else{ListDelete_L(L,i,e);printf("新链表:");ListTraverse(L);}printf("下一步操作:");break;}case 11:{DestroyList(L);printf("链表已销毁!\n");printf("下一步操作:");break;}case 12:{printf("谢谢使用\n");break;}default:{printf("输入错误,请重新输入\n");break;}}}while(opp!=12);return 0;}五、调试与测试数据六、实验总结。

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

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

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

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

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

如:单链表建立、输出、插入、删除、查找等操作。

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

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

要求:同学们可参考指导书实验2程序、教材算法及其他资料编程实现单链表相关操作。

必须包括单链表创建、输出、插入、删除操作,其他操作根据个人情况增减。

三、 算法分析与设计。

头结点......2.单链表插入s->data=x; s->next=p->next; p->next=s;3.单链表的删除:p->next=p->next->next;四、运行结果1.单链表初始化2.创建单链表3.求链表长度4.检查链表是否为空5.遍历链表6.从链表中查找元素7.从链表中查找与给定元素值相同的元素在顺序表中的位置8.向链表中插入元素插入元素之后的链表9.从链表中删除元素删除位置为6的元素(是3)10.清空单链表五、实验体会经过这次单链表基本操作实验,自己的编程能力有了进一步的提高,认识到自己以前在思考一个问题上思路不够开阔,不能灵活的表达出自己的想法,虽然在打完源代码之后出现了一些错误,但是经过认真查找、修改,最终将错误一一修正,主要是在写算法分析的时候出现了障碍,经过从网上查找资料,自己也对程序做了仔细的分析,对单链表创建、插入、删除算法画了详细的N-S流程图。

六、C语言版原代码# include<stdio.h># include<stdlib.h>/* 定义ElemType 为int类型*/typedef int ElemType;# define TRUE 1# define FALSE 0# define NULL 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;return L;}/*清空单链表*/void LinkedListClear(LinkedList L){L->next=NULL;printf("链表已经清空\n");}/*检查单链表是否为空*/int LinkedListEmpty(LinkedList L){if(L->next==NULL) return TRUE;else return FALSE;}/*遍历单链表*/void LinkedListTraverse(LinkedList L) {LinkedList p;p=L->next;if(p==NULL) printf("单链表为空表\n");else{printf("链表中的元素为:\n");while(p!=NULL){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;}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;}int LinkedListLocate(LinkedList L,ElemType x) {LinkedList p;int j;p=L->next;j=1;while(p!=NULL&&p->data!=x){p=p->next;j++;}if(p) return j;else return 0;}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));s->data=x;s->next=p->next;p->next=s;printf("%d 已插入到链表中\n",x);}}void LinkedListDel(LinkedList L,int i) {LinkedList p,q;int j;j=1;p=L;while(p->next&&j<i){p=p->next;j++;}if(p->next==NULL)printf("删除位置不正确\n");else{q=p->next;p->next=q->next;free(q);printf("第%d 个元素已从链表中删除\n",i);}}LinkedList LinkedListCreat(){LinkedList L=LinkedListInit(),p,r;ElemType x;r=L;printf("请依次输入链表中的元素,输入-1结束\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 scan(){int d;printf("请选择要进行的操作\n");printf("-------------------------------------------------------\n"); printf("1.初始化 2.清空 3.求链表长度 4.检查链表是否为空\n"); printf("-------------------------------------------------------\n"); printf("5.遍历链表 6.从链表中查找元素\n");printf("-------------------------------------------------------\n"); printf("7.从链表中查找与给定元素值相同的元素在顺序表中的位置\n"); printf("-------------------------------------------------------\n"); printf("8.向链表中插入元素 9.从链表中删除元素 10创建线性表\n"); printf("-------------------------------------------------------\n"); printf("其他键退出。

\n");printf("输入: ");scanf("%d",&d);return(d);}main(){int quit=0;int i,locate;ElemType e;LinkedList L,p;while(!quit)switch(scan()){case 1:L=LinkedListInit();printf("\n");break;case 2:LinkedListClear(L);printf("\n");break;case 3:printf("链表长度为 %d\n",LinkedListLength(L));break;case 4:if(LinkedListEmpty(L))printf("链表为空\n");else printf("链表非空\n");break;case 5:LinkedListTraverse(L);break;case 6:printf("请输入待查询元素在链表中的位置:");scanf("%d",&i);p=LinkedListGet(L,i);if(p) printf("链表第%d个元素的值为:%d\n",i,p->data);else printf("查询位置不正确\n");break;case 7:printf("请输入待查询元素的值:");scanf("%d",&e);locate=LinkedListLocate(L,e);if(locate)printf("%d在链表中的位置是:%d\n",e,locate);else printf("链表中没有值为%d的元素\n",e);break;case 8:printf("请输入插入元素的位置和值(中间以空格或回车分隔):\n");scanf("%d%d",&i,&e);LinkedListInsert(L,i,e);break;case 9:if(LinkedListLength(L)==0)printf("链表已经为空,不能删除!\n");else{printf("请输入待删除元素的位置: ");scanf("%d",&i);LinkedListDel(L,i);}break;case 10:L=LinkedListCreat();printf("\n");break;default:quit=1;}}。

相关文档
最新文档