数据结构上机报告:编写一个程序,实现单链表的各种基本运算

合集下载

数据结构上机报告:编写一个程序,实现单链表的各种基本运算

数据结构上机报告:编写一个程序,实现单链表的各种基本运算

《数据结构》上机报告_2011_年_ 3 _月_ 9 _日姓名_____ 学号_ _ 同组成员 __ _无_ __1.实验题目及要求编写一个程序,实现单链表的各种基本运算2.需求分析建立一个单链表,实现单链表的初始化,插入、删除节点等功能,以及确定某一元素在单链表中的位置。

(1)初始化单链表;(2)依次采用尾插入法插入a,b,c,d,e元素;(3)输出单链表L;(4)输出单链表L的长度;(5)判断单链表L是否为空;(6)输出单链表L的第三个元素;(7)输出元素a的位置;(8)在第4个元素位置上插入f元素;(9)输出单链表L;(10)删除L的第3个元素;(11)输出单链表L;(12)释放单链表。

3.概要设计(1)为了实现上述程序功能,需要定义一个简化的线性表抽象数据类型:ADT LinearList {数据对象:D={ a i|a i∈IntegerSet,i=0,1,2,…,n,n≥0}结构关系:R={<a i,a i+1>|a i,a i+1 ∈D}基本操作:InitList_L(L)操作前提:L是一个未初始化的线性表操作结果:将L初始化为一个空的线性表CreateList_L(L)操作前提:L是一个已初始化的空表操作结果:建立一个非空的线性表LListInsert_L(L,pos,e)操作前提:线性表L已存在操作结果:将元素e插入到线性表L的pos位置ListDelete_L(L,pos,e)操作前提:线性表L已存在操作结果:将线性表L中pos位置的元素删除,删除的元素值通过e返回LocateList_L(L,e)操作前提:线性表L已存在操作结果:在线性表L中查找元素e,若存在,返回元素在表中的序号位置;若不存在,返回-1DestroyList_L(&L)初始条件:线性表L已存在操作结果:销毁线性表ListEmpty_L(L)初始条件:线性表已存在操作结果:若L为空表,则返回ERROR,否则返回FALSEListLength_L(L)初始条件:线性表L已存在操作结果:返回L中数据元素个数GetElem_L(L,I,&e)初始条件:线性表L已存在操作结果:用e返回L中第i个数据元素值}(2)本程序包含10个函数:主函数main()初始化单链表函数InitList_L()显示单链表内容函数DispList_L()插入元素函数ListInsert_L()删除元素函数ListDelete_L()查找元素函数LocateList_L()创建链表函数CreateList_L()链表元素长度函数ListLength_L()判断链表是否为空函数ListEmpty_L()取值函数GetElem_L()各函数间调用关系如下:( 3 ) 主函数的伪码main(){ 说明一个单链表 L ; 初始化 L ; 建立 L ; 显示 L ; }4. 详细设计采用单链表实现概要设计中定义的抽象数据类型,有关的数据类型和伪码算法定义mainInitList DispList CreateList ListLength ListEmptyDestroyList GetElem ListInsert ListDelete LocateElem如下:(1)类型定义typedef int ElemType;typedef struct LNode{ ElemType data; //数据域struct LNode *next; //指针域} LNode,* LinkList;(2)基本操作的伪码算法初始化Bool InitLinkList(LinkList *L){ *L=申请新结点;如果申请失败,返回失败标志;(*L)->next=NULL;返回成功标志;}建立单链表Bool CrtLinkList(LinkList L)/* L是已经初始化好的空链表的头指针,通过键盘输入元素值,利用尾插法建单链表L */{ rear=L;打印输入提示:“请输入若干个正整数(用空格分隔),并用 -1 结束:”读入一个数x;当x不是结束标志时,循环做如下处理:{申请一个新结点s;如果申请失败,返回失败标志;将x送到s的data域;rear->next=s;rear=s;读入下一个数x;}rear->next=NULL;返回成功标志;}显示单链表(输出)void DispLinkList(LinkList L){p=首元素结点地址;while ( p不空 ){打印结点p 的元素值;p=下一个结点地址;}}插入操作bool InsLinkList(LinkList L, int pos, ElemType e)/*在带头结点的单链表L中第pos个位置插入值为e的新结点s*/ {从“头”开始,查找第i-1个结点 pre ;if (查找失败){ 显示参数错误信息;return ERROR;}else{申请一个新的结点s ;将e放入s的数据域;将s 插到pre 后面;return OK;}}删除操作bool DelLinkList(LinkList L, int pos, ElemType *e)/* 在带头结点的单链表L中删除第pos个元素,并将删除的元素保存到变量*e中 */ {查找待删除结点i的前驱结点,并用pre指向它;if (查找失败){ 显示参数错误信息;return ERROR;}else{r=pre->next;修改指针,删除结点r ;释放被删除的结点所占的内存空间;return OK;}}查找操作int LocLinkList(LinkList L, ElemType e)/ * 在带头结点的单链表L中查找其结点值等于e的结点,若找到则返回该结点的序号位置k,否则返回 -1 * /{p=首元素结点地址;while ( p不空 )if (p->data!=e){ p=p->next; k++; }else break;if ( p 不空 ) return k;else return -1;}5.调试分析开始运行时会出现Debug Error,DAMAGE: After Normal block,搜索后了解到是内存越界操作,检查后发现内存分配L和S=(LinkList)malloc(sizeof(LNode))写成了=(LinkList)malloc(sizeof(LinkList)),修改后正常。

数据结构上机操作实验报告

数据结构上机操作实验报告

实验一单链表的基本操作(必做)一、实验目的1.掌握单链表的存储、初始化、插入、删除等操作的程序实现。

2.加深对单链表基本概念,基本理论及相应算法的掌握与理解。

3.了解链表的处理方式,学习体会简单的单链表程序实现相关知识。

二、实验内容1.建立一个链表、设计链表的基本操作实现算法、输出一个链表表,调试并输出结果。

2.编写一个程序实现如下功能:让计算机产生出50个0~9之间的随机数并依次保存到单链表中;输出遍历单链表;从单链表中删除与给定值相等的所有结点;输出遍历单链表;输出单链表长度,调试并输出结果。

三、实验步骤1.定义一个链表结构体。

2.利用插入功能插入一个结点。

3.利用删除功能删除一个结点。

四、程序运行测试1.利用插入功能插入一个结点。

2.利用删除功能删除一个结点。

五、实验报告要求1.绘制链表操作实现的流程图。

2.详细给出程序运行测试结果(包括测试数据和测试结果)。

3.选试验步骤2-3中的任意一个,给出程序的详细注释。

4.参考程序中某一部分功能的改进(选做)5.实验心得与体会6.附录,实验用源程序六、参考源代码#include <iostream.h>#include <malloc.h>typedef struct LNode{int data;struct LNode *next;}Lnode, *LinkList;//假设下面的单链表均为带头结点。

void CreatLinkList(LinkList &L,int j){//建立一个单链表L,数据为整数,数据由键盘随机输入。

LinkList p,q;L=(LinkList )malloc(sizeof(Lnode));L->next=NULL;q=L;cout<<"在单链表内输入整数:"<<endl;for(int i=0;i<j;i++) p=(LinkList)malloc(sizeof(Lnode)); cin>>p->data;p->next=q->next;q->next=p;q=p; }int PrintLinkList(LinkList &L){//输出单链表L的数据元素LinkList p;p=L->next;if(L->next==NULL){cout<<"链表没有元素!"<<endl;return 0;}cout<<"单链表的数据元素为:";while(p){cout<<p->data<<" ";p=p->next;}cout<<endl;return 1;}void LinkListLengh(LinkList &L){//计算单链表L的数据元素个数。

数据结构单链表实验报告

数据结构单链表实验报告

数据结构单链表实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中的单链表概念、原理和操作方法,通过实际编程实现单链表的创建、插入、删除、查找等基本操作,提高对数据结构的实际应用能力和编程技能。

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

三、实验原理单链表是一种常见的数据结构,它由一系列节点组成,每个节点包含数据域和指针域。

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

单链表的优点是可以动态地分配内存,灵活地插入和删除节点,但其缺点是访问特定位置的节点需要从头开始遍历,时间复杂度较高。

四、实验内容(一)单链表的创建创建单链表的基本思路是依次创建节点,并将节点通过指针链接起来。

以下是创建单链表的代码实现:```cppinclude <iostream>using namespace std;//定义链表节点结构体struct ListNode {int data;ListNode next;ListNode(int x) : data(x), next(NULL) {}};//创建单链表ListNode createList(){int num, value;cout <<"请输入节点个数: ";cin >> num;ListNode head = NULL;ListNode tail = NULL;for (int i = 0; i < num; i++){cout <<"请输入第"<< i + 1 <<"个节点的值: ";cin >> value;if (head == NULL) {head = newNode;tail = newNode;} else {tail>next = newNode;tail = newNode;}}return head;}```(二)单链表的插入操作单链表的插入操作可以分为在表头插入、在表尾插入和在指定位置插入。

数据结构实验报告实现单链表各种基本运算的算法

数据结构实验报告实现单链表各种基本运算的算法

实验截图(1)void InitList(LinkNode *&L)//初始化线性表{L=(LinkNode *)malloc(sizeof(LinkNode)); //创建头结点L->next=NULL;//单链表置为空表}void DestroyList(LinkNode *&L)//销毁线性表{LinkNode *pre=L,*p=pre->next;实验截图(2)bool GetElem(LinkNode *L,int i,ElemType &e) //求线性表中第i个元素值{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L;//p指向头结点,j置为0(即头结点的序号为0) while (j<i && p!=NULL)//找第i个结点p{ j++;p=p->next;}if (p==NULL)//存在值为e的结点,返回其逻辑序号ireturn(i);}实验截图(3)bool ListInsert(LinkNode *&L,int i,ElemType e) //插入第i个元素{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L,*s;//p指向头结点,j置为0(即头结点的序号为0) while (j<i-1 && p!=NULL)//查找第i-1个结点p{ j++;p=p->next;}}实验截图(4)编写exp2-2.cpp程序包含有关代码//文件名:exp2-2.cpp#include "linklist.cpp"int main(){LinkNode *h;ElemType e;printf("单链表的基本运算如下:\n");printf(" (1)初始化单链表h\n");InitList(h);printf(" (2)依次采用尾插法插入a,b,c,d,e元素\n");return 1;}实验截图(5)运行得到结果实验截图(6)。

单链表基本操作的实现

单链表基本操作的实现

单链表基本操作的实现单链表是一种常见的数据结构,它由多个节点组合而成,每个节点包含一个数据元素和一个指向下一个节点的指针。

通过指针,我们可以方便地在单链表中进行插入、删除和遍历等操作。

以下是关于单链表基本操作的实现。

1. 单链表的创建单链表的创建需要定义一个空的头结点,它的作用是方便在链表的头部进行添加和删除节点操作。

一个空的头节点可以在链表初始化的过程中进行创建。

```typedef struct Node{int data;struct Node *next;}Node;Node *createList(){Node *head = (Node*)malloc(sizeof(Node)); //创建空的头节点head->next = NULL;return head; //返回头节点的地址}```2. 单链表的插入单链表的插入可以分为在链表头部插入、在链表尾部插入和在链表中间插入三种情况。

a. 在链表头部插入节点:```void insertAtHead(Node *head, int data){Node *node = (Node*)malloc(sizeof(Node));node->data = data;node->next = head->next;head->next = node;}```b. 在链表尾部插入节点:```void insertAtTail(Node *head, int data){Node *node = (Node*)malloc(sizeof(Node));node->data = data;node->next = NULL;Node *p = head;while(p->next != NULL){p = p->next;}p->next = node;}```c. 在链表中间插入节点:```void insertAtMid(Node *head, int data, int pos){ Node *node = (Node*)malloc(sizeof(Node)); node->data = data;node->next = NULL;Node *p = head;int count = 0;while(p->next != NULL && count < pos-1){ p = p->next;count++;}if(count == pos-1){node->next = p->next;p->next = node;}else{printf("插入位置错误!");}}```3. 单链表的删除单链表的删除可以分为在链表头部删除、在链表尾部删除和在链表中间删除三种情况。

单链表的基本操作

单链表的基本操作

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

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

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

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

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

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

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

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

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

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

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

数据结构 实验一:实现单链表各种基本运算的算法

数据结构 实验一:实现单链表各种基本运算的算法

- 1 -实验一:实现单链表各种基本运算的算法一、 实验目的1、 掌握单链表存储结构的类型定义;2、 实现单链表各种基本运算的算法。

二、 实验环境1、 Windows 操作系统;2、 Visual C++ 6.0三、 实验内容实现单链表各种基本运算的算法。

四、 概要设计1.存储结构的类型定义:Typedef struct LNode{ElemType data;Struct LNode *next;}LinkList;2.单链表示意图:3.项目组成图:4.algo2_2.cpp 的程序文件包含的函数原型及功能:InitList(LinkList *&L) 初始化单链表LDestroyList(LinkList *&L) 释放单链表LListEmpty(LinkList *L)判断单链表L 是否为空表ListLength(LinkList *L)返回单链表L 的元素个数DispList(LinkList *L)输出单链表LGetElem(LinkList *L,int i,ElemType &e)获取单链表L 的第i 个元素LocateElem(LinkList *L,ElemType e)在单链表L 中查找元素eListInsert(LinkList *&L,int i,ElemType e)在单链表L 中的第i 个位置上插入元素e…… head a 1 a 2 a 3 a n ∧ListDelete(LinkList *&L,int i,ElemType &e)在单链表L中删除第i个元素5.exp2_2.cpp程序文件简介:InitList(LinkList *&L) 初始化单链表LDestroyList(LinkList *&L) 释放单链表LListEmpty(LinkList *L) 判断单链表L是否为空表ListLength(LinkList *L) 返回单链表L的元素个数DispList(LinkList *L) 输出单链表LGetElem(LinkList *L,int i,ElemType &e) 获取单链表L的第i个元素LocateElem(LinkList *L,ElemType e) 在单链表L中查找元素eListInsert(LinkList *&L,int i,ElemType e) 在单链表L中的第i个位置上插入元素e ListDelete(LinkList *&L,int i,ElemType &e) 在单链表L中删除第i个元素6.proj2-2的项目的模块结构:在文件algo2-2中,(1)定义单链表结构类型;(2)初始化单链表(3)定义释放单链表的函数(4)定义判断单链表是否为空的函数(5)定义返回单链表元素个数的函数(6)定义输出单链表的函数(7)定义获取第i个元素的函数(8)定义查找元素的函数(9)定义插入元素的函数(10)定义删除元素的函数在文件exp2-2中分别调用algo2-2中所定义的函数7.函数调用关系图:五、详细设计源代码清单见附录。

实现单链表的各种基本运算。

实现单链表的各种基本运算。

实现单链表的各种基本运算。

单链表是一种常用的数据结构,它由一个头指针和一些节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。

单链表具有插入、删除、查找、排序等基本运算。

下面将介绍如何实现单链表的各种基本运算。

1. 创建单链表
首先需要定义一个节点结构,包含数据域和指针域。

然后声明一个头指针,表示单链表的头节点。

接着输入节点数据,逐个创建新节点,并将其插入链表中。

2. 插入节点
在单链表中插入节点有两种情况:插入到链表头部和插入到链表尾部。

插入节点时需要先找到插入位置的前一个节点,然后修改前一个节点的指针域,将其指向新节点,再修改新节点的指针域,将其指向插入位置的后一个节点。

3. 删除节点
在单链表中删除节点也有两种情况:删除链表头部的节点和删除链表任意位置的节点。

删除节点时需要先找到删除位置的前一个节点,然后修改前一个节点的指针域,将其指向待删除节点的后一个节点,最后释放待删除节点的空间。

4. 查找节点
在单链表中查找节点时需要从头节点开始遍历链表,逐个比较节点值,直到找到目标节点或者遍历到链表尾部为止。

5. 排序
单链表排序可以采用冒泡排序、选择排序、快速排序等多种算法。

其中最简单的是冒泡排序,即从头节点开始遍历链表,逐个比较相邻节点的值,如果前一个节点的值大于后一个节点的值,则交换两个节点的值,直到遍历到链表尾部为止。

以上就是单链表的各种基本运算的实现方法,其它高级运算(如合并链表、反转链表等)可以在此基础上进一步扩展。

单链表的各种基本运算的实现 实验报告

单链表的各种基本运算的实现  实验报告

软件技术基础实验一——单链表的各种基本运算的实现一、实验题目编写一个程序,实现单链表的各种基本运算,并在此基础上设计一个主程序完成如下功能:(1)初始化单链表(2)依次采用尾插法插入a,b,c,d,e元素(3)输出单链表(4)在第四个元素位置上插入f元素(5)删除该单链表的第三个元素二、实验目的1、理解单链表的概念及结构特点;2、掌握单链表的基本操作:查找、插入、删除等运算在链接存储结构上的运算。

三、调试通过并正确执行给定功能要求的实验代码#include "stdafx.h"#include<malloc.h>#include<iostream.h>struct link{char data;link *next;};link *rcreat(link *head,char x) //尾插法建立单链表{link *s,*r;r=head;s=new link;s->data=x;r->next=s;r=s;r->next=NULL;return r;}link *get(link *head,int i) //查找第i个元素,返回其地址{int j;link *p;j=1;p=head->next ;while((j<i-1)&&(p!=NULL)){j++;p=p->next;}return p;}void insert(link *head,int num,char y) //元素y之后插入x {link *p,*s;s=new link;s->data=y;if(head->next==NULL){head->next=s;s->next=NULL;}p=get(head,num);if(p==NULL) cout<<"插入位置非法";else{s->next=p->next;p->next=s;}}void delet(link *head,char x) //将指定元素x删除{link * p, * q;q=head;p=head->next;while((p!=NULL)&&(p->data!=x)){q=p;p=p->next;}if(p==NULL) cout<<"要删除的元素不存在";else{q->next=p->next;delete(p);}}void print(link *head) //输出单链表{link *p;p=head->next;while(p->next!=NULL){cout<<p->data<<"->";p=p->next;}cout<<p->data<<endl;}void main(int argc, char* argv[]){link *head,*p,*q,*r;char x,y;int n,dele,i=1,j=1;head=new link;head->next=NULL;r=head;while(j<=5){cout<<"请输入要插入的元素:";cin>>x;r=rcreat(r,x);j=j+1;}print(head);cout<<"请输入要插入元素的位置:";cin>>n;cout<<"请输入要插入的元素:";cin>>y;insert(head,n,y);cout<<"输出插入后的单链表:"<<endl;print(head);cout<<"请输入要删除元素的位置:";cin>>dele;q=head;p=head->next;while(i<dele){q=p;p=p->next;i=i+1;}q->next=p->next;delete (p);cout<<"删除后的链表如下:"<<endl;print(head);}四、实验结果。

单链表的实现实验报告

单链表的实现实验报告

单链表的实现实验报告篇一:数据结构单链表实验报告一、设计人员相关信息1. 设计者姓名、学号和班号:12地信李晓婧120122429832. 设计日期:2014.3. 上机环境:VC++6.0二、程序设计相关信息1. 实验题目:编写一个程序,实现单链表的各种基本运算(假设单链表的元素类型为char),并在此基础上设计一个程序,完成如下功能:(1)初始化单链表;(2)采用尾插法依次插入元素a,b,c,d,e;(3)输出单链表(4)输出单链表长度(5)判断单链表是否为空(6)输出单链表第3个元素(7)输出元素a的位置(8)在第4个元素位置上插入元素f(9)输出单链表(10)删除第三个元素(11)输出单链表(12)释放单链表2. 实验项目组成:(1)插入和删除节点操作(2)建立单链表尾插法建表(3)线性表基本运算在单链表中的实现初始化线性表销毁线性表判断线性表是否为空表求线性表的长度3. 实验项目的程序结构(程序中的函数调用关系图):4. 实验项目包含的各个文件中的函数的功能描述:? 尾插法建表CreateListR:将新节点插到当前链表的表尾上,为此必须增加一个尾指针r,使其始终指向当前链表的尾节点。

? 初始化线性表InitList:该运算建立一个空的单链表,即创建一个头节点;? 销毁线性表DestroyList:释放单链表占用的内存空间,即逐一释放全部节点的空间; ? 判断线性表是否为空表ListEmpty:若单链表没有数据节点,则返回真,否则返回假; ? 求线性表的长度ListLength:返回单链表中数据节点的个数;? 输出线性表DispList:逐一扫描单链表的每个数据节点,并显示各节点的data域值;? 求线性表中某个数据元素值GetElem:在单链表中从头开始找到第i个节点,若存在第i个数据节点,则将其data域值赋给变量e;? 按元素值查找LocateElem:在单链表中从头开始找第一个值域与e相等的节点,若存在这样的节点,则返回逻辑序号,否则返回0;? 插入数据元素ListInsert:先在单链表中找到第i1个节点*p,若存在这样的节点,将值为e的节点*s插入到*p节点的后面;? 删除数据元素ListDelete:先在单链表中找到第i1个节点*p,若存在这样的节点,且也存在后继节点*q;删除*q节点,返回TRUE;否则返回FALSE表示参数i错误。

数据结构单链表实验报告记录

数据结构单链表实验报告记录

数据结构单链表实验报告记录————————————————————————————————作者:————————————————————————————————日期:一、设计人员相关信息1.设计者姓名、学号和班号:12地信李晓婧120122429832.设计日期:2014.3.上机环境:VC++6.0二、程序设计相关信息1.实验题目:编写一个程序,实现单链表的各种基本运算(假设单链表的元素类型为char),并在此基础上设计一个程序,完成如下功能:(1)初始化单链表;(2)采用尾插法依次插入元素a,b,c,d,e;(3)输出单链表(4)输出单链表长度(5)判断单链表是否为空(6)输出单链表第3个元素(7)输出元素a的位置(8)在第4个元素位置上插入元素f(9)输出单链表(10)删除第三个元素(11)输出单链表(12)释放单链表2.实验项目组成:(1)插入和删除节点操作(2)建立单链表尾插法建表(3)线性表基本运算在单链表中的实现初始化线性表销毁线性表判断线性表是否为空表求线性表的长度3.实验项目的程序结构(程序中的函数调用关系图):MainLinkListInitListCreateListRDispListListLengthListEmptyGetElemLocateElemListInsertListDeleteDestroyList4.实验项目包含的各个文件中的函数的功能描述:●尾插法建表CreateListR:将新节点插到当前链表的表尾上,为此必须增加一个尾指针r,使其始终指向当前链表的尾节点。

●初始化线性表InitList:该运算建立一个空的单链表,即创建一个头节点;●销毁线性表DestroyList:释放单链表占用的内存空间,即逐一释放全部节点的空间;●判断线性表是否为空表ListEmpty:若单链表没有数据节点,则返回真,否则返回假;●求线性表的长度ListLength:返回单链表中数据节点的个数;●输出线性表DispList:逐一扫描单链表的每个数据节点,并显示各节点的data域值;●求线性表中某个数据元素值GetElem:在单链表中从头开始找到第i个节点,若存在第i个数据节点,则将其data域值赋给变量e;●按元素值查找LocateElem:在单链表中从头开始找第一个值域与e相等的节点,若存在这样的节点,则返回逻辑序号,否则返回0;●插入数据元素ListInsert:先在单链表中找到第i-1个节点*p,若存在这样的节点,将值为e的节点*s插入到*p节点的后面;●删除数据元素ListDelete:先在单链表中找到第i-1个节点*p,若存在这样的节点,且也存在后继节点*q;删除*q节点,返回TRUE;否则返回FALSE表示参数i错误。

数据结构实验报告-单链表的基本操作

数据结构实验报告-单链表的基本操作

湖南文理学院实验报告课题名称:数据结构实验实验名称:单链表的基本操作学生姓名:学号:专业:计算机科学与技术班级:计科11102班实验日期:2012.11.02成绩:一、实验目的1.学会定义单链表的结点类型,实现对单链表的一些基本操作和具体的函数定义,了解并掌握单链表的类定义以及成员函数的定义与调用。

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

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

(2)在La中插入一个新结点。

(3)删除La中的某一个结点。

(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所指的结点之后。

三、实验源代码1.建立新链表void INlist(linklist&head,int n){linklist q;head=(list*)malloc(LEN);head->next=NULL;q=head;for(int i=0;i<n;i++){p=(list*)malloc(LEN);scanf("%d",&(p->data));p->next=NULL;q->next=p;q=p;}q->next=NULL;p=head;//head=head->next;}2.输出链表void printlist(linklist L){L=L->next;while(L){printf("%d",L->data);L=L->next;}printf("\n");}3.插入节点bool listinsert(linklist&L,int n){p=L;linklist q;int j=0;while(p&&j<n-1){p=p->next;j++;}if(!p||j>n-1)return false;q=(list*)malloc(LEN);printf("请输入你需要的值:");scanf("%d",&(q->data));q->next=p->next;p->next=q;return true;}4.删除节点bool delist(linklist&L,int n){p=L;linklist q;int i=0;if(p->next==NULL)return false;/*if(n==1){q=p;p=p->next;free(q);}*/while(p->next&&i<n-1){p=p->next;i++;}if(!(p->next)&&i>n-1)return false;q=p->next;printf("删除的值为:%d\n",q->data);p->next=q->next;free(q);return true;}5.合并两个链表void merlist(linklist&La,linklist&Lb,linklist&Lc){linklist pa,pb;Lc=p=La;pb=Lb->next;pa=La->next;while(pa&&pb){if(pa->data<=pb->data){p->next=pa;p=pa;pa=pa->next;} else{p->next=pb;p=pb;pb=pb->next;}}p->next=pa?pa:pb;free(Lb);}6.主函数int main(){int n;linklist la,lb,lc;printf("请输入第一个链表的长度:");scanf("%d",&n);printf("请输入这些数:");INlist(la,n);printf("输入这些数为:");printlist(la)printf("请输入你需要在哪个节点前插入:");scanf("%d",&n);if(listinsert(la,n))printf("插入成功!\n");elseprintf("失败!\n");printf("输出这些数为:");printlist(la);printf("请输入第二个链表的长度:");scanf("%d",&n);printf("请输入这些数:");INlist(lb,n);printf("输出这些数为:");printlist(lb);printf("请输入你需要删除哪个节点:");scanf("%d",&n);if(delist(lb,n))printf("删除成功!\n");else printf("失败!\n");printf("输出这些数为:");printlist(lb);printf("合并并输出两个链表为:");merlist(la,lb,lc);printlist(lc);return0;}7.头文件#include<stdio.h>#include<malloc.h>#define LEN sizeof(list)typedef int ET;typedef struct list{ET data;struct list*next;}list,*linklist;linklist p;四、实验结果五、实验分析1.刚开始运行程序时我将数字无序输入,导致无序输出,不符合实验要求,后来有序输入结果符合要求;2.主函数中“printf("合并并输出两个链表为:");merlist(la,lb,lc);printlist(lc);”语句必须写在最后面,否则将无法实现合并两条链表的功能,甚至导致程序运行出错。

数据结构c语言版上机报告单链表

数据结构c语言版上机报告单链表

数据结构C语言版上机报告:单链表序在数据结构课程中,单链表是一个重要的概念,也是C语言中常用的数据结构之一。

本次报告将深入探讨单链表的基本概念、操作方法以及应用场景,帮助读者更深入地理解和掌握这一数据结构。

一、概述1.1 单链表的定义单链表是一种线性表,它由一系列节点组成,每个节点包含两部分:数据域和指针域。

数据域用于存储数据元素,指针域用于指向下一个节点,通过指针将这些节点串联在一起,形成一个链表结构。

1.2 单链表的特点单链表具有以下特点:(1)动态性:单链表的长度可以动态地增加或减少,不需要预先分配固定大小的空间。

(2)插入和删除操作高效:在单链表中进行插入和删除操作时,只需要修改指针的指向,时间复杂度为O(1)。

(3)随机访问效率低:由于单链表采用链式存储结构,无法通过下标直接访问元素,需要从头节点开始依次遍历,时间复杂度为O(n)。

1.3 单链表的基本操作单链表的基本操作包括:创建、插入、删除、查找等。

这些操作是使用单链表时常常会涉及到的,下面将逐一介绍这些操作的具体实现方法和应用场景。

二、创建2.1 头插法和尾插法在C语言中,可以通过头插法和尾插法来创建单链表。

头插法是将新节点插入到链表的头部,尾插法是将新节点插入到链表的尾部,这两种方法各有优缺点,可以根据具体应用场景来选择。

2.2 应用场景头插法适合于链表的逆序建立,尾插法适合于链表的顺序建立。

三、插入3.1 在指定位置插入节点在单链表中,插入节点需要考虑两种情况:在链表头部插入和在链表中间插入。

通过对指针的操作,可以实现在指定位置插入节点的功能。

3.2 应用场景在实际应用中,经常会有需要在指定位置插入节点的情况,比如排序操作、合并两个有序链表等。

四、删除4.1 删除指定节点在单链表中,删除节点同样需要考虑两种情况:删除头节点和删除中间节点。

通过对指针的操作,可以实现删除指定节点的功能。

4.2 应用场景在实际应用中,经常会有需要删除指定节点的情况,比如删除链表中特定数值的节点等。

数据结构实验报告-实验一顺序表、单链表基本操作的实现

数据结构实验报告-实验一顺序表、单链表基本操作的实现

数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现l 实验⽬的1、顺序表(1)掌握线性表的基本运算。

(2)掌握顺序存储的概念,学会对顺序存储数据结构进⾏操作。

(3)加深对顺序存储数据结构的理解,逐步培养解决实际问题的编程能⼒。

l 实验内容1、顺序表1、编写线性表基本操作函数:(1)InitList(LIST *L,int ms)初始化线性表;(2)InsertList(LIST *L,int item,int rc)向线性表的指定位置插⼊元素;(3)DeleteList1(LIST *L,int item)删除指定元素值的线性表记录;(4)DeleteList2(LIST *L,int rc)删除指定位置的线性表记录;(5)FindList(LIST *L,int item)查找线性表的元素;(6)OutputList(LIST *L)输出线性表元素;2、调⽤上述函数实现下列操作:(1)初始化线性表;(2)调⽤插⼊函数建⽴⼀个线性表;(3)在线性表中寻找指定的元素;(4)在线性表中删除指定值的元素;(5)在线性表中删除指定位置的元素;(6)遍历并输出线性表;l 实验结果1、顺序表(1)流程图(2)程序运⾏主要结果截图(3)程序源代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList/*定义线性表结构*/{int *list; /*存线性表元素*/int size; /*存线性表长度*/int Maxsize; /*存list数组元素的个数*/};typedef struct LinearList LIST;void InitList(LIST *L,int ms)/*初始化线性表*/{if((L->list=(int*)malloc(ms*sizeof(int)))==NULL){printf("内存申请错误");exit(1);}L->size=0;L->Maxsize=ms;}int InsertList(LIST *L,int item,int rc)/*item记录值;rc插⼊位置*/ {int i;if(L->size==L->Maxsize)/*线性表已满*/return -1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)/*将线性表元素后移*/L->list[i+=1]=L->list[i];L->list[rc]=item;L->size++;return0;}void OutputList(LIST *L)/*输出线性表元素*/{int i;printf("%d",L->list[i]);printf("\n");}int FindList(LIST *L,int item)/*查找线性元素,返回值>=0为元素的位置,返回-1为没找到*/ {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item)/*删除指定元素值得线性表记录,返回值为>=0为删除成功*/ {int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;}int DeleteList2(LIST *L,int rc)/*删除指定位置的线性表记录*/{int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return0;}int main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.size,LL.Maxsize);printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.list,LL.Maxsize);while(1){printf("请输⼊元素值,输⼊0结束插⼊操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d",&i);if(i==0)break;printf("请输⼊插⼊位置:");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为:");OutputList(&LL);}while(1){printf("请输⼊查找元素值,输⼊0结束查找操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d ",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没有找到\n");elseprintf("有符合条件的元素,位置为:%d\n",r+1);}while(1){printf("请输⼊删除元素值,输⼊0结束查找操作:");fflush(stdin);/*清楚标准缓存区*/scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(i<0)printf("没有找到\n");else{printf("有符合条件的元素,位置为:%d\n线性表为:",r+1);OutputList(&LL);}while(1){printf("请输⼊删除元素位置,输⼊0结束查找操作:");fflush(stdin);/*清楚标准输⼊缓冲区*/scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为:");OutputList(&LL);}}}链表基本操作l 实验⽬的2、链表(1)掌握链表的概念,学会对链表进⾏操作。

实习2:实现单链表各种基本运算

实习2:实现单链表各种基本运算

实习2:实现单链表各种基本运算1、实验目的充分理解线性表的链接存储方式,掌握单链表的各种基本运算的实现。

2、实验内容编写一个程序,实现单链表的各种基本运算,并在此基础上设计一个主程序,完成如下功能:(1)根据输入指定个数的表元素值,采用头插法建立一个单链表,并输出单链表中各元素的值,同时观察输入内容与输出内容是否一致。

(2)在单链表的第i个元素之前插入一个值为x的新元素,并输出插入后的单链表中各元素的值。

(3)删除单链表中第i个元素,并输出删除后的单链表中各元素的值。

(4)在单链表中查找第i个元素,如果查找成功,则输出该元素的值;否则,输出该元素不存在。

(5)在单链表中查找值为y的元素,如果查找成功,则输出该元素的位序号(0~n-1);否则,输出该元素不存在。

import java.util.Scanner;class Node {private Object data;private Node next;public Node() {this(null, null);}public Node(Object data) {this(data, null);}public Node(Object data, Node next) {this.data = data;this.next = next;}public Object getData() {return data;}public void setData(Object data) {this.data = data;}public Node getNext() {return next;}public void setNext(Node next) {this.next = next;}}class LinkList {Node head=new Node();public LinkList(int n,boolean Order)throws Exception{if(Order)create1(n);}public void create1(int n) throws Exception {Scanner sc = new Scanner(System.in);for (int j=0; j<n; j++)insert(0, sc.nextInt());}public Object get(int i) throws Exception {Node p = head.getNext();int j = 0;while (p != null && j < i) {p = p.getNext();++j;}if (j > i || p == null) {throw new Exception("第" + i + "个元素不存在");}return p.getData();}public int indexOf(Object x){Node p=head.getNext();int j=0;while(p!=null && !p.getData().equals(x)){p=p.getNext();++j;}if(p!=null)return j;elsereturn -1;}public void insert(int i, Object x) throws Exception {Node p = head;int j = -1;while (p != null && j < i - 1) {p = p.getNext();++j;}if (j > i - 1 || p == null)throw new Exception("插入位置不合理");Node s = new Node(x);s.setNext(p.getNext());p.setNext(s);}public void remove(int i) throws Exception {Node p = head;int j = -1;while (p.getNext() != null && j < i - 1) {p = p.getNext();++j;}if (j > i - 1 || p.getNext() == null) {throw new Exception("删除位置不合理");}p.setNext(p.getNext().getNext());}public void display() {Node p = head.getNext();while (p != null) {System.out.print(p.getData() + " ");p = p.getNext();}System.out.println();}}public class LinkL{public static void main(String[] args) throws Exception{Scanner sc=new Scanner(System.in);int n=0;LinkList L=new LinkList(n,true);System.out.println("请输入链表中的结点数:");n=sc.nextInt();System.out.println("请输入"+n+"个数字:");L.create1(n);System.out.println("建立的单链表为:");L.display();System.out.println("请输入待插入的位置i:");int i=sc.nextInt();System.out.println("请输入待插入的数据值x:");int x= sc.nextInt();L.insert(i, x);System.out.println("插入后的链表为:");L.display();System.out.println("请输入待删除元素的位置:");i=sc.nextInt();L.remove(i);System.out.println("删除后的链表为:");L.display();System.out.println("请输入待查找的数据元素的位序号:");i=sc.nextInt();Object o=L.get(i);System.out.println("此单链表中第"+i+"个结点的数据元素值为"+o);System.out.println("请输入待查找的数据元素的值:");x=sc.nextInt();int order=L.indexOf(x);if (order==-1)System.out.println("此顺序表中不包含值为"+x+"的数据元素!");elseSystem.out.println("值为"+x+"元素在顺序表中的第"+order+"个位置上");}}。

数据结构实验报告之链表顺序表的操作

数据结构实验报告之链表顺序表的操作

数据结构实验报告之链表顺序表的操作1、编写程序实现顺序表的各种基本运算:初始化、插⼊、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。

在此基础上设计⼀个主程序完成如下功能:(1)初始化顺序表L;(2)依次在表尾插⼊a,b,c,d,e五个元素;(3)输出顺序表L;(4)输出顺序表L的长度;(5)判断顺序表L是否为空;(6)输出顺序表L的第4个元素;(7)输出元素c的位置;(8)在第3个位置上插⼊元素f,之后输出顺序表L;(9)删除L的第2个元素,之后输出顺序表L;(10)销毁顺序表L。

2、编写程序实现单链表的各种基本运算:初始化、插⼊、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。

在此基础上设计⼀个主程序完成如下功能:(1)初始化单链表L;(2)依次在表尾插⼊a,b,c,d,e五个元素;(3)输出单链表L;(4)输出单链表L的长度;(5)判断单链表L是否为空;(6)输出单链表L的第4个元素;(7)输出元素c的位置;(8)在第3个位置上插⼊元素f,之后输出单链表L;(9)删除L的第2个元素,之后输出单链表L;(10)销毁单链表L。

1顺序表2 #include<stdio.h>3 #include<malloc.h>4 #include<stdlib.h>56#define TRUE 17#define FALSE 08#define OK 19#define ERROR 010#define INFEASIBLE -111#define OVERFLOW -212 typedef int Status;13 typedef char ElemType;1415#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量16#define LISTINCREMENT 10 //线性表存储空间的分配增量17 typedef struct {18 ElemType *elem; //存储空间基地址19int length; //当前长度20int listsize; //当前分配的存储容量21 } SqList;2223 Status InitList_Sq(SqList &L) { //算法2.324 L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));25if (!L.elem) exit(OVERFLOW); //存储分配失败26 L.length = 0; //空表长度为027 L.listsize = LIST_INIT_SIZE; //初始存储容量28return OK;29 }//InitList_Sq3031 Status ListInsert_Sq(SqList &L, int i, ElemType e) { //算法2.432 ElemType *newbase, *p, *q;33if (i<1 || i>L.length + 1) return ERROR; //i值不合法34if (L.length >= L.listsize)35 { //当前存储空间已满,增加分配36 newbase = (ElemType*)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));37if (!newbase) exit(OVERFLOW); //存储分配失败38 L.elem = newbase; //新基址39 L.listsize += LISTINCREMENT; //增加存储容量40 }41 q = &(L.elem[i - 1]); //q为插⼊位置42for (p = &(L.elem[L.length - 1]); p >= q; --p) *(p + 1) = *p; //元素右移43 *q = e; //插⼊e44 ++L.length; //表长增145return OK;46 }4748void DispSqList(SqList L)49 {50int i;51for (i = 0; i < L.length; i++)52 printf("%c ", L.elem[i]);53 }5455 Status ListDelete(SqList &L, int i, ElemType &e)56 {57 ElemType *p,*q;58if ((i < 1) || (i > L.length)) return ERROR;59 p = &(L.elem[i - 1]);60 e = *p;61 q = L.elem + L.length - 1;62for (++p; p <= q; ++p)63 *(p - 1) = *p;64 --L.length;65return OK;66 } //ListDelete_Sq6768 Status GetElem(SqList L, int i, ElemType &e)69 {70if (L.length == 0 || i<1 || i>L.length)71return ERROR;72 e = L.elem[i - 1];73return OK;74 }7576int ListLength(SqList L)77 {78return(L.length);79 }8081 Status DestroyList(SqList &L)82 {83 free(L.elem);84 L.length = 0;85return OK;86 }8788 Status ListEmpty(SqList L)89 {90return(L.length == 0);91 }9293int LocateElem(SqList L, ElemType e)94 {95int i = 0;96while (i < L.length && L.elem[i] != e) i++;97if (i >= L.length) return0;98else return i + 1;99 }100101void main()102 {103 SqList h;104 ElemType e;105 InitList_Sq(h);106 ListInsert_Sq(h, h.length + 1, 'a');107 ListInsert_Sq(h, h.length + 1, 'b');108 ListInsert_Sq(h, h.length + 1, 'c');109 ListInsert_Sq(h, h.length + 1, 'd');110 ListInsert_Sq(h, h.length + 1, 'e');111 DispSqList(h);112 printf("%d\n\n",ListLength(h));113 ListEmpty(h);114if (ListEmpty(h))116 printf("Empty\n\n");117 }118else119 {120 printf("Not empty\n\n");121 }122 GetElem(h, 4, e);123 printf("%c\n", e);124 printf("%d\n",LocateElem(h, 'c'));125 ListInsert_Sq(h,3,' f');126 DispSqList(h);127 ListDelete(h, 2, e);128 DispSqList(h);129 DestroyList(h);130 }131132133134135136单链表137138139140 #include<stdio.h>141 #include<malloc.h>142 #include<stdlib.h>143144#define TRUE 1145#define FALSE 0146#define OK 1147#define ERROR 0148#define INFEASIBLE -1149#define OVERFLOW -2150 typedef int Status;151152 typedef char ElemType;153154155 typedef struct LNode {156 ElemType data;157int length;158struct LNode *next;159 }LNode, *LinkList;160161162 Status InitList_L(LinkList &L) {163 L = (LinkList)malloc(sizeof(LNode));164 L->next = NULL;165return OK;166 }167168 Status ListInsert_L(LinkList L, int i, ElemType e) { 169 LinkList p = L,s;170int j = 0;171while (p && j < i - 1)172 {173 p = p->next;174 ++j;175 }176if (!p || j > i - 1)177 {178return ERROR;179 }180else181 {182 s = (LinkList)malloc(sizeof(LNode));183 s->data = e;184 s->next = p->next;185 p->next = s;186return OK;187 }188 }189190void DispList_L(LinkList L)191 {192 LinkList p = L->next;193while (p != NULL)194 {195 printf("%c\n", p->data);196 p = p->next;197 }198200201void DestoryList(LinkList &L)202 {203 LinkList p = L, q = p->next;204while (q != NULL)205 {206 free(p);207 p = q;208 q = p->next;209 }210 free(p);211 }212213 Status ListLength_L(LinkList L) {214 LinkList p = L; int n = 0;215while (p->next != NULL)216 {217 n++;218 p = p->next;219 }220return (n);221 }222223 Status ListDelete(LinkList L, int i, ElemType &e){ 224int j;225 LinkList p, q;226 p = L;227 j = 1;228while (p->next && j < i)229 {230 p = p->next;231 ++j;232 }233if (!(p->next) || j > i)234 {235return ERROR;236 }237 q = p->next;238 p->next = q->next;239 e = q->data;240 free(q);241return OK;242 }243244 Status ListEmpty_L(LinkList L)245 {246return(L->length == 0);247 }248249 Status GetElem(LinkList L, int i, ElemType &e) 250 {251int j;252 LinkList p;253 p = L->next;254 j = 1;255while (p&&j<i)256 {257 p = p->next;258 ++j;259 }260if (!p || j > i)261 {262return ERROR;263 }264 e = p->data;265return OK;266 }267268 Status LocateElem(LinkList L, int e)269 {270 LinkList p = L;271int n=0;272//p->length = 0;273while (p != NULL)274 {275if(p->data != e)276 {277 p = p->next;278 n++;279 }280else281 {282break;283 }284 }285if(p != NULL)286 {287return n;288 }289else290 {291return ERROR;292 }293 }294295void main()296 {297 LinkList h;298 ElemType e;299 InitList_L(h);300 ListInsert_L(h, 1, 'a');301 ListInsert_L(h, 2, 'b');302 ListInsert_L(h, 3, 'c');303 ListInsert_L(h, 4, 'd');304 ListInsert_L(h, 5, 'e');305 DispList_L(h);306 printf("%d\n", ListLength_L(h)); 307if (ListEmpty_L(h))308 {309 printf("Empty\n\n");310 }311else312 {313 printf("Not empty\n\n");314 }315 GetElem(h, 4, e);316 printf("%c\n", e);317 printf("%d\n", LocateElem(h, 'c')); 318 ListInsert_L(h, 3, 'f');319 DispList_L(h);320 ListDelete(h, 2, e);321 DispList_L(h);322 DestoryList(h);323 }。

单链表的操作实验报告

单链表的操作实验报告

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

在本次实验中,我们将学习如何使用C语言实现单链表的基本操作,包括插入、删除和查找等。

一、单链表的定义和初始化单链表由节点组成,每个节点包含数据和指向下一个节点的指针。

首先,我们需要定义一个节点的结构体,如下所示:```struct Node {int data; // 节点数据struct Node* next; // 指向下一个节点的指针};```在初始化单链表之前,我们需要创建一个头节点,它不存储任何数据,只用于指向第一个节点。

初始化单链表的代码如下:```struct Node* head = NULL; // 头节点初始化为空```二、单链表的插入操作插入操作是向单链表中添加新节点的过程。

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

下面以在链表头部插入新节点为例进行说明。

首先,我们需要创建一个新节点,并为其分配内存空间:```struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));```然后,为新节点赋值并将其插入到链表头部:```newNode->data = 10; // 赋值新节点的数据newNode->next = head; // 将新节点的指针指向原头节点head = newNode; // 将头节点指向新节点```三、单链表的删除操作删除操作是从单链表中删除指定节点的过程。

我们可以根据节点的位置或者数据进行删除。

下面以删除链表中指定数据的节点为例进行说明。

首先,我们需要遍历链表找到要删除的节点,并记录其前一个节点的地址:```struct Node* current = head;struct Node* previous = NULL;int targetData = 10; // 要删除的节点数据while (current != NULL && current->data != targetData) {previous = current;current = current->next;}```然后,将前一个节点的指针指向要删除节点的下一个节点,并释放要删除节点的内存空间:```previous->next = current->next;free(current);```四、单链表的查找操作查找操作是在单链表中查找指定数据的节点。

实现单链表的各种基本运算

实现单链表的各种基本运算

实现单链表的各种基本运算
单链表是一种重要的数据结构,在实际开发中应用广泛。

实现单链表的各种基本运算是数据结构学习的必备内容。

其中,包括单链表的创建、插入、删除、查找以及遍历等操作。

首先,单链表的创建需要定义单链表节点的结构体,并通过malloc函数动态分配节点内存。

然后,将各个节点通过指针相连,形成链表。

其次,单链表的插入操作可以在链表的任意位置插入新节点。

具体实现方式是,先通过遍历找到待插入节点的位置,然后将新节点插入到该位置前面即可。

再次,单链表的删除操作可以删除任意位置的节点。

具体实现方式是,先通过遍历找到待删除节点的位置,然后将其前一个节点的指针指向其后一个节点,再通过free函数释放该节点的内存即可。

另外,单链表的查找操作可以通过遍历实现。

对于有序链表,还可以采用二分查找法提高查找效率。

最后,单链表的遍历操作可以通过while循环遍历整个链表,依次输出每个节点的值。

总之,实现单链表的基本运算是数据结构学习中非常重要的一部分。

掌握了这些操作,可以为日后的开发工作打下坚实的基础。

- 1 -。

单链表实验报告

单链表实验报告

单链表实验报告第一篇:单链表实验报告《数据结构》实验报告二分校:学号:日期:班级:姓名:程序名: L2311.CPP一、上机实验的问题和要求:单链表的查找、插入与删除。

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

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

2.从键盘输入1个整数,在单链表中查找该结点。

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

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

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

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

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

7.把单链表变成带表头结点的循环链表,输出循环单链表所有结点值,观察输出结果。

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

二、程序设计的基本思想,原理和算法描述:(包括程序的结构,数据结构,输入/输出设计,符号名说明等)三、源程序及注释:四、运行输出结果:五、调试和运行程序过程中产生的问题及采取的措施:六、对算法的程序的讨论、分析,改进设想,其它经验教训:七、对实验方式、组织、设备、题目的意见和建议:第二篇:北邮数据结构实验报告单链表北京邮电大学数据结构试验报告实验名称:实验一线性表学生姓名:班级:班内序号:学号:日期: 2014年1月3日实验目的⌝熟悉C++语言的基本编程方法,掌握集成编译环境的调试方法⌝学习指针、模板类、异常处理的使用⌝掌握线性表的操作的实现方法⌝学习使用线性表解决实际问题的能力实验内容2.1题目1 根据线性表的抽象数据类型的定义,选择下面任一种链式结构实现线性表,并完成线性表的基本功能。

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

《数据结构》上机报告_2011_年_ 3 _月_ 9 _日姓名_____ 学号_ _ 同组成员 __ _无_ __1.实验题目及要求编写一个程序,实现单链表的各种基本运算2.需求分析建立一个单链表,实现单链表的初始化,插入、删除节点等功能,以及确定某一元素在单链表中的位置。

(1)初始化单链表;(2)依次采用尾插入法插入a,b,c,d,e元素;(3)输出单链表L;(4)输出单链表L的长度;(5)判断单链表L是否为空;(6)输出单链表L的第三个元素;(7)输出元素a的位置;(8)在第4个元素位置上插入f元素;(9)输出单链表L;(10)删除L的第3个元素;(11)输出单链表L;(12)释放单链表。

3.概要设计(1)为了实现上述程序功能,需要定义一个简化的线性表抽象数据类型:ADT LinearList {数据对象:D={ a i|a i∈IntegerSet,i=0,1,2,…,n,n≥0}结构关系:R={<a i,a i+1>|a i,a i+1 ∈D}基本操作:InitList_L(L)操作前提:L是一个未初始化的线性表操作结果:将L初始化为一个空的线性表CreateList_L(L)操作前提:L是一个已初始化的空表操作结果:建立一个非空的线性表LListInsert_L(L,pos,e)操作前提:线性表L已存在操作结果:将元素e插入到线性表L的pos位置ListDelete_L(L,pos,e)操作前提:线性表L已存在操作结果:将线性表L中pos位置的元素删除,删除的元素值通过e返回LocateList_L(L,e)操作前提:线性表L已存在操作结果:在线性表L中查找元素e,若存在,返回元素在表中的序号位置;若不存在,返回-1DestroyList_L(&L)初始条件:线性表L已存在操作结果:销毁线性表ListEmpty_L(L)初始条件:线性表已存在操作结果:若L为空表,则返回ERROR,否则返回FALSEListLength_L(L)初始条件:线性表L已存在操作结果:返回L中数据元素个数GetElem_L(L,I,&e)初始条件:线性表L已存在操作结果:用e返回L中第i个数据元素值}(2)本程序包含10个函数:主函数main()初始化单链表函数InitList_L()显示单链表内容函数DispList_L()插入元素函数ListInsert_L()删除元素函数ListDelete_L()查找元素函数LocateList_L()创建链表函数CreateList_L()链表元素长度函数ListLength_L()判断链表是否为空函数ListEmpty_L()取值函数GetElem_L()各函数间调用关系如下:( 3 ) 主函数的伪码main(){ 说明一个单链表 L ; 初始化 L ; 建立 L ; 显示 L ; }4. 详细设计采用单链表实现概要设计中定义的抽象数据类型,有关的数据类型和伪码算法定义mainInitList DispList CreateList ListLength ListEmptyDestroyList GetElem ListInsert ListDelete LocateElem如下:(1)类型定义typedef int ElemType;typedef struct LNode{ ElemType data; //数据域struct LNode *next; //指针域} LNode,* LinkList;(2)基本操作的伪码算法初始化Bool InitLinkList(LinkList *L){ *L=申请新结点;如果申请失败,返回失败标志;(*L)->next=NULL;返回成功标志;}建立单链表Bool CrtLinkList(LinkList L)/* L是已经初始化好的空链表的头指针,通过键盘输入元素值,利用尾插法建单链表L */{ rear=L;打印输入提示:“请输入若干个正整数(用空格分隔),并用 -1 结束:”读入一个数x;当x不是结束标志时,循环做如下处理:{申请一个新结点s;如果申请失败,返回失败标志;将x送到s的data域;rear->next=s;rear=s;读入下一个数x;}rear->next=NULL;返回成功标志;}显示单链表(输出)void DispLinkList(LinkList L){p=首元素结点地址;while ( p不空 ){打印结点p 的元素值;p=下一个结点地址;}}插入操作bool InsLinkList(LinkList L, int pos, ElemType e)/*在带头结点的单链表L中第pos个位置插入值为e的新结点s*/ {从“头”开始,查找第i-1个结点 pre ;if (查找失败){ 显示参数错误信息;return ERROR;}else{申请一个新的结点s ;将e放入s的数据域;将s 插到pre 后面;return OK;}}删除操作bool DelLinkList(LinkList L, int pos, ElemType *e)/* 在带头结点的单链表L中删除第pos个元素,并将删除的元素保存到变量*e中 */ {查找待删除结点i的前驱结点,并用pre指向它;if (查找失败){ 显示参数错误信息;return ERROR;}else{r=pre->next;修改指针,删除结点r ;释放被删除的结点所占的内存空间;return OK;}}查找操作int LocLinkList(LinkList L, ElemType e)/ * 在带头结点的单链表L中查找其结点值等于e的结点,若找到则返回该结点的序号位置k,否则返回 -1 * /{p=首元素结点地址;while ( p不空 )if (p->data!=e){ p=p->next; k++; }else break;if ( p 不空 ) return k;else return -1;}5.调试分析开始运行时会出现Debug Error,DAMAGE: After Normal block,搜索后了解到是内存越界操作,检查后发现内存分配L和S=(LinkList)malloc(sizeof(LNode))写成了=(LinkList)malloc(sizeof(LinkList)),修改后正常。

6.使用说明程序执行后,界面直接输出要求的结果7.测试结果8.附件#include<>#include<>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define NULL 0typedef int Status;typedef int ElemType;typedef struct LNode {ElemType data;struct LNode *next;}LNode,*LinkList;Status InitList_L(LinkList &L) { //初始化线性表L=(LinkList )malloc(sizeof(LNode)); //L指向头节点,头节点数据域为空L->next=NULL;return OK;}// InitList_LStatus DispList_L(LinkList &L) { //输出线性表LinkList p=L->next;while(p!=NULL){printf("%c",p->data);p=p->next;}return OK;} // DispList_LStatus CreateList_L(LinkList &L,ElemType a[],int n) { //尾插法建表LinkList s,r;int i;L=(LinkList )malloc(sizeof(LNode));r=L;for(i=0;i<n;i++){s=(LinkList )malloc(sizeof(LNode));s->data=a[i];r->next=s;r=s;}r->next=NULL;return OK;}// CreateList_LStatus ListLength_L(LinkList L) { //求线性表的长度LinkList p=L;int n=0;while(p->next!=NULL){n++;p=p->next;}return(n);}// ListLength_LStatus ListEmpty_L(LinkList L) { //判断单链表是否为空return(L->next==NULL);}// ListEmpty_LStatus DestroyList_L(LinkList &L) { //销毁线性表LinkList p=L,q=p->next;while(q!=NULL){free(p);p=q;q=p->next;}free(p);return OK;}// DestroyList_LStatus GetElem_L(LinkList L, int i, ElemType &e) { // L为带头节点的单链表的头指针。

// 当第i个元素存在时,其值赋给e并返回OK,否则返回ERROR int j=0;LinkList p=L;while(j<i&&p!=NULL){j++;p=p->next;}if(p==NULL){return ERROR;}else{e=p->data;return OK;}// GetElem_LStatus ListInsert_L(LinkList &L, int i, ElemType e) { //插入数据元素int j=0;LinkList p=L,s;/*找到插入节点的上一个元素,如果是头节点则退出,当i=1时表示头节点,i=2时,表示第一个元素*/while(j<i-1&&p!=NULL){j++;p=p->next;}if(p==NULL){return ERROR;}else{s=(LinkList )malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s;return OK;}// ListInsret_LStatus ListDelete_L(LinkList &L, int i, ElemType &e) { //删除数据元素int j=0;LinkList p=L,q;while(j<i-1&&p!=NULL) //查找删除元素的前一个节点{j++;p=p->next;}if(p==NULL){return ERROR;}else{q=p->next; //q为要删除的元素节点if(q==NULL){return ERROR;}e=q->data; //e为删除节点的数据区域p->next=q->next;free(q);return OK;}// ListDelete_Lint LocateElem_L(LinkList L, ElemType e) { //按元素值查找元素LinkList p=L->next;int i=1;while(p!=NULL&&p->data!=e){p=p->next;i++;}//如果要插入的节点为头节点,则退出if(p==NULL){return ERROR;}else{return(i);}}// LocateElem_Lint main() {ElemType e,a[5]={'a','b','c','d','e'};LinkList L;printf("(1)初始化单链表L\n");InitList_L(L); //初始化单链表L printf("(2)依次采用尾插法插入a,b,c,d,e元素\n");CreateList_L(L,&a[0],5); //依次采用尾插入法插入a,b,c,d,e 元素printf("(3)输出单链表L:");DispList_L(L); //输出单链表Lprintf("\n");printf("(4)单链表L的长度为:");printf("%d",ListLength_L(L)); //输出单链表L的长度printf("\n");if(ListEmpty_L(L)){printf("(5)该单链表为空\n");}else{printf("(5)该单链表不为空\n"); //判断单链表L是否为空}GetElem_L(L,3,e);printf("(6)单链表L的第三个元素为:");printf("%c",e); printf("\n"); //输出单链表L的第3个元素printf("(7)单链表L中a的位置为:");printf("%d",LocateElem_L(L,'a')); //输出元素'a'的位置printf("\n");ListInsert_L(L,4,'f'); //在第4个元素位置插入'f'元素printf("(8)在第4个元素位置上插入 f 元素\n");printf("(9)输出单链表L:");DispList_L(L); //输出单链表Lprintf("\n");ListDelete_L(L,3,e); //删除L的第3个元素printf("(10)删除L的第3个元素\n");printf("(11)输出单链表L:"); //输出单链表LDispList_L(L);printf("\n");printf("(12)释放单链表L\n");DestroyList_L(L); //释放单链表Lreturn 0;}。

相关文档
最新文档