数据结构实验报告

原创 于 2021-03-10 19:10:07 发布 · 2.8k 阅读 · 17 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#链表 #指针 #数据结构 #算法

本实验旨在掌握线性表的链式存储结构，包括单链表和双向循环链表的建立、插入、删除和查找操作。学生需要使用C语言编程实现这些功能，同时计算单链表中特定值出现的次数。实验要求涉及头插法、尾插法、数据域值计数等核心算法。

数据结构与算法操作实验二( 链表的操作)

一、实验目的

1．掌握线性表的链式存储结构的表示和实现方法。
2．掌握链表基本操作的算法实现。

二、实验内容

1．建立单链表，并在单链表上实现插入、删除和查找操作（验证性内容）。
2．建立双向链表，并在双向链表上实现插入、删除和查找操作（设计性内容）。
3．计算已知一个单链表中数据域值为一个指定值x的结点个数（应用性设计内容）。

三、实验的软硬件环境要求

硬件环境要求：
PC机（单机）
使用的软件名称、版本号以及模块：
Windows环境下的VC++等。

四、知识准备

前期要求熟练掌握了C语言的编程规则、方法和单链表和双向链表的基本操作算法。

五、验证性实验

1．实验要求

编程实现如下功能：
（1）根据输入的一系列整数，以0标志结束，用头插法建立单链表，并输出单链表中各元素值，观察输入的内容与输出的内容是否一致。
（2）在单链表的第i个元素之前插入一个值为x的元素，并输出插入后的单链表中各元素值。
（3）删除单链表中第i个元素，并输出删除后的单链表中各元素值。
（4）在单链表中查找第i个元素，如果查找成功，则显示该元素的值，否则显示该元素不存在。

2. 实验相关原理：

线性表的链式储结构是用一组任意的存储单元依次存放线性表中的元素，这组存储单元可以是连续的，也可以是不连续的。为反映出各元素在线性表中的前后逻辑关系，对每个数据元素来说，除了存储其本身数据值之外，还需增加一个或多个指针域，每个指针域的值称为指针，又称作链，它用来指示它在线性表中的前驱或后继的存储地址。这两个部分的的一起组成一个数据元素的存储映像，称为结点，若干个结点链接成链表。如果一个结点中只含一个指针的链表，则称单链表。单链表的存储结构描述如下：

typedef   struct  Lnode {
Elemtype   data;/*数据域*/
    struct  Lnode  *next;/*指针域*/
}LNODE,*Linklist; /*其中LNODE为结点类型名，Linklist为指向结点的指针类型名*/

【核心算法提示】
1． 链表建立操作的基本步骤：链表是一个动态的结构，它不需要予分配空间，因此建立链表的过程是一个结点“逐个插入” 的过程。先建立一个只含头结点的空单链表，然后依次生成新结点，再不断地将其插入到链表的头部或尾部，分别称其为“头插法”和“尾插法”。
2． 链表查找操作的基本步骤：因链表是一种"顺序存取"的结构，则要在带头结点的链表中查找到第 i个 元素，必须从头结点开始沿着后继指针依次"点数"，直到点到第 i 个结点为止,如果查找成功，则用e返回第i个元素值。头结点可看成是第0个结点。
3． 链表插入操作的基本步骤：先确定要插入的位置，如果插入位置合法，则再生成新的结点，最后通过修改链将新结点插入到指定的位置上。
4． 链表删除操作的基本步骤：先确定要删除的结点位置，如果位置合法，则再通过修改链使被删结点从链表中“卸下”，最后释放被删结点的空间。
【核心算法描述】

void  creat1(Linklist &L)  /*输入一系列整数，以0标志结束，将这些整数作为data域并用头插法建立一个带头结点的单链表的函数*/
{   L=(Linklist)malloc(sizeof(LNODE));/*生成头结点*/
    L->next=NULL;/*头结点的指针域初始为空*/
    scanf("%d",&node);
while(node!=0)
      { p=(Linklist)malloc(sizeof(LNODE));/*为一个新结点的分配空间*/
        p->data=node; /*为新结点数据域赋值*/
        p->next=L->next;/*新结点指针域指向开始结点*/
        L->next=p;  /*头结点指针域指向新结点，即新结点成为开始结点*/
scanf("%d",&node);
}    
}
void  creat2(Linklist &L) /*输入一系列整数，以0标志结束，将这些整数作为data域并用尾插法建立一个带头结点的单链表的函数*/
 {   L=(Linklist)malloc(sizeof(LNODE));/*为头结点分配空间*/
     L->next=NULL; /*头结点的指针域初始为空*/
     r=L;  /*尾指针初始指向头结点*/
scanf("%d",&node);
while(node!=0)
       { p=(Linklist)malloc(sizeof(LNODE));/*为一个新结点分配空间*/
         p->data=node; /*新结点数据域赋值*/
         p->next=NULL; /*新结点指针域为空*/
         r->next=p;/*尾结点指针域指向新结点*/
         r=p;   /*尾指针指向新结点，即新结点成为尾结点*/
scanf("%d",&node);
 }
}
       status list_search(Linklist L, int i;Elemtype &e)
            /*在带头结点的单链表L中查找第i个元素，如果查找成功则用e返回其值*/
{  p=L->next;  /*使指针p指向第1个元素结点*/
j=1;        /*计数器赋初值为1*/
while (p&& j<i)  /*顺着后继指针查找第i个元素结点*/
 { p=p->next;
     j++;
}
if (!p&& j>i)
 return ERROR;  /*如果i值不合法，即i值小于1或大于表长，则出错*/
e=p->data;    /*如果第i个元素存在，则将该元素值赋给e*/
return OK;
            }
status list_insert(Linklist &L,int i;Elemtype x) 
/*在带头结点的单链表L中第i个位置之前插入新元素x*/
           { p=L;   j=0;
             while(p!=NULL&&j<i-1) /*寻找插入位置，并使p指向插入位置的前驱结点，即L中的第i-1个位置*/
               { p=p->next; 
        ++j;
}
             if(p==NULL||j>i-1)
               return ERROR; /*若位置不正确,即i小于1或大于表的长度加1，则出错*/
             s=(Linklist)malloc(sizeof(LNODE)); /*分配一个新结点的空间*/
             s->data=x;   /*为新结点数据域赋值*/
              /*下面两条语句就是完成修改链，将新结点s插入到p结点之后*/
 s->next=p->next;  /*新结点指针域指向p的后继结点*/
             p->next=s;   /*新结点成为p的后继结点*/
             return OK;
}
status  list_delete(Linklist &L,int i,Elemtype &x)
/*在带头结点的单链表L中，删除第i个元素结点,并用x返回其值*/
          { p=L;j=0;
            while(p->next!=NULL&&j<i-1) /*寻找被删结点，并使p指向被删结点的前驱*/
              { p=p->next; 
++j; 
}
            if (p->next==NULL||j>i-1)
                   return ERROR;   /*若位置不正确，即i小于1或大于表长，则出错*/
            q=p->next;     /* q指向p的后继结点*/
            p->next=q->next;  /*q的后继结点成为p的后继结点*/
            x=q->data;   /*用x返回第i个位置的元素*/
free(q);   /*释放q所指的被删结点的空间*/
return OK;
}

3．学生实验代码

#include "stdio.h"
#include<stdlib.h>
typedef struct node
{
	int data;
	struct node *next;
}Linklist;

Linklist *creat(int n)
{ int x;
	Linklist *p,*q,*head=(Linklist*)malloc(sizeof(Linklist));
	head->next=NULL;
	q=head;
	for(int i=1;i<=n;i++)
	{
		printf("输入数据");
		scanf("%d",&x);
		p=(Linklist*)malloc(sizeof(Linklist));
		p->data =x;
		p->next=NULL;
		q->next=p;
		q=p;
	}
	return head;
}

int print(Linklist *L)
{
	Linklist *p=L;
	while(p->next!=NULL)
	{
		p=p->next ;
		printf("%4d",p->data );
	}
	printf("\n");
}





insert(Linklist *L,int i,int e)
{ int j=1;
	Linklist *q,*p=L->next;
	while(p&&j<i-1)
	{
		j++;
		p=p->next;
	}
	q=(Linklist*)malloc(sizeof(Linklist));
	q->data =e;
	q->next =p->next ;
	p->next =q;
}

delet (Linklist *L,int i)
{
	int j=1;
	Linklist *q,*p=L->next;
	while(p&&j<i-1)
	{
		j++;
		p=p->next ;
	}
	q=p->next ;p->next =q->next ;
	free(q);
}
search (Linklist *L,int key)
{
	Linklist *p=L->next;
	while(p&&p->data !=key)
	{
		p=p->next ;
		if(p->data==key)
		{
		printf("OK");break;
	  }
		else
		{
			printf("NOT FOUND");break;
		}
  }
}
int main()
{
	int n,i,e,key;
	printf("输入表的长度");
	scanf("%d",&n);
	Linklist *head=creat(n);
	print(head);
	printf("请输入要插入的位置：");
	scanf("%d",&i);
	printf("请输入要插入的值e：");
	scanf("%d",&e);
	insert(head,i,e);
	print(head);
	printf("请输入要删除的位置i：");
	scanf("%d",&i);
	delet(head,i);
	print(head);
	printf("请输入要查找key：");
	scanf("%d",&key);
	search(head,key);
	print(head);
}

5． 运行结果

在这里插入图片描述

六、设计性实验(以下两个设计题目学生可根据自己的掌握程度或兴趣自行选择完成)

  1. 编程实现在双向循环链表上的插入、删除和查找操作
⑴ 实验要求

（1）输入链表的长度和各元素的值，用尾插法建立双向循环链表，并输出链表中各元素值，观察输入的内容与输出的内容是否一致。
（2）在双向循环链表的第i个元素之前插入一个值为x的元素，并输出插入后的链表中各元素值。
（3）删除双向循环链表中第i个元素，并输出删除后的链表中各元素值。
（4）在双向循环链表中查找值为x元素，如果查找成功，则显示该元素在链表中的位置，否则显示该元素不存在。

⑵ 核心算法提示

双向循环链表采用的存储结构描述如下：

typedef struct DULNODE
       { Elemtype data;  /*数据域*/
         struct DULNODE *prior; /*指向前驱结点的指针域*/
         struct DULNODE  *next;/*指向后继结点的指针域*/
       }DULNODE,*DuLinklist;
      typedef int Elemtype;

不论是建立双向循环链表还是在双向循环链表中进行插入、删除和查找操作，其操作方法和步骤都跟单链表类似。只不过要注意两点：
（1）凡是在操作中遇到有修改链的地方，都要进行前驱和后继两个指针的修改。
（2）单链表操作算法中的判断条件：p= =NULL 或p!=NULL ,在循环链表的操作算法中则需改为：p!= L,其中L为链表的头指针。

⑶ 核心算法描述
void  DuList_creat (DuLinklist &L,int n) /*输入n个整数（其中n为表长），将这些整数作为data域并用尾插法建立一个带头结点的双向循环链表的函数*/
 {   L=( DuLinklist)malloc(sizeof(DULNODE));/*为头结点分配空间*/
     L->next=L->prior=L;
/*使头结点的后继指针和前驱指针都指向自身，形成空的双向循环链表*/
     r=L;    /*尾指针初始指向头结点*/
for (i=0;i<n;i++)
       { p=(DuLinklist)malloc(sizeof(DULNODE));/*为一个新结点分配空间*/
         scanf("%d",&p->data); /*从键盘输入值，并保存在新结点数据域中*/
         p->next=r->next; /*新结点后继指针指向尾结点r的后继结点*/
         p->prior=r;    /*新结点的前驱指针指向尾结点r*/
  r->next=p;  /*尾结点的后继指针指向新结点*/
         r=p;      /*尾指针指向新结点，即新结点成为尾结点*/
}
L->prior=r;    /*使尾结点成为头结点的前驱结点*/
}
status DuList_search(DuLinklist L, int i;Elemtype &e)
  /*在带头结点的双向循环链表L中查找第i个元素，如果查找成功则用e返回其值*/
{ p=L->next;  /*使指针p指向第1个元素结点*/
j=1;        /*计数器赋初值为1*/
  while (p!=L && j<i)  /*顺着后继指针查找第i个元素结点*/
   { p=p->next;
     j++;
}
if (j!=i)
    return ERROR;  /*如果i值不合法，即i值小于1或大于表长，则出错*/
e=p->data;    /*如果第i个元素存在，则将该元素值赋给e*/
return OK;
 }
status DuList_insert(DuLinklist &L,int i;Elemtype x) 
/*在带头结点的双向循环链表L中第i个位置之前插入新元素x*/
        {   p=L->next;   j=1;
while(p!=L &&j<i) /*寻找插入位置，并使p指向插入位置的结点，即L中的第i个结点*/
            { p=p->next; 
 ++j;
}
      if(j!=i)
         return ERROR;  /*若位置不正确,即i小于1或大于表的长度加1，则出错*/
      s=(DuLinklist)malloc(sizeof(DULNODE)); /*为一个新结点s分配空间*/
      s->data=x;   /*为新结点数据域赋值*/
            /*下面四条语句就是完成修改链，将新结点s插入到p结点之前*/
      s->next=p;
p->prior->next=s;  
      s->prior=p->prior;
p->prior=s;  
      return OK;
}
status  DuList_delete(DuLinklist &L,int i,Elemtype &x)
/*在带头结点的双向循环链表L中，删除第i个元素结点，并用x返回其值*/
   {  p=L->next;j=1;
     while(p!=L&&j<i) /*寻找被删结点，并使p指向被删结点的前驱*/
       { p=p->next; 
++j; 
}
     if (j!=i)
        return ERROR;   /*若位置不正确，即i小于1或大于表长，则出错*/
 q=p;   /*记下被删结点*/ 
 p->prior->next=p->next;   /*修改链使得p结点从链中脱离*/ 
 p->next->prior=p->prior;
 x=q->data;
 printf("the delete data is:%d\n",x);
 free(q);  //释放被删结点空间
return OK;
}

提醒: 请将上述算法与单链表上相应操作的算法对照学习，特别注意它们不相同的地方。

2．编写一个程序，计算出一个单链表中数据域值为一个指定值x的结点个数。
实验要求：
⑴ 从键盘输入若干个整数，以此序列为顺序建立一个不带头结点的单链表；
⑵ 输出此单链表中的各个数据元素值；
⑵ 给定一个x的具体整数值，计算并返回此单链表中数据域值为x的结点个数值。

《数据结构》实验报告
LToday的专栏
06-25 2426
实验七：排序一．我的实验选题：排序算法二．实验主要内容和目的：将输入的n个数用插入排序、快速排序、选择排序分别重新排列成按一个数据元素某个项值有序的序列。本实验的目的在于：对于每一种排序，要深刻理解它的思想，熟练掌握排序过程，时间和空间复杂度，最好情况和最坏情况，稳定性如何，适用于什么样的初始序列。掌握重要排序的算法和排序过程，插入排
数据结构试验报告
06-17
实验一：线性表的应用算法：构造一个递增有序的正整数链表，实现链表分解为一个奇数表和一个偶数表，之后再将两个链表合并一个递减链表。 实验二：线性表的应用算法：构造两个按指数递增的有序链表，实现两个一元多项式相加
链表的操作实验
木头博客
02-28 4185
链表的操作实验 一、实验名称和性质 二、实验目的 1．掌握线性表的链式存储结构的表示和实现方法。 2．掌握链表基本操作的算法实现。 三、实验内容 1．建立单链表，并在单链表上实现插入、删除和查找操作（验证性内容）。 2．建立双向链表，并在双向链表上实现插入、删除和查找操作（设计性内容）。 3．计算已知一个单链表中数据域值为一个指定值x的结点个数（应用性设计内容）。 四、实验的软硬件环境要求 硬件环境要求：PC机（单机） 使用的软件名称、版本号以及模块： Windows环境下的TurboC2.0以上或
精选资源
西北工业大学数据结构实验报告
07-12
包含11次数据结构实验报告以及配套代码，结构完整，符合要求，实验成绩97分。 啰嗦几句： 更加建议大家自己写，我这个更多的是自己的资源存档 有问题的话私信，看到会回复 关于代码，因为当时比较仓促，还没有进行...
精选资源
数据结构实验报告答案.pdf
08-22
数据结构实验报告答案
数据结构实验报告汇总
12-28
大学上数据结构课程自己写的数据结构实验，供参考 其中包括：学生管理系统（链表），算术表达式求值（栈和队列），KMPandBF算法，Huffman树和Huffman编码，完全二叉树的操作，学生管理系统plus（排序和查找）
华科数据结构实验报告代码和文档
12-16
在这个“华科数据结构实验报告代码和文档”中，我们将会深入学习和实践一系列重要的数据结构概念，包括顺序表、二叉树以及图等。 首先，我们来看顺序表。顺序表是最基础的数据结构之一，它在内存中按照线性顺序存储...
数据结构实验报告.docx
12-21
浙江科技学院数据结构实验报告(2019年)，包含实验线性表操作(一元多项式的运算)丶哈夫曼编码和译码丶求图的最小生成树丶最短路径算法设计(单源最短路)丶快速排序
数据结构实验报告一
02-19
一、实验目的 掌握线性表的基本操作（插入、删除、查找）以及线性表合并等运算在顺序存储结构、链式存储结构上的实现。重点掌握链式存储结构实现的各种操作。 掌握线性表的链式存储结构的应用。 （1）描述你在进行实现时，主要的函数或操作内部的主要算法，分析这个算法的时、空复杂度，并说明你设计的巧妙之处。 主要函数： void create(Poly &L); 输入并建立多项式L，该函数首相确定多项式的项数，从而容易实现所输入多项式何时结束的判断。 void display(Poly L); //显示输出多项式L， void sort(Poly &L); //多项式L按指数排序 void add(Poly La,Poly Lb,Poly &Lc;); //多项式La,Lb相加 void subtract(Poly La,Poly Lb,Poly &Ld;); //多项式La减去Lb，结果给Ld 相加和相减两个函数同采用while循环，将pa && pb作为判断条件，从而可在不知道两个多项式项数的情况下，有一个多项式遍历比较结束就会停止，程序继续想下一步进行。
数据结构实验报告（一）
热门推荐
cqc1161的博客
09-19 1万+
数据结构实验报告（一） 一、实验名称 实验一  线性表的基本操作实现及其应用 二、实验目的 1、熟练掌握线性表的结构特点，掌握顺序表的基本操作。 2、巩固 C++相关的程序设计方法与技术。 3、学会使用顺序表解决实际问题。 三、实验内容 顺序表的建立与操作实现 建立 n 个元素的顺序表（n 的大小和表里数据自己确定），实现相关的操作：输出，插 入，删除，查找等功能。编写完整程序
C++实现数据结构实验报告解析
在处理这份关于"数据结构实验报告"的文件时，我们需要关注标题、描述、标签和文件名称列表提供的信息。本文件的核心内容是围绕数据结构实验而撰写的报告，并且使用了C++编程语言。我们将根据这些线索详细阐述相关...
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值