实验二顺序表及链表
三种存储结构(顺序表,链表,静态链表)求解josuphu问题的实验报告
实验报告:使用三种存储结构(顺序表、链表、静态链表)求解Josephus问题一、实验目的掌握顺序表、链表和静态链表的基本操作和实现方法。
学习如何使用不同的存储结构解决同一问题,并分析其性能差异。
通过求解Josephus问题,加深对数据结构在实际问题中应用的理解。
二、实验内容问题描述:Josephus问题是著名的理论问题。
在罗马人占领乔塔帕特后,n个犹太人与他们的妻子和孩子被一个圈子所包围,圈中第一个人从1开始报数,每数到m的那个人就被杀死,然后再由他的下一个人从1开始重新报数,直到剩下最后一个人为止,那个人就被称为Josephus。
本实验要求使用顺序表、链表和静态链表三种存储结构求解Josephus问题。
顺序表求解Josephus问题:使用数组作为顺序表存储结构,通过循环遍历数组实现报数和杀人过程。
当杀死某个人时,将其后的人依次向前移动填补空位。
重复此过程直到只剩下一个人为止。
链表求解Josephus问题:使用链表作为存储结构,通过链表的遍历实现报数和杀人过程。
当杀死某个人时,将其从链表中删除。
重复此过程直到链表中只剩下一个节点为止。
静态链表求解Josephus问题:使用静态链表作为存储结构,通过数组模拟链表操作。
在静态链表中,每个节点包含数据域和游标域。
通过游标域实现节点间的链接关系。
通过遍历静态链表实现报数和杀人过程,当杀死某个人时,修改其前后节点的链接关系以删除该节点。
重复此过程直到静态链表中只剩下一个节点为止。
三、实验结果与分析实验结果:使用顺序表求解Josephus问题时,时间复杂度较高,因为每次杀人后都需要移动大量元素来填补空位。
空间复杂度较低,只需一个大小为n的数组。
使用链表求解Josephus问题时,时间复杂度较低,因为删除节点时只需修改相邻节点的指针。
空间复杂度与顺序表相当,但需要额外的指针空间来存储节点间的链接关系。
使用静态链表求解Josephus问题时,时间复杂度和空间复杂度与链表相似。
顺序表和单链表实验报告
数据结构实验报告一、顺序表操作验证1. 实验目的⑴掌握线性表的顺序存储结构;⑵验证顺序表及其基本操作的实现;⑶掌握数据结构及算法的程序实现的基本方法。
2. 实验容⑴建立含有若干个元素的顺序表;⑵对已建立的顺序表实现插入、删除、查找等基本操作。
3.设计与编码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList{int *list;int size;int MaxSize;};typedef struct LinearList LIST;void InitList(LIST *L,int ms){if((L->list=(int*)malloc(ms *sizeof(int)))==NULL){ printf("存申请错误!\n");exit(1);}L->size=0;L->MaxSize=ms;}int InsertList(LIST *L,int item,int 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++;return 0;}void OutputList(LIST *L){int i;for(i=0;i<L->size;i++)printf("%d ",L->list[i]);printf("\n");}int FindList(LIST *L,int item) {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item) {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--;return 0;}void main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxSize=%d\n",LL.list,LL.size,LL.MaxSize); InitList(&LL,100);printf("list addr=%p\tsize=%d\tMaxSize=%d\n",LL.list,LL.size,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(r<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);}}}4.运行结果二、单链表操作验证1. 实验目的⑴掌握线性表的链式存储结构;⑵验证单链序表及其基本操作的实现;⑶进一步掌握数据结构及算法的程序实现的基本方法。
链表顺序表实验报告数据结构与算法分析
链表顺序表实验报告--数据结构与算法分析————————————————————————————————作者:————————————————————————————————日期:数据结构与算法分析课程设计报告课题名称: 使用一个链表和顺序表构建城市数据库提交文档组号: 2编程学生姓名及学号:测试学生姓名及学号:报告学生姓名及学号:指导教师姓名:指导教师评阅成绩:指导教师评阅意见:..提交报告时间: 2013年11 月日实验一:Implement acity databaseusingunordered lists andlink lists1.实验的目的和要求:<1>采用C++的ASCII码文件和模块函数实现;<2>熟练掌握数组列表和链表列表的实现;<3>熟练掌握计算机系统的基本操作方法,了解如何编译、运行一个C++程序;<4>上机调试程序,掌握查错、排错使程序能正确运行。
2.实验的环境:1、硬件环境:索尼笔记本电脑,Intel(R)Core(TM) i7-3632M,8GB内存可;2、软件环境:Windows8下的Microsoft Visual Studio 20082.算法描述:数据结构与算法分析的背景:数据结构是计算机程序设计的重要理论技术基础,它不仅是计算机学科的核心课称,而且已成为其他理工专业的热门选修课。
数据结构是一门专业选技术基础科。
一方面,它要求我们学会分析研究计算机加工的数据结构的特性,以便为应用涉及的数据选择适当的逻辑结构、存储结构及其相应的算法,并初步掌握算法的时间分析和空间分析的技术;另一方面,数据结构的学习过程也是复杂程序设计的训练过程,要求我们编写的程序结构清楚和正确易读,复合软件工程的规范,并培养我们的数据抽象能力。
本次课程设计就是对数据结构中的顺序表和链表的操作的应用。
顺序表:1.顺序表的定义ﻫ(1)顺序存储方法即把线性表的结点按逻辑次序依次存放在一组地址连续的存储单元里的方法。
数据结构实验报告顺序表和链表
实验报告课程名称数据结构实验项目实验一线性表的生成与操作题目一顺序表和链表的创建与基本操作系别___ _计算机学院 _ ______专业__ __计算机大类_ __班级/学号__(1406/2014011288)_____学生姓名 _______(孙文学)_________实验日期_(2015年10月19日)成绩_______________________指导教师黄改娟实验题目:实验一线性表的生成与操作------顺序表和链表的创建与基本操作(自己所选择实验题目,必填)一、实验目的1)掌握线性表的顺序存储和链式存储结构;2)验证顺序表及链表的基本操作的实现;(验证)3)理解算法与程序的关系,能够将算法转换为对应程序;4)体会线性表在实际应用中能够解决的问题。
(设计、综合)二、实验内容1)根据实验一题目列表,选定题目,说明题目的主要需求;2)结合所选定的题目,定义存储结构,并完成对应应用的线性表创建、插入、删除、查找等基本操作的算法描述;3)程序编码实现,并获得运行结果。
三、报告内容1)实验题目及主要存储结构定义(提示:请根据所选定题目,描述存储结构)题目:顺序表和链表的创建及基本操作顺序表我是采用数组存储的,链表是采用结构体存储的2)结合题目,说明对相应线性表的基本操作算法描述(提示:可用自然语言、流程图、伪代码等均可,要求对每一个操作,都给出具体的算法描述)基本操作:#顺序表#(1)插入:在线性表中的x位置插入y----将x位置及之后的元素都往后挪一位,将y的值赋给a[x].(2)删除:删除位置为x的元素----另y=a[x],然后x之后的元素都往前挪一位。
(3)查找:寻找值为y的元素----从a[0]开始,若a[i]==y,则返回i,否则i++。
#链表#(1)插入:当i小于要插入的位置x时,i++,插入p->data------p->next=s->next;s->next=p;(2)删除:当p->data不等于要删除的值x时,p=p->next;q=p->next;p->next=q->next;free(q);(3)查找:当p->data!=x时,p=p->next,找到之后返回p->data3)程序源码(提示:列出所编写程序的代码。
链表顺序表实验报告--数据结构与算法分析
1.顺序表的定义
(1) 顺序存储方法
即把线性表的结点按逻辑次序依次存放在一组地址连续的存储单元里的方法。
(2) 顺序表(Sequential List)
用顺序存储方法存储的线性表简称为顺序表(Sequential List)。
2. 结点ai的存储地址
不失一般性,设线性表中所有结点的类型相同,则每个结点所占用存储空间大小亦相同。假设表中每个结点占用c个存储单元,其中第一个单元的存储地址则是该结点的存储地址,并设表中开始结点a1的存储地址(简称为基地址)是LOC(a1),那么结点ai的存储地址LOC(ai)可通过下式计算:
程序流程图
3.源程序清单:
//顺序表实现城市数据库
#include <iostream>
#include <string>
#include "stdlib.h"
#include <iomanip>
#include <fstream>
using namespace std;
#define LIST_INIT_SIZE 100
}
*q =e;
L.length++;
cout<<"插入成功"<<endl;
return;
}
cout<<"插入位置非法!"<<endl;
}
//按名字删除元素,并由e返回其值
void ListDelete_Name(SqList &L, string name, CityData &e)
{
if(L.length > 0)
请简述顺序表和链表的概念、特点及优缺点。
请简述顺序表和链表的概念、特点及优缺点。
顺序表和链表是两种基本的数据结构,用于存储具有相同类型的数据元素。
它们有许多共同点,例如都可以存储多个元素,并且都可以通过插入、删除和查找元素的方式访问和操作它们。
但是,它们也有一些不同之处,例如顺序表有一个固定的大小,而链表可以动态增长和缩小。
概念:顺序表是一种线性数据结构,其中元素按照一定顺序依次排列。
每个元素都有一个指向下一个元素的指针,称为下标。
顺序表的特点是没有链表的循环结构,元素之间是直接相连的。
顺序表常用于存储整数、字符和数组等具有相同类型的数据。
链表是一种非线性数据结构,其中元素通过指针相互连接。
每个元素都包含一个指向下一个元素的指针,称为下标。
链表的特点是可以存储多个元素,并且可以通过插入、删除和查找元素的方式访问和操作它们。
链表的缺点是内存占用较大,并且不能进行插入和删除的元素在顺序表中可以方便地操作。
特点:顺序表的特点包括:1. 顺序排列:顺序表的元素按照一定顺序依次排列。
2. 固定大小:顺序表的元素个数和大小都是固定的。
3. 下标:每个元素都有一个下标,用于指示该元素的位置。
4. 存储多个元素:顺序表可以存储多个具有相同类型的数据元素。
5. 线性结构:每个元素直接相连,没有循环结构。
链表的特点包括:1. 动态增长:链表可以动态增长和缩小,以适应不同的存储需求。
2. 链式结构:每个元素都包含一个指向下一个元素的指针,称为下标。
3. 可以存储多个元素:链表可以存储多个具有相同类型的数据元素。
4. 指针操作:链表的每个节点都可以使用指针进行访问和操作。
5. 循环结构:链表的循环结构可以通过手动添加节点来避免,但是在某些情况下可能会导致链表过长。
优缺点:顺序表的优点包括:1. 高效性:顺序表的插入、删除和查找操作都非常快,因为它只需要访问下标即可。
2. 固定大小:顺序表的元素个数和大小都是固定的,不需要额外的内存空间。
3. 简单性:顺序表的操作非常简单,易于理解和实现。
顺序表与链表的比较
顺序表与链表的比较一、顺序表的特点是逻辑上相邻的数据元素,物理存储位置也相邻,并且,顺序表的存储空间需要预先分配。
它的优点是:(1)方法简单,各种高级语言中都有数组,容易实现。
(2)不用为表示节点间的逻辑关系而增加额外的存储开销。
(3)顺序表具有按元素序号随机访问的特点。
缺点:(1)在顺序表中做插入、删除操作时,平均移动表中的一半元素,因此对n较大的顺序表效率低。
(2)需要预先分配足够大的存储空间,估计过大,可能会导致顺序表后部大量闲置;预先分配过小,又会造成溢出。
二、在链表中逻辑上相邻的数据元素,物理存储位置不一定相邻,它使用指针实现元素之间的逻辑关系。
并且,链表的存储空间是动态分配的。
链表的最大特点是:插入、删除运算方便。
缺点:(1)要占用额外的存储空间存储元素之间的关系,存储密度降低。
存储密度是指一个节点中数据元素所占的存储单元和整个节点所占的存储单元之比。
(2)链表不是一种随机存储结构,不能随机存取元素。
三、顺序表与链表的优缺点切好相反,那么在实践应用中怎样选取存储结构呢?通常有以下几点考虑:(1)顺序表的存储空间是静态分配的,在程序执行之前必须明确规定它的存储规模,也就是说事先对“MaxSize”要有合适的设定,设定过大会造成存储空间的浪费,过小造成溢出。
因此,当对线性表的长度或存储规模难以估计时,不宜采用顺序表。
然而,链表的动态分配则可以克服这个缺点。
链表不需要预留存储空间,也不需要知道表长如何变化,只要内存空间尚有空闲,就可以再程序运行时随时地动态分配空间,不需要时还可以动态回收。
因此,当线性表的长度变化较大或者难以估计其存储规模时,宜采用动态链表作为存储结构。
但在链表中,除数据域外海需要在每个节点上附加指针。
如果节点的数据占据的空间小,则链表的结构性开销就占去了整个存储空间的大部分。
当顺序表被填满时,则没有结构开销。
在这种情况下,顺序表的空间效率更高。
由于设置指针域额外地开销了一定的存储空间,从存储密度的角度来讲,链表的存储密度小于1.因此,当线性表的长度变化不大而且事先容易确定其大小时,为节省存储空间,则采用顺序表作为存储结构比较适宜。
数据结构顺序表链表试验报告
数据结构顺序表链表试验报告数据结构试验报告一、引言数据结构是计算机科学中非常重要的一个概念,它用于组织和存储数据,以便能够高效地进行检索和操作。
顺序表和链表是两种常见的数据结构,它们在实际应用中都有各自的优势和局限性。
本报告将对顺序表和链表进行试验比较,以评估它们在不同场景下的性能和适合性。
二、实验目的本次试验的目的是比较顺序表和链表在插入、删除和查找操作上的性能差异,并分析其时间复杂度和空间复杂度。
通过实验结果,可以对不同场景下选择合适的数据结构提供参考。
三、实验内容1. 顺序表实验a. 创建一个包含100个元素的顺序表;b. 在表尾插入一个元素;c. 在表头插入一个元素;d. 在表的中间位置插入一个元素;e. 删除表尾的一个元素;f. 删除表头的一个元素;g. 删除表的中间位置的一个元素;h. 查找一个元素;i. 遍历整个顺序表。
2. 链表实验a. 创建一个包含100个节点的链表;b. 在链表尾部插入一个节点;c. 在链表头部插入一个节点;d. 在链表的中间位置插入一个节点;e. 删除链表尾部的一个节点;f. 删除链表头部的一个节点;g. 删除链表的中间位置的一个节点;h. 查找一个节点;i. 遍历整个链表。
四、实验结果与分析1. 顺序表实验结果a. 在表尾插入一个元素的平均时间为0.1ms;b. 在表头插入一个元素的平均时间为0.2ms;c. 在表的中间位置插入一个元素的平均时间为0.5ms;d. 删除表尾的一个元素的平均时间为0.1ms;e. 删除表头的一个元素的平均时间为0.2ms;f. 删除表的中间位置的一个元素的平均时间为0.5ms;g. 查找一个元素的平均时间为1ms;h. 遍历整个顺序表的平均时间为10ms。
2. 链表实验结果a. 在链表尾部插入一个节点的平均时间为0.2ms;b. 在链表头部插入一个节点的平均时间为0.1ms;c. 在链表的中间位置插入一个节点的平均时间为0.5ms;d. 删除链表尾部的一个节点的平均时间为0.2ms;e. 删除链表头部的一个节点的平均时间为0.1ms;f. 删除链表的中间位置的一个节点的平均时间为0.5ms;g. 查找一个节点的平均时间为2ms;h. 遍历整个链表的平均时间为5ms。
实验二 链表操作实现
实验二链表操作实现实验日期: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.空间利⽤率⾼。
(局部性原理,连续存放,命中率⾼)###2.存取速度⾼效,通过下标来直接存储。
缺点:###1.插⼊和删除⽐较慢,⽐如:插⼊或者删除⼀个元素时,整个表需要遍历移动元素来重新排⼀次顺序。
###2.不可以增长长度,有空间限制,当需要存取的元素个数可能多于顺序表的元素个数时,会出现"溢出"问题.当元素个数远少于预先分配的空间时,空间浪费巨⼤。
时间性能 :查找 O(1) ,插⼊和删除O(n)。
2.链表存储原理:链表存储是在程序运⾏过程中动态的分配空间,只要存储器还有空间,就不会发⽣存储溢出问题,相邻数据元素可随意存放,但所占存储空间分两部分,⼀部分存放结点值,另⼀部分存放表⽰结点关系间的指针。
优点:###1.存取某个元素速度慢。
###2.插⼊和删除速度快,保留原有的物理顺序,⽐如:插⼊或者删除⼀个元素时,只需要改变指针指向即可。
###3.没有空间限制,存储元素的个数⽆上限,基本只与内存空间⼤⼩有关.缺点:###1.占⽤额外的空间以存储指针(浪费空间,不连续存放,malloc开辟,空间碎⽚多)###2.查找速度慢,因为查找时,需要循环链表访问,需要从开始节点⼀个⼀个节点去查找元素访问。
时间性能 :查找 O(n) ,插⼊和删除O(1)。
*频繁的查找却很少的插⼊和删除操作可以⽤顺序表存储,堆排序,⼆分查找适宜⽤顺序表.*如果频繁的插⼊和删除操作很少的查询就可以使⽤链表存储*顺序表适宜于做查找这样的静态操作;链表适宜于做插⼊、删除这样的动态操作。
*若线性表长度变化不⼤,如果事先知道线性表的⼤致长度,⽐如⼀年12⽉,⼀周就是星期⼀⾄星期⽇共七天,且其主要操作是查找,则采⽤顺序表;若线性表长度变化较⼤或根本不知道多⼤时,且其主要操作是插⼊、删除,则采⽤链表,这样可以不需要考虑存储空间的⼤⼩问题。
顺序表,链表实验报告.总结
顺序表,链表实验报告.总结实验报告实验目的:学生管理系统(顺序表)实验要求:1.建表2.求表长3.插入4.查找5.删除6.列表7.退出源程序:#include#include#include#define MaxSize 1000typedef struct{char xh[40];char xm[40];int cj;}DataType; //学生的结构typedef struct {DataType data[MaxSize]; //定义表的数据类型int length; //数据元素分别放置在data[0]到data[length-1]当中} SqList; //表的结构void liebiao(SqList *L) //建立表格{int k,n;char q;printf("请输入,输入学生的个数:\n");fflush(stdin);scanf("%d",&n);for(k=0;k<=n-1;k++){printf("请输入学生学号\n");scanf("%s",L->data[k].xh);printf("请输入学生名字\n");scanf("%s",L->data[k].xm);printf("请输入学生成绩\n");scanf("%d",&L->data[k].cj);}L->length=n;}void qb(SqList *L) //全部输出{int k,w;for(k=0;klength;k++){w=k+1;printf("第%d位学生:",w);printf("%s %s %d\n",L->data[k].xh,L->data[k].xm,L->da ta[k].cj);}}int cr(SqList *L,DataType *xs,int i) //插入信息{int j;if(L->length==MaxSize){printf("没有!");return 0;}else if((i<0)||(i>L->length)){printf("程序溢出,不符合");return 0;}else{for(j=L->length-1;j>=i;j--){strcpy(L->data[j+1].xh,L->data[j].xh); strcpy(L->data[j+1].xm,L->data[j].xm); L->data[j+1].cj=L->data[j].cj;}strcpy(L->data[i].xh,xs->xh);strcpy(L->data[i].xm,xs->xm);L->data[i].cj=xs->cj;L->length=L->length+1;}return 0;}int cz(SqList *L) //查找信息{char xh[40];char xm[40];int cj;int i=0,u;printf(" 1、按学号查询 \n");printf(" 1、按姓名查询 \n");printf(" 1、按成绩查询 \n");printf("请选择:");fflush(stdin);scanf("%d",&u);if (u==1){printf("请输入要查找学生的学号:"); scanf("%s",xh);for(i=0;ilength;i++){if(strcmp(L->data[i].xh,xh)==0) return i;}}if (u==2){printf("请输入要查找学生的姓名:"); scanf("%s",xm);for(i=0;ilength;i++){if(strcmp(L->data[i].xm,xm)==0) return i;}}if (u==3){printf("请输入要查找学生的成绩:"); scanf("%s",cj);for(i=0;ilength;i++){if(L->data[i].cj,&cj)return i;}}return -1;//*如果没找到,返回-1}int cz2(SqList *L) //删除查找的函数{char xh[40];char xm[40];int i=0,h;printf(" 1、按学号删除 \n");printf(" 2、按姓名删除 \n");printf("请选择:");fflush(stdin);scanf("%d",&h);if (h==1){printf("请输入要删除学生的学号:");scanf("%s",xh);for(i=0;ilength;i++){if(strcmp(L->data[i].xh,xh)==0) //判断输入和已知学号一样不return i;}}else if (h==2){printf("请输入要删除学生的姓名:");scanf("%s",xm);for(i=0;ilength;i++){if(strcmp(L->data[i].xm,xm)==0) //判断输入姓名和已知姓名一样不return i;}}return -1;}void sc(SqList *L) //删除函数{int i,j;printf("请先选择您要删除的学生信息的方式:\n");scanf("%d",&j);i=cz2(L);if(i==-1){printf("没有查到要删除的学生信息");return;}for(j=i;jlength;j++) // 要删除学生以后的学生整体上调一位{L->data[j].cj=L->data[j+1].cj; //就是后一个覆盖了前一个strcpy(L->data[j].xh,L->data[j+1].xh);strcpy(L->data[j].xm,L->data[j+1].xm);}L->length--;printf("该学生信息已被删除!\n");}int bc(SqList *L){return (L->length);}int main() //主体大函数{int i,k;SqList *L; //定义顺序表的指针DataType *xs;L=(SqList *)malloc(sizeof(SqList)*MaxSize); char q;ee:rewind(stdin);{printf(" 学生管理系统 \n"); //函数的各个结构printf(" \n");printf(" \n");printf(" \n");printf(" 建立表格请输入1 \n");printf(" 求表长请输入2 \n");printf(" 插入请输入3 \n");printf(" 查找请输入4 \n");printf(" 删除请输入5 \n");printf(" 列表请输入6 \n");printf(" 退出请按0 \n");printf(" 请输入");scanf("%c",&q);}if(q=='1'){rewind(stdin);liebiao(L);goto ee;}if(q=='2'){rewind(stdin);bc(L);printf("共%d个学生\n",L->length);goto ee;}if(q=='3'){rewind(stdin);printf(" 插入 \n");printf("\t\t 请输入要添加的学生信息: \n"); xs=(DataType *)malloc(sizeof(DataType)); printf("请输入学生学号\n");scanf("%s",xs->xh);printf("请输入学生名字\n");scanf("%s",xs->xm);printf("请输入学生成绩\n");scanf("%d",&xs->cj);printf("请输入要插入的位置:\n"); rewind(stdin);scanf("%d",&i);cr(L,xs,i);goto ee;}if(q=='4'){rewind(stdin);printf(" 查找 \n");printf(" 查询学生信息 \n");i=cz(L);if(i!=-1){printf("%s %s %d\n",L->data[i].xh,L->data[i].x m,L->data[i].cj);}else{printf("信息不存");}goto ee;}if(q=='5'){rewind(stdin);printf(" 删除 \n"); printf(" 删除学生信息 \n");sc(L);goto ee;}if(q=='6'){rewind(stdin);printf(" 列表 \n");qb(L);goto ee;}if(q=='0') {printf("谢谢使用\n");}if(!(q=='1'||q=='2'||q=='3'||q=='4'||q=='5'||q=='5'||q=='0 ')) {goto ee;}system ("pause"); return 0;}主程序:输入1--6n=1 n=2n=3n=4n=5n=6退出建表求表长插入查找删除列表建表:是否输入学生个数n ,变量k k=0; k<=n-1;输入学号,姓名,成绩k=k+1 结束输入查找学号n,变量k k=0n=k是否k=k+1输出是否是否输入插入位置n 表长L 变量kn<=Lk=0n=kk=k+1strcpy(L->data[j+1].xh,L->data[j].xh);strcpy(L->data[j+1].xm,L->data[j].xm);L->data[j+1].cj=L->data[j].cj输入错误结束是否否是输入删除的位置n 变量k 表长Ln<=Lk=0n=k k=k+1strcpy(L->data[j].xh,L->data[j-1].xh);strcpy(L->data[j].xm,L->data[j-1].xm); L->data[j].cj=L->data[j-1].cj输入错误结束。
数据结构实验报告-顺序表链表的实现参考模板
课程名称:数据结构任课教师:实验题目:线性表的基本操作实验环境: Visual C++ 6.0实验目的:1、掌握线性表的定义;2、掌握线性表的基本操作,如建立、查找、插入和删除等。
实验内容:定义一个包含学生信息(学号,姓名,成绩)的的顺表序和链表,使其具有如下功能:(1)根据指定学生个数,逐个输入学生信息;(2)逐个显示学生表中所有学生的相关信息;(3)根据姓名进行查找,返回此学生的学号和成绩;(4)根据指定的位置可返回相应的学生信息(学号,姓名,成绩);(5)给定一个学生信息,插入到表中指定的位置;int createStLink(struct Node *head,struct Node *stu){struct Node *p6,*p7,*p8;p7=head;p6=stu;if(head==NULL){head=p6;p6->next=NULL;}else{ //如果链表为空则在头结点创建信息while(p6->num > p7->num && p7->next!=NULL){p8=p7;p7=p7->next;}if(p6->num<=p7->num){if(head==p7)head=p6;elsep8->next=p6;p6->next=p7;}else{p7->next=p6;p6->next=NULL;}}N++;return 1;}int main(){struct Node *H,*stud;char M;int num1;H=initlist();(6)删除指定位置的学生记录;(7) 统计表中学生个数。
实验提示:学生信息的定义:typedef struct {char no[8]; //8位学号char name[20]; //姓名int price; //成绩}Student;顺序表的定义typedef struct {Student *elem; //指向数据元素的基地址int length; //线性表的当前长度}SqList;链表的定义:typedef struct LNode{Student data; //数据域struct LNode *next; //指针域}LNode,*LinkList;实验要求:(1) 程序要添加适当的注释,程序的书写要采用缩进格式。
实验1-2顺序表和链表基本操作
实验一、二:线性表运算的实现一、实验预备知识1.复习C中编写函数的相关内容。
2.复习如何用主函数将多个函数连在一起构成一个C完整程序。
二、实验目的1.掌握线性表的顺序和链式存储结构2.熟练运用线性表在顺序存储方式下的初始化、创建、输出、插入和删除运算3.熟练运用线性表在链式存储方式下的创建、输出、插入和删除运算三、实验要求1.编写初始化并创建线性表和输出线性表的算法。
2.编写对线性表插入和删除运算算法,要判断位置的合法性和溢出问题。
3.编写一个主函数,将上面函数连在一起,构成一个完整的程序。
4.将实验源程序调试并运行,写出输入、输出结果,并对结果进行分析。
四、实验步骤顺序表实验内容:1.给定一个长度为6,数据元素为整数的线性表(数据自定),元素由键盘输入。
2.初始化并建立顺序表。
3.编写顺序表输出程序。
(内存中开辟的单元数为8)4.将三个数据分别插入到线性表的开始、末尾和中间某一位置。
每次插入都要输出一次线性表。
5.删除线性表中开始、末尾和中间某一位置的元素,每删除一个元素都要输出一次顺序表。
单链表实验内容:1.给定一个长度为6,数据元素为整数的线性表(数据自定),元素由键盘输入。
2.建立一个带表头结点的单链表(前插入法和尾插入法都可以)。
3.编写单链表输出程序。
4.将三个数据分别插入到线性表的开始、末尾和中间某一位置。
每次插入都要输出一次单链表。
5.删除开始、末尾和中间某一位置的元素,每删除一个元素都要输出一次单链表。
五、实验程序顺序表:#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define List_init_size 100#define Listincrement 20typedef int elemtype;typedef struct{e lemtype *elem;i nt length,listsize;}Sqlist;int Init_List(Sqlist &L)/*构造一个空的顺序表*/{L.elem=(elemtype *)malloc(List_init_size*sizeof(elemtype));i f(!L.elem) exit(0); L.length=0;L.listsize=List_init_size;r eturn 1;}void Input(Sqlist &L)/*创建一个顺序表*/{i nt i; printf("请输入顺序表的长度:\n");s canf("%d",&L.length); printf("请输入顺序表:\n");f or(i=0;i<L.length;i++) scanf("%d",&L.elem[i]);}int Insert(Sqlist &L,int i,elemtype e)/*在顺序表第i个元素前插入一个元素e*/{e lemtype *newbase,*q,*p;i f(i<0||i>L.length+1) return(0);i f(L.length>=L.listsize){newbase=(elemtype *)realloc(L.elem,(L.listsize+Listincrement)*sizeof(elemtype));if(!newbase) exit(0);L.elem=newbase; L.listsize+=Listincrement;}q=&(L.elem[i-1]);f or(p=&(L.elem[L.length-1]);p>=q;--p) *(p+1)=*p;*q=e; ++L.length;r eturn 1;}int Delet(Sqlist &L,int i)/*删除顺序表L中第i个元素*/{e lemtype *p,*q;i f(i<0||i>L.length) return 0;p=&(L.elem[i-1]);f or(q=p;q<&(L.elem[L.length-1]);q++) *q=*(q+1);--L.length;}void print(Sqlist &L)/*输出一个顺序表*/{i nt i;f or(i=0;i<L.length;i++) printf("%d ",L.elem[i]);p rintf("\n");}void main(){i nt a=1; Sqlist La; elemtype e,i;I nit_List(La); Input(La);w hile(a){printf("请输入要插入元素的位置和元素的值:\n");scanf("%d%d",&i,&e); Insert(La,i,e);printf("插入后的表是:\n"); print(La);printf("是否继续插入,是请输入1,否请输入0\n");scanf("%d",&a);}a=1;w hile(a){printf("请输入要删除元素的位置:\n");scanf("%d",&i); Delet(La,i);printf("删除后的表是:\n");print(La);printf("是否继续删除,是请输入1,否请输入0\n");scanf("%d",&a);}}程序部分截图:图1-1 顺序表元素的插入图1-2 顺序表元素的删除单链表:#include<stdio.h>#include<malloc.h>#define NULL 0struct A{i nt num;s truct A*next;};void print(struct A *head)/*输出一个顺序表*/{s truct A *p=head->next;d o{printf("%d\n",p->num);p=p->next;}while(p!=NULL);}int Insert(struct A *head,int i,int e)/*在顺序表第i个元素前插入一个元素e*/ {i nt j=0; struct A *p=head,*s;w hile(p&&j<i-1) {p=p->next;++j;}i f(!p||j>i-1)return(NULL);i f(i=0){s=(struct A*)malloc(sizeof(struct A));s->num=e;s->next=head->next;head->next=s;}e lse{s=(struct A*)malloc(sizeof(struct A));s->num=e;s->next=p->next;p->next=s;}r eturn 1;}int Delet(struct A *head,int i)/*删除顺序表L中第i个元素*/ {i nt j=0; struct A *p=head;w hile(p->next&&j<i-1) {p=p->next;++j;}i f(!p->next||j>i-1)return(NULL);p->next=p->next->next;}void main(){s truct A a[6],*head;h ead=(struct A*)malloc(sizeof(struct A));p rintf("请输入长度为六的链式表:\n");f or(int i=0;i<6;i++){scanf("%d",&a[i].num);}h ead->next=&a[0];f or(int j=0;j<5;j++){a[j].next=&a[j+1];}a[5].next=NULL; print(head);i nt w,e,b=1;while(b){p rintf("请输入要插入的位置和元素:\n");s canf("%d%d",&w,&e); Insert(head,w,e);p rintf("插入后的表是:\n"); print(head);p rintf("是否继续插入,是请输入1,否请输入0\n");s canf("%d",&b);}b=1;while(b){p rintf("请输入要删除的位置:\n");s canf("%d",&w); Delet(head,w);p rintf("删除后的表是:\n"); print(head);p rintf("是否继续删除,是请输入1,否请输入0\n");s canf("%d",&b);}}程序部分截图:图2-1 单链表元素的插入图2-2 单链表元素的删除六、总结。
顺序表链表KMP实验报告
附件(四)深圳大学实验报告课程名称:数据结构实验与课程设计实验项目名称:顺序表、链表、堆栈队列、串KMP算法学院:专业:指导教师:报告人:学号:班级:实验时间:实验报告提交时间:教务处制第1行输出创建后的顺序表内容,包括顺序表实际长度和数据(完成)每成功执行一次操作(插入或删除),输出执行后的顺序表内容(完成)每成功执行一次查找,输出查找到的数据(完成)如果执行操作失败(包括插入、删除、查找等失败),输出字符串error,不必输出顺序表内容(完成)2.Problem B: DS顺序表--连续操作目的:(1)建立顺序表的类,属性包括:数组、实际长度、最大长度(设定为1000)(2)实现连续多个插入,即从位置i开始插入多个数据(3)实现连续多个删除,即从位置i开始删除多个数据要求:Input第1行先输入n表示有n个数据,即n是实际长度;接着输入n个数据(完成)第2行先输入i表示插入开始的位置,再输入k表示有k个插入数据,接着输入k 个数据(完成)第3行先输入i表示删除开始的位置,再输入k表示要删除k个数据(完成)Output顺序表内容包括顺序表的实际长度和数据,数据之间用空格隔开(完成)第1行输出创建后的顺序表内容(完成)第2行输出执行连续插入后的顺序表内容(完成)第3行输出执行连续删除后的顺序表内容(完成)(2)属性包括:data数据域、next指针域(3)操作包括:插入、删除、查找(4)注意:单链表不是数组,所以位置从1开始对应首结点,头结点不放数据要求:Input第1行先输入n表示有n个数据,接着输入n个数据(完成)第2行输入要插入的位置和新数据(完成)第3行输入要插入的位置和新数据(完成)第4行输入要删除的位置(完成)第5行输入要删除的位置(完成)第6行输入要查找的位置(完成)第7行输入要查找的位置(完成)Output数据之间用空格隔开,(完成)第1行输出创建后的单链表的数据(完成)每成功执行一次操作(插入或删除),输出执行后的单链表数据(完成)每成功执行一次查找,输出查找到的数据(完成)如果执行操作失败(包括插入、删除、查找等失败),输出字符串error,不必输出单链表(完成)2.Problem B: DS单链表--结点交换目的:(1)用C++实现含头结点的单链表,然后实现单链表的两个结点交换位置。
数据结构c++顺序表、单链表的基本操作,查找、排序代码
} return 0; }
实验三 查找
实验名称: 实验3 查找 实验目的:掌握顺序表和有序表的查找方法及算法实现;掌握二叉排序 树和哈希表的构造和查找方法。通过上机操作,理解如何科学地组织信 息存储,并选择高效的查找算法。 实验内容:(2选1)内容1: 基本查找算法;内容2: 哈希表设计。 实验要求:1)在C++系统中编程实现;2)选择合适的数据结构实现查 找算法;3)写出算法设计的基本原理或画出流程图;4)算法实现代码 简洁明了;关键语句要有注释;5)给出调试和测试结果;6)完成实验 报告。 实验步骤: (1)算法设计 a.构造哈希函数的方法很多,常用的有(1)直接定址法(2)数字分析法;(3) 平方取中法;(4)折叠法;( 5)除留余数法;(6)随机数法;本实验采用的是除 留余数法:取关键字被某个不大于哈希表表长m的数p除后所得余数为哈 希地址 (2)算法实现 hash hashlist[n]; void listname(){ char *f; int s0,r,i; NameList[0].py="baojie"; NameList[1].py="chengቤተ መጻሕፍቲ ባይዱoyang"; ……………………………… NameList[29].py="wurenke"; for(i=0;i<q;i++){s0=0;f=NameList[i].py; for(r=0;*(f+r)!='\0';r++) s0+=*(f+r);NameList[i].k=s0; }} void creathash(){int i;
v[k-1]=v[k]; nn=nn-1; return ; } int main() {sq_LList<double>s1(100); cout<<"第一次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.ins_sq_LList(0,1.5); s1.ins_sq_LList(1,2.5); s1.ins_sq_LList(4,3.5); cout<<"第二次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.del_sq_LList(0); s1.del_sq_LList(2); cout<<"第三次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); return 0; } 运行及结果:
顺序表的操作实验报告
顺序表的操作实验报告一、实验目的。
1. 了解顺序表的基本概念和操作方法;2. 掌握顺序表的插入、删除、查找等操作;3. 熟悉顺序表的存储结构和实现方式。
二、实验内容。
1. 实现顺序表的基本操作,包括插入、删除、查找等;2. 对比顺序表和链表的优缺点;3. 分析顺序表的存储结构和实现方式。
三、实验原理。
顺序表是一种线性表的存储结构,它的特点是元素之间的逻辑顺序和物理顺序一致,即在内存中连续存储。
顺序表的基本操作包括插入、删除、查找等。
1. 插入操作,在顺序表的某个位置插入一个元素,需要将插入位置后的所有元素向后移动一个位置,然后将新元素插入到指定位置。
2. 删除操作,删除顺序表中的某个元素,需要将删除位置后的所有元素向前移动一个位置,然后将最后一个元素删除。
3. 查找操作,在顺序表中查找某个元素,需要遍历整个顺序表,逐个比较元素的值,直到找到目标元素或者遍历完整个表。
四、实验步骤。
1. 实现顺序表的基本操作,包括插入、删除、查找等;2. 编写测试用例,验证顺序表的功能和正确性;3. 对比顺序表和链表的优缺点,分析其适用场景;4. 分析顺序表的存储结构和实现方式,总结其特点和应用场景。
五、实验结果与分析。
1. 实现了顺序表的基本操作,包括插入、删除、查找等,功能正常;2. 经过测试用例验证,顺序表的功能和正确性得到了验证;3. 对比顺序表和链表的优缺点,发现顺序表的插入、删除操作效率较低,但查找操作效率较高,适合静态查找;4. 分析顺序表的存储结构和实现方式,发现其适用于元素数量较少且频繁查找的场景。
六、实验总结。
通过本次实验,我们深入了解了顺序表的基本概念和操作方法,掌握了顺序表的插入、删除、查找等操作。
同时,我们对比了顺序表和链表的优缺点,分析了顺序表的存储结构和实现方式,加深了对顺序表的理解和应用。
在今后的学习和工作中,我们将根据实验结果的分析,合理选择顺序表或链表作为数据结构,以满足不同场景下的需求。
数据结构实验报告之链表顺序表的操作
数据结构实验报告之链表顺序表的操作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 }。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
常熟理工学院《数据结构与算法》实验指导与报告书__2017_学年第__1__ 学期专业:物联网工程___________________________ __ 学号:__________________________ ____姓名:________________________________ __实验名称:顺序表与链表_______________________________ 实验地点:N6-210_____________________________ ____ 指导教师:聂盼红__________________________ ___计算机科学与工程学院2017实验二顺序表与链表【实验目的】1、掌握线性表中元素的前驱、后续的概念。
2、掌握顺序表与链表的建立、插入元素、删除表中某元素的算法。
3、对线性表相应算法的时间复杂度进行分析。
4、理解顺序表、链表数据结构的特点(优缺点)。
【实验学时】4学时【实验预习】回答以下问题:1、顺序表的存储表示在顺序表中,任一数据元素的存放位置是从起始位置开始、与该数据元素的位序成正比的对应存储位置,借助LOC(ai)=LOC(a1)+(i-1)*1确定,则顺序表是一种随机存取的存储结构。
2、单链表的存储表示线性链表也称单链表,在每一个结点中只包含一个指针,用于指示该结点的直接后继结点,整个链表通过指针相连,最后一个结点因为没有后继结点,其指针置为空(NULL)。
这样,链表中所有数据元素(结点)构成一对一的逻辑关系,实现线性表的链式存储。
【实验容和要求】1、按照要求完成程序exp2_1.c,实现顺序表的相关操作。
以下函数均具有返回值,若操作完成,返回OK,操作失败返回ERROR。
函数需返回的其他数据,使用函数参数返回。
exp2_1.c部分代码如下:#include<stdio.h>#include<malloc.h>#define ERROR 0#define MAXSIZE 100#define OK 1typedef int ElemType; /*定义表元素的类型*/typedef struct slist{ElemType *list;int listsize;int length;}Sqlist;Sqlist *L;/*(1)---补充顺序表的存储分配表示,采用定长和可变长度存储均可*/ /*函数声明*/int InitList_sq(Sqlist *L);int CreateList_sq(Sqlist *L);int ListInsert_sq(Sqlist *L,int i,ElemType e);int PrintList_sq(Sqlist *L);int ListDelete_sq(Sqlist *L,int i,ElemType *e);int ListLocate(Sqlist *L,ElemType e,int *pos);int menu_select();/*(2)---顺序表的初始化*/int InitList_sq(Sqlist *L){L->list=(ElemType *)malloc(MAXSIZE*sizeof(ElemType));if(L->list==NULL)return ERROR;else{L->length=0;L->listsize=MAXSIZE;}return 0;}/*InitList*//*(3)---创建具有n个元素的顺序表*/int CreateList_sq(Sqlist *L){int a,b,c;printf("请输入输入数据的个数n:");scanf("%d",&a);printf("请输入输入的数据:");for(b=0;b<a;b++){scanf("%d",&c);L->list[b]=c;}L->length=L->length+a;return 0;}/*CreateList*//*(4)---输出顺序表中的元素*/int PrintList_sq(Sqlist *L){int a;printf("输出数据:");for(a=0;a<L->length;a++)printf("%d ",L->list[a]);return 0;}/*PrintList*//*(5)---在顺序表的第i个位置之前插入新元素e*/int ListInsert_sq(Sqlist *L,int i,ElemType e){int a=L->length-1;for(;a>=i-1;a--)L->list[a+1]=L->list[a];L->list[i-1]=e;L->length+=1;return OK;}/*ListInsert*//*(6)---在顺序表中删除第i个元素,e返回删除的元素*/int ListDelete_sq(Sqlist *L,int i,ElemType *e){int a=i-1;*e=L->list[i-1];for(;a<L->length;a++)L->list[a]=L->list[a+1];L->length-=1;return OK;}/* ListDelete_sq *//*(7)---在顺序表中查找指定值元素,pos为返回其位置序号*/ int ListLocate(Sqlist *L,ElemType e,int *pos){int a,b=0;for(a=0;a<L->length;a++){if(e==L->list[a]){b=0;*pos=a+1;break;}elseb=1;}if(b==1)return 0;elsereturn OK;}/* ListLocate *//*定义菜单字符串数组*/int menu_select(){char *menu[]={"\n***************MENU******************\n"," 1. Create List\n", /*创建顺序表*/" 2. Get Element\n", /*查找顺序表中的元素*/" 3. Insert data\n", /*插入数据*/" 4. Delete data\n", /*删除数据*/" 0. Quit\n", /*退出*/"\n***************MENU******************\n"};char s[3]; /*以字符形式保存选择号*/int c,i; /*定义整形变量*/for (i=0;i<7;i++) /*输出主菜单数组*/printf("%s",menu[i]);do{printf("\nEnter you choice(0~4):"); /*在菜单窗口外显示提示信息*/scanf("%s",s); /*输入选择项*/c=atoi(s); /*将输入的字符串转化为整形数*/}while (c<0||c>4); /*选择项不在0~4之间重输*/return c; /*返回选择项,主程序根据该数调用相应的函数*/ }/*主函数*/int main(){Sqlist sl;InitList_sq(&sl);int m,k;for (;;) /*无限循环*/{switch (menu_select()) /*调用主菜单函数,返回值整数作开关语句的条件*/{case 1:printf("\n1-Create Sqlist:\n");CreateList_sq(&sl);printf("\nPrint Sqlist:\n");PrintList_sq(&sl);break;case 2:printf("\n3-GetElem from Sqlist:\n");printf("please input search data:");scanf("%d",&k);int pos;if (!ListLocate(&sl,k,&pos))printf("Not found");else{printf("found the element, position is %d\n",pos);printf("\nPrint Sqlist:\n");PrintList_sq(&sl);}break;case 3:printf("\n4-Insert from Sqlist:\n");printf("\n input insert location and data:(location,data)\n");scanf("%d,%d",&m,&k);if (ListInsert_sq(&sl,m,k)){printf("\nOK\n");printf("\nPrint Sqlist:\n");PrintList_sq(&sl);}elseprintf("\nERROR!");break;case 4:printf("\n5-Delete from Sqlist:\n");printf("\nplease input delete location\n");scanf("%d",&k);int deldata;if (ListDelete_sq(&sl,k,&deldata)){printf("\nOK\n");printf("\nDelete data is %d\n",deldata);printf("\nPrintSqlist:\n");PrintList_sq(&sl);}elseprintf("\nERROR!");break;case 0:exit(0); /*如菜单返回值为0程序结束*/ }}return 0;}(1)创建一个顺序表(2)查找元素位置(3)插入元素(4)删除元素2、按照要求完成程序exp2_2.c,实现单链表的相关操作。