实验一实验报告顺序表的合并
数据结构实验一顺序表实验报告
数据结构实验一顺序表实验报告
数据结构是计算机科学中的一门基础课程,在学习数据结构的过程中,顺序表是我们必须深入了解和掌握的重要数据结构之一。
在实验一中,我们对顺序表进行了一系列的操作,实现了增删改查等基本操作。
我们先来介绍一下顺序表的基本概念。
顺序表是将线性表中的数据存储在一段连续的存储空间中的数据结构,其查找效率高,但插入和删除操作效率较低。
顺序表需要预先分配一定的存储空间,当存储空间不足时需要进行动态扩容,即重新申请更大的存储空间并将原有数据复制到新的存储空间中。
在实验中,我们首先学习了顺序表的实现方式,包括顺序表的结构体定义、创建顺序表、插入元素、删除元素、修改元素以及查询元素等基本操作。
我们通过 C 语言来实现了这些操作,并将其封装成一个顺序表的 API,使其更加易于使用和维护。
在实验过程中,我们还发现顺序表中数据的存储顺序非常重要,因为顺序表中元素的存储顺序与元素的下标是一一对应的,如果存储的顺序错误,可能会导致元素的下标与我们想象中的不一致,从而造成一些意想不到的结果。
总的来说,实验一帮助我们更深入地了解了顺序表的实现方式和基本操作,同时也挖掘出了一些潜在问题,这对于我们今后的学习和实践都起到了很大的帮助。
顺序表实验报告
实验报告实验项目名称实验一线性表的操作所属课程名称数据结构实验类型验证实验实验日期2010-11-19院系数学与信息科学学院实验一线性表的操作一.实验目的1、掌握用上机调试线性表的基本方法;2、掌握线性表的基本操作,插入、删除、查找,以及线性表合并等简单操作在顺序存储结构上的运算。
二.实验环境硬件:计算机、256M以上内存,40G以上硬盘;软件:Windows XP , C++三.实验内容线性表基本操作的实现:构造一空线性表,将线性表置空,对线性表进行判空,求线性表的长度,查询线性表的第i个数据元素的值,查询要查询元素的上个元素的值,查询要查询元素的下个元素的值,删除线性表中的某个元素,将某元素插入线性表,对线性表进行查访并返回一特定的值。
给出两个线性表将其合并成一个线性表,销毁线性表。
四.实验步骤1、本实验的程序及头文件如下:SqlistMain.cpp#include"iostream.h"#include"stdio.h"#include"malloc.h"#include"stdlib.h"#include"SqListOperation.h"#include"function.h"#include "SqList.h"void main(){SqList L1,L2,L3;SqList *La=&L1,*Lb=&L2,*Lc=&L3;ElemType e;int m;InitList_Sq(La);InitList_Sq(Lb);cout<<"请输入线性表a"<<endl;EnterList_Sq(La);cout<<"输出线性表a"<<endl;PrintSqList(La);cout<<"输出线性表a长:"<<ListLength(La)<<endl;cout<<"验线性表a是否空表(空为1,不空为0):"<<ListEmpty(La)<<endl;cout<<"输入查询线性表a中元素的位置:";cin>>m;cout<<"输出线性表a中第m个元素:"<<GetElem(La,m)<<endl;cout<<"输入要查询元素的上个元素:";cin>>m;cout<<"输出性表a中第m个元素上个元素:"<<PriorElem(La,m)<<endl;cout<<"输入要查询元素的下个元素:";cin>>m;cout<<"输出线性表a中第m个元素下个元素:"<<NextElem(La,m)<<endl;cout<<"输入插入元素e及其位置m:";cin>>m>>e;ListInsert_Sq(La,e,m);cout<<"输出插入元素后的线性表a:"<<endl;PrintSqList(La);cout<<"输入删除元素位置m:";cin>>m;cout<<"除线性表a中第"<<m<<"个元素并输出其值:"<<ListDelete_Sq(La,m)<<endl;cout<<"输出删除元素后的线性表a:"<<endl;PrintSqList(La);cout<<"输入线性表b"<<endl;EnterList_Sq(Lb);cout<<"输出线性表b"<<endl;PrintSqList(Lb);cout<<"给线性表La按递增排序并输出:"<<endl;Sort_Increase(La);PrintSqList(La);cout<<"给线性表La按递增排序并输出:"<<endl;Sort_Increase(Lb);PrintSqList(Lb);cout<<"把线性表a和线性表b按非递减排列归并到线性表c,并输出线性表c:"<<endl;MergeList(La,Lb,Lc);PrintSqList(Lc);cout<<"删除线性表Lc"<<endl;ClearList(Lc);DestroyList(Lc);cout<<"输出删除线性表Lc后的表长:"<<ListLength(Lc)<<endl;}Function.hStatus InitList_Sq(SqList *L);Status DestroyList(SqList *L);Status ClearList(SqList *L);Status ListEmpty(SqList *L);int ListLength(SqList *L);Status GetElem(SqList *L,int i,ElemType *e);ElemType GetElem(SqList *L,int i);int LocateElem(SqList *L,ElemType e,Status (*compare)(ElemType a,ElemType e));Status PriorElem(SqList *L,ElemType cur_e,ElemType *pre_e);ElemType PriorElem(SqList *L,ElemType cur_e);Status NextElem(SqList *L,ElemType cur_e,ElemType *next_e);ElemType NextElem(SqList *L,ElemType cur_e);Status ListInsert_Sq(SqList *L,int i,ElemType e);Status ListDelete_Sq(SqList *L,int i,ElemType *e);ElemType ListDelete_Sq(SqList *L,int i);void PrintSqList(SqList *L);Status ListTraverse(SqList *L,Status (*visit)(ElemType *a));Status EnterList_Sq(SqList *L);Status compare(ElemType a,ElemType e);Status visit(ElemType *a);Status Union(SqList *La,SqList *Lb);Status MergeList(SqList *La,SqList *Lb,SqList *Lc);//Status MergeList_Sq(SqList *La,SqList *Lb,SqList *Lc);Status Sort_Increase(SqList *L);Status Sort_Reduce(SqList *L);SqlistOperation.h#define LIST_INIT_SIZE 100#define LISTINCREMENT 10#define OK 1#define ERROR 0#define TURE 1#define FALSE 0#define OVERFLOW 0#define INFEASIBLE 0typedef int Status;typedef int ElemType;typedef struct{ElemType *elem;int length;int listsize;}SqList;const int n=10;Sqlist.h//初始条件:已申明线性表类型为SqListStatus InitList_Sq(SqList *L){//构造一个空的顺序表L->elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L->elem) exit(ERROR);//存储分配失败L->length=0;//空表长度为零L->listsize=LIST_INIT_SIZE;//初始存储容量return OK;}//InitList_SqStatus EnterList_Sq(SqList *L){//初始条件:已存在空的顺序表//操作结果:给顺序表输入元素,并记录元素个数int i,m;ElemType *newbase;cout<<"输入所需输入线性表元素的个数"<<endl;cin>>m;newbase=(ElemType*)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(Ele mType));if(!newbase) exit(OVERFLOW);//存储分配失败L->elem=newbase;//新基址L->listsize+=LISTINCREMENT;//增加存储容量cout<<"依次输入所需元素:"<<endl;for(i=0;i<m;i++){cin>>L->elem[i];L->length++;}return OK;}Status DestroyList(SqList *L){//初始条件:顺序线性表L已存在。
顺序表的基本操作--插入,删除,合并
{
ElemType*newbase,*p,*q;
if(i<1||i>L->length+1)returnERROR;
if(L->length>=L->listsize)
{
newbase=(ElemType*)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(ElemType));
printf("Listsize: %d\n\n",La.listsize);
}
else
printf("error!");
/*------------------INIT-----------------*/
if(InitList_sq(&Lb))
{
printf("Init is ok!\n");
printf("Length: %d\n",Lb.length);
实验
准备
你为本次实验做了哪些准备:
在课后认真复习,基于上课的基础上,对于线性表的存储,插入,删除,合并等有了一定的了解,对于书上给出的程序反复捉摸,达到了较熟练的程度。
实验
进度
本次共有1个练习,完成个。
实验
总结
日
本次实验的收获、体会、经验、问题和教训:
顺序表初始化、插入、删除算法。
实现两个有序表合并算法.
for(i=1;i<=n;i++)
{
scanf("%d",&e) ;
数据结构实验报告 有序表的合并(优质参考)
数据结构实验报告实验题目:有序表的合并姓名:张耀班级:计嵌151学号: 1513052017一、实验目的把两个有序表归并为一个有序表。
二、数据结构设计(1)存储设计:采用带头结点的单链表存储数据。
输入:数据通过键盘有序输入输出:屏幕显示两个有序表及归并后的表(2)函数设计:CreateList(int n);// 创建具有n个元素的线性链表ListDisplay();//输出表元素Combine(LinkList LA, LinkList LB);//归并单链表LA,LB(3)两个有序表合并算法描述:Step1:初始化。
1.1设置工作指针pa,pb,分别指向两个有序表LA,LB的首元结点。
1.2生成新表LC的头结点,工作指针pc指向LC。
Step2:只要pa和pb有所指,循环执行下列操作。
2.1生成一新节点,链到LC表尾,pc指向它。
2.2如果pa->data<=pb->data:pc->data=pa->data;pa后移。
2.3否则:pc->data=pb->data;pb后移。
Step3:如果pa空,把pb开始的结点依次复制到pc后。
Step4: 如果pb空,把pa开始的结点依次复制到pc后。
三、算法设计与N-S图(1)算法设计:求归并表的过程是在元素有序的情况下不断地从两表中取出元素,添加到新表中,所以元素采取表尾插入。
设两个有序表SA,SB,归并后的有序表为SC,取元素的过程是:依次扫描SA,SB中的元素,比较当前元素的值,将较小的元素赋给SC,直到一个顺序有序表扫描完毕,然后将另一个顺序有序表中余下元素复制到SC中。
(2)程序流程图开始初始化:pa = LA.Head->next; pb = LB.Head->next;pc = Head;pa和pb都不为空生成新节点,连接到LC表尾,pc指向它pa->data<=pb->datapc->data = pb->data;pb = pb->next;pc->data = pa->data;pa = pa->next;pa==N ULLPb!=NULL把pb开始的结点依次复制到pc后面pb==N ULLPa!=NULL把pa开始的结点依次复制到pc后面四、程序清单#include<iostream>using namespace std;结束#include"process.h"struct Node{int data;//数据域,存放表元素Node *next;//指针域,指向下一个结点};class LinkList{private:Node *Head;// 链表头指针public:LinkList();//构造函数,创建空链表void CreateList(int n);//创建具有n个元素的线性链表void ListDisplay();//输出表元素void Combine(LinkList, LinkList);//合并};LinkList::LinkList(){//构建函数,建一空链表Head = new Node;Head->next = NULL;}void LinkList::CreateList(int n){//尾插法(正序)创建具有n个元素的线性表Node *p, *s;//设置工作指针。
实验一 顺序表 实验报告
顺序表实验报告一、实验内容和目的实验目的:掌握顺序表的建立、查找、插入和删除操作。
掌握有序表的建立、合并、插入操作。
实验内容:1. 顺序表的建立2. 顺序表的遍历3. 顺序表的元素查找4. 顺序表的元素插入5. 顺序表的元素删除6. 有序表的建立7. 有序表的遍历8. 有序表的元素插入9. 有序表的合并二、实验原理基本原理:通过连续的地址空间实现逻辑上和物理上连续的储存的一系列元素。
并在此基础上进行元素的添加,查找,删除操作。
有序表的插入算法:元素插入之前的,先跟有序表中的逐个元素进行对比,以找到合适的插入位置。
例如,已有有序表L,要向L 中插入元素18L={13,15,17,19,20,35,40}第一步:将18与L1进行比较,18 > L1,不是合适的插入位置。
第二步:将18与L2进行比较,18>L2,仍然不是不是的插入位置。
重复上述步骤,知道找到18≤Ln,然后在(n-1) 和n之间插入元素。
(如果元素比有序表中的所有元素都要大,则把该元素放到有序表的最后)此例子中,L n-1 = 17,L n = 19插入元素之后的有序表L为:L′={13,15,17,18,19,20,35,40}仍然保持有序。
重置光标的位置:程序接受两种方式的输入。
一种是输入数字后按回车,一种是利用空格间隔的连续几个数字。
然而,在使用后者输入数字的时候,会出现提示输出不正确的问题。
(如图)这个问题的原因简单如下:当程序输出“请输入第2个数字:”的时候,应该等待用户输入;然而,在程序等待输入第一个数字的时候,用户输入了五个数字。
因此,程序输出“输入第2个提示以后”,程序发现仍然有数据没有进行处理,因此把上次输入但未处理的字符当成是用户的输入。
所以没让用户输入数据就自动继续执行。
解决这个问题的思路:每次输出提示时,将光标移动到行首,因此,输出提示的时候会自动覆盖已经输出的提示信息。
效果如下:具体的解决方法:#include<windows.h>// 将光标移动到行首void ResetCursor(){HANDLE hOut;COORD cTarget;CONSOLE_SCREEN_BUFFER_INFO info;int y = 0;hOut = GetStdHandle(STD_OUTPUT_HANDLE);GetConsoleScreenBufferInfo(hOut, &info);y = info.dwCursorPosition.Y;cTarget.X = 0;cTarget.Y = y;SetConsoleCursorPosition(hOut, cTarget);}三、程序流程图四、实现步骤4.1 创建顺序表的实现①通过scanf 函数从键盘中读入数据,并通过scanf函数的返回值判断用户输入的是数字还是非数字,作为判断输入结束的判断。
顺序表的基本操作和实现实验报告(一)
顺序表的基本操作和实现实验报告(一)顺序表的基本操作和实现实验报告1. 引言顺序表是计算机科学中一种常用的数据结构,用于存储一组元素并支持快速的随机访问。
本实验旨在探究顺序表的基本操作和实现方法。
2. 实验目的•理解顺序表的概念和特性。
•学习顺序表的基本操作,包括插入、删除、查找和修改等。
•掌握顺序表的实现方法,包括静态分配和动态分配两种方式。
•培养对数据结构的抽象思维和编程能力。
3. 实验内容1.了解顺序表的定义,及其与数组的关系。
2.掌握插入操作的实现方法,包括在表头、表中和表尾插入元素。
3.掌握删除操作的实现方法,包括按索引删除和按值删除。
4.掌握查找操作的实现方法,包括按索引查找和按值查找。
5.掌握修改操作的实现方法,包括按索引修改和按值修改。
6.实现顺序表的静态分配和动态分配两种方式。
4. 实验步骤1.定义顺序表的结构体,包括数据存储区和长度属性。
2.实现插入操作,根据需要选择插入位置和移动元素。
3.实现删除操作,根据需要选择删除方式和更新长度。
4.实现查找操作,根据需要选择查找方式和返回结果。
5.实现修改操作,根据需要选择修改方式和更新元素。
6.实现顺序表的静态分配和动态分配方法。
5. 实验结果经过多次实验和测试,顺序表的基本操作都能够正确实现。
在插入操作中,能够将元素正确插入指定位置,并保持顺序表的有序性。
在删除操作中,能够按需删除指定位置或值的元素,并正确更新顺序表的长度。
在查找操作中,能够根据索引或值查找到对应的元素,并返回正确的结果。
在修改操作中,能够按需修改指定位置或值的元素,并更新顺序表的内容。
6. 实验总结本实验通过对顺序表的基本操作和实现方法的学习和实践,进一步巩固了对数据结构的理解和编程能力的培养。
顺序表作为一种常用的数据结构,对于解决实际问题具有重要的作用。
通过本次实验,我对顺序表的插入、删除、查找和修改等操作有了更深入的了解,并学会了如何实现这些操作。
通过本次实验,我还学会了顺序表的静态分配和动态分配方法,了解了它们的区别和适用场景。
实习01_线性表的顺序存储和操作(有序表的合并)
实验一线性表的顺序存储和操作(有序表的合并)1.目的用顺序表(SqList)类型实现书上算法2.1和2.2,了解线性表及在计算机中的两类不同的存储结构;熟练掌握线性表的查找、插入和删除等算法并灵活运用这些算法。
2.要求用C语言编写程序,其中Lb={2,4,6,8,10} La={1,2,3,4,5},①算法2.1执行后,得到的new La = 1,2,3,4,5,6,8,10②修改Lb=2,6,8,9,11,15,20,并利用新生成的La,得到合并后的Lc,Lc= 1,2,2,3,4,5,6,6,8,8,9,10,11,15,203、预习要求:1、复习书上第20页的例2-1和例2-2;2、复习算法2.3,理解如何构造线性表;3、复习算法2.7,理解算法的执行步骤和含义;4、项目介绍:前面的课程已经学习了如何用C语言描述顺序表、如何初始化顺序表、以及如何在顺序表中插入和删除数据元素。
现在通过两个顺序表的合并的实验,加深对顺序表的理解,熟悉如何将逻辑上的数学模型转化为计算机能够理解的指令代码。
该实验是数据结构课程的第一个实验,实验的目标除了加深理解课堂内容外,还对学生的动手能力提出了更高的要求,锻炼学生动手的能力。
5、算法设计#include <stdio.h>#include <stdlib.h>#include <malloc.h># define TRUE 1# define ERROR 0# define OK 1# define OVERFLOW -2# define FALSE 0# define LIST_INIT_SIZE 10# define LISTINCREMENT 5void main(){List La,Lb,Lc;int j,b[7]={2,6,8,9,11,15,20};InitList(La); // 创建空表La。
如不成功,则会退出程序的运行for(j=1;j<=5;j++) // 在表La中插入5个元素,依次为1、2、3、4、5 ListInsert(La,j,j);printf("La= ");ListTraverse(La,printer); // 输出表La的内容InitList(Lb); // 创建空表Lbfor(j=1;j<=5;j++) // 在表Lb中插入5个元素,依次为2、4、6、8、10 ListInsert(Lb,j,2*j);printf("Lb= ");ListTraverse(Lb,printer); // 输出表Lb的内容Union(La,Lb); // 调用算法2.1,将Lb中满足条件的元素插入La(不改变Lb) printf("new La= ");ListTraverse(La,printer); // 输出新表La的内容ClearList(Lb); // 清空表Lbfor(j=1;j<=7;j++) // 在表Lb中重新依次插入数组b[]的7个元素ListInsert(Lb,j,b[j-1]);printf("Lb= ");ListTraverse(Lb,printer); // 输出表Lb的内容MergeList(La,Lb,Lc); // 调用算法2.2,生成新表Lc(不改变表La和表Lb)printf("Lc= ");ListTraverse(Lc,printer); // 输出表Lc的内容}6.小结线性表是软件设计中最基础的数据结构。
数据结构 顺序表 实验报告
重庆交通大学计算机与信息学院数据结构实验报告实验名称:顺序表操作实验性质:课程安排实验所属课程:数据结构指导教师:班级: 2008级3班学号:姓名:完成时间: 2010年 4 月 7 日目录封面 (1)目录 (2)一、实验目的 (3)二、实验内容及要求................................................. (3)(1)实验内容(2)实现功能(3)上交内容三、实验设备及软件 (4)四、设计方案 (5)(一)题目:顺序表及其相关操作(二)设计的主要思路 (5)(三)主要功能 (5)(四)程序大致流程图 (6)五、主要代码(略) (7)六、测试结果及说明 (7)七、实验体会 (10)一、实验目的培养学生在程序设计方面知识的综合应用能力及程序设计能力(包括编制能力及程序调试能力)二、实验内容及要求(1)以顺序存储方式实现线性表进行简单的图书管理,图书信息由学生自行定义。
(2)主要实现以下功能:增加图书、删除图书、修改图书信息、查询与定位(查询方式由学生自行设计)、显示与浏览、图书信息文件的打开与保存等(3)上交内容:1、实验报告:要求内容充实、结构完整、格式规范、说明详细等2、源代码与数据文件:将所有的源代码与测试用数据文件一并压缩后提交注:实验报告、源代码中均需要注明自己的学号、姓名、年级、专业、班级等信息三、实验设备及软件计算机、Visual C++6.0四、设计方案(一)题目:顺序表及其相关操作(二)设计的主要思路1、建立能保存图书信息的数据类型,定义类book1)由于本次实验要求,图书信息自己定义,所以本次选用双精度型作为编号,字符串类型的名称和作者以及整型的页数;2)根据原来定义类的经验,本次程序同样定义了比较完善的共有成员函数,其中包括设置私有成员的值(含有函数重载,包括有参函数和无参函数)、私有成员数据的获取、book数据类型赋值符号的重载、输入、输出,以及文件操作的读入数据函数。
实验一 顺序表合并
{
scanf("%d",&e.da);
}
void MergeList_Sq(SqList La, SqList Lb, SqList &Lc)
{
ElemType *pa,*pb,*pc,*pa_last,*pb_last;
int n;//表示数据元素个数
int i;
ElemType e;
InitList_Sq(La);
InitList_Sq(Lb);
InitList_Sq(Lc);
printf("请输入线性表La\n");
printf("请输入线性表La的元素个数:");
scanf("%d",&n);
for (p = &(L.elem[L.length-1]); p>=q; --p)
*(p+1) = *p;
// 插入位置及之后的元素右移
*q = e; // 插入e
++L.length; // 表长增1
return OK;
} // ListInsert_Sq
int ListDelete_Sq(SqList &L, int i, ElemType &e)
{
inputdataelem(e);
ListInsert_Sq(Lb,i,e);
}
MergeList_Sq(La,Lb,Lc);
outputdata(Lc);
printf("\n");
[计算机]实验一实验报告顺序表的合并
实验题目:顺序表的合并一、实验目的掌握顺序表的基本操作理解并分析算法的时间复杂度二、实验内容:实现两个有序(从小到大)的顺序表合并成为一个顺序表,合并后的结果放在第一个顺序表中(假设这两个有序顺序表中没有两个相同的元素)。
三、设计与编码1、基本思想从第二个表中从小到大依次取出一个元素与第一个表中的元素逐个进行比较,如果遇到第一个比它小的数就插到这个数后面,直到第二个表全部比较完。
2、编码#include <stdlib.h>#include <iostream.h>const int MaxSize=100; //100只是示例性的数据,可以根据实际问题具体定义class SeqList{public:SeqList(); //无参构造函数SeqList(int a[], int n); //有参构造函数~SeqList(){} //析构函数为空int Length(){return length;} //求线性表的长度int Get(int i); //按位查找,取线性表的第i个元素friend void MergeList(SeqList &A,SeqList B); //合并顺序表void PrintList(); //遍历线性表,按序号依次输出各元素private:int data[MaxSize]; //存放数据元素的数组int length; //线性表的长度};SeqList::SeqList(int a[],int n){if(n>MaxSize)cout<<"参数非法";for(int i=0;i<n;i++){data[i]=a[i];length=n;}}int SeqList::Get(int i){if (i<1||i>length) throw "查找位置非法";else return data[i-1];int x=data[i-1];}void SeqList::PrintList(){for(int i=0;i<length;i++)cout<<data[i]<<" ";cout<<endl;}void MergeList(SeqList &A,SeqList B){int a;for (int i=0;i<B.length;i++){a=-1;for(int j=0;j<A.length;j++){if (B.data[i]<A.data[j]){a=j;break;}}if(a==-1){A.data[A.length]=B.data[i];A.length++;}else{for(int k=A.length-1;k>=a;k--)A.data[k+1]=A.data[k];A.data[a]=B.data[i];A.length++;}}}void main(){int a[100];int n=4;for(int i=0;i<n;i++ ){cin>>a[i];}int b[100];int m=4;for(int j=0;j<m;j++ ){cin>>b[j];}SeqList La(a,4),Lb(b,4);La.PrintList ();Lb.PrintList ();MergeList(La,Lb);La.PrintList ();}四、调试与运行1、调试时遇到的主要问题及解决遇到的主要问题:没有把找到的位置用一个变量记下解决方法:通过请教同学2、运行结果(输入及输出,可以截取运行窗体的界面)五、实验心得写程序的过程中如果卡住了就一定要请教一下同学,不要一错再错,也许一经过同学提醒就一下子懂了,胜过你一直在那儿磨。
数据结构顺序表操作实验报告
实验1 顺序表的操作一、实验要求1.输入一组整型元素序列,建立顺序表。
2.实现该顺序表的遍历。
3.在该顺序表中进行顺序查找某一元素,查找成功返回1,否则返回0。
4.判断该顺序表中元素是否对称,对称返回1,否则返回0。
5.实现把该表中所有奇数排在偶数之前,即表的前面为奇数,后面为偶数。
6.* 输入整型元素序列利用有序表插入算法建立一个有序表。
7.* 利用算法6建立两个非递减有序表并把它们合并成一个非递减有序表。
8.编写一个主函数,调试上述算法。
二、源代码#include"stdio.h"#include"stdlib.h"#define ElemType int//int类型宏定义#define MAXSIZE 100//顺序结构typedef struct{ElemType elem[MAXSIZE]; //元素数组int length; //当前表长}SqList;//建立顺序表void BuildList(SqList &L){int n;printf("请输入建立顺序表的大小。
n=");scanf("%d",&n);L.length=n;printf("\n开始建立顺序表...\n");for(int i=0;i<L.length;i++)//循环建立顺序表{printf("\n请输入第%d个元素:",i+1);scanf("%d",&L.elem[i]);}printf("\n建立顺序表完毕!...\n");}//遍历顺序表void ShowList(SqList &L){int i;printf("\n开始遍历顺序表...\n");for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);printf("\n遍历结束...\n");}//在顺序表中寻找X元素int FindList(SqList &L,int x){int a=0;for(int i=0;i<L.length;i++){if(L.elem[i]==x)a=1;}if(a==1)printf("1\n");elseprintf("0\n");return 0;}//判断是否对称int Duichen(SqList &L){int j,b=1,n;n=L.length;if(n%2==0){for(j=0;j<n/2;j++){if(L.elem[j]!=L.elem[L.length-j-1])b=0;}}elsefor(j=0;j<(n-1)/2;j++){if(L.elem[j]!=L.elem[L.length-j-1])b=0;}if(b==1)printf("1\n");elseprintf("0\n");return 0;}//前面为奇数,后面为偶数void PaixuList(SqList &L){int i,j,a;for(i=1;i<L.length;i++){if(L.elem[i]%2==1){a=L.elem[i];for(j=i;j>0;j--){L.elem[j]=L.elem[j-1];}L.elem[0]=a;i++;}}for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);printf("\n");}int main(){SqList List;int n;while(1){printf("\n 实验一:顺序表\n");printf("\n******************************************************************");printf("\n 1.创建顺序表");printf("\n 2.遍历顺序表");printf("\n 3.在该顺序表中进行顺序查找某一元素,查找成功返回1,否则返回0");printf("\n 4.判断该顺序表中元素是否对称,对称返回1,否则返回0");printf("\n 5.该表中所有奇数排在偶数之前,即表的前面为奇数,后面为偶数");printf("\n 0.退出");printf("\n******************************************************************\n");printf("\n请输入选择序号:");scanf("%d",&n);switch(n){case 0:return 0;case 1:BuildList(List);break;case 2:ShowList(List);break;case 3:int X;printf("请输入要查找值:X=");scanf("%d",&X);FindList(List,X);break;case 4:Duichen(List);break;case 5:PaixuList(List);break;default:printf(" 请输入数字0-5 \n");}}return 0;}三、运行结果1)程序主界面2)选择1建立顺序表3)选择2遍历顺序表4)选择3查询元素X5)选择4判断是否对称6)选择5奇数在前,偶数在后7)选择0退出。
数据结构实验一顺序表实验报告
数据结构实验一顺序表实验报告数据结构实验一顺序表实验报告一、实验目的顺序表是一种基本的数据结构,本次实验的目的是通过实现顺序表的基本操作,加深对顺序表的理解,并掌握顺序表的插入、删除、查找等操作的实现方法。
二、实验内容1. 实现顺序表的创建和初始化操作。
2. 实现顺序表的插入操作。
3. 实现顺序表的删除操作。
4. 实现顺序表的查找操作。
5. 实现顺序表的输出操作。
三、实验步骤1. 创建顺序表的数据结构,包括数据存储数组和记录当前元素个数的变量。
2. 初始化顺序表,将当前元素个数置为0。
3. 实现顺序表的插入操作:- 判断顺序表是否已满,若已满则输出错误信息。
- 将插入位置之后的元素依次后移一位。
- 将要插入的元素放入插入位置。
- 当前元素个数加一。
4. 实现顺序表的删除操作:- 判断顺序表是否为空,若为空则输出错误信息。
- 判断要删除的位置是否合法,若不合法则输出错误信息。
- 将删除位置之后的元素依次前移一位。
- 当前元素个数减一。
5. 实现顺序表的查找操作:- 遍历顺序表,逐个比较元素值与目标值是否相等。
- 若找到目标值,则返回该元素的位置。
- 若遍历完整个顺序表仍未找到目标值,则返回错误信息。
6. 实现顺序表的输出操作:- 遍历顺序表,逐个输出元素值。
四、实验结果经过实验,顺序表的各项操作均能正确实现。
在插入操作中,可以正确将元素插入到指定位置,并将插入位置之后的元素依次后移。
在删除操作中,可以正确删除指定位置的元素,并将删除位置之后的元素依次前移。
在查找操作中,可以正确返回目标值的位置。
在输出操作中,可以正确输出顺序表中的所有元素。
五、实验总结通过本次实验,我深入了解了顺序表的原理和基本操作,并通过实际编程实现了顺序表的各项功能。
在实验过程中,我遇到了一些问题,如如何判断顺序表是否已满或为空,如何处理插入和删除位置的合法性等。
通过查阅资料和与同学讨论,我解决了这些问题,并对顺序表的操作有了更深入的理解。
1实验一:数据结构两个顺序表的合并
学生姓名:学号:专业班级:实验类型:□验证□综合□设计□创新实验日期:2014.10.27 实验成绩:一、实验次数实验一二、实验项目名称两个顺序表的合并三、实验基本原理#include<iostream>using namespace std;#define MAXSIZE 100typedef struct {int *elem;int length;}List;void InitList(List &L){L.elem=new int[MAXSIZE];L.length=0;}void ListInput(List &L,int n){int i;cout<<"请输入"<<n<<"个数:\n"; for(i=0;i<n;i++)cin>>L.elem[i];L.length=n;}int ListLength(List L){return L.length;}void GetElem(List L,int i,int &e) {e=L.elem[i-1];}bool LocateElem(List L,int e){int i;for(i=0;i<L.length;i++)if(e==L.elem[i])return true;return false;}void ListInsert(List &L,int e) {L.elem[L.length]=e;L.length++;}void ListOutput(List L){int i;for(i=0;i<L.length;i++)cout<<L.elem[i]<<" ";cout<<endl;}void unionList(List &LA,List LB) {int LA_len,LB_len,i,e;LA_len=ListLength(LA);LB_len=ListLength(LB); for(i=1;i<=LB_len;i++){GetElem(LB,i,e);if(!LocateElem(LA,e))ListInsert(LA,e);}}int main(){List LA,LB;int n,m;InitList(LA);InitList(LB);cout<<"请输入线性表LA的元素个数:"; cin>>n;ListInput(LA,n);cout<<"请输入线性表LB的元素个数:";cin>>m;ListInput(LB,m);unionList(LA,LB);cout<<"LA和LB合并后的集合为:\n";ListOutput(LA);return 0;}四、主要仪器设备及耗材PC机,Microsoft Visual Studio 2005软件五、实验步骤六、思考讨论题或体会或对改进实验的建议要注意代码拼写有误,标点符号错误和括号不匹配的问题。
有序表的合并的标准实验报告Word版
软件工程专业类课程实验报告课程名称:学院专业:学生姓名:学号:指导教师:日期:电子科技大学计算机学院实验中心电子科技大学实验报告一、实验室名称:二、实验项目名称:有序单链表的合并三、实验原理:合并单链表算法的思想描述,因这是本实验重点,这里老是就不写了。
四、实验目的:1. 掌握带头结点的单链表建立,插入,删除,查找等基本操作的设计与实现2. 通过单链表的排序编程理解单链表与顺序表操作的区别与联系3. 理解单链表对集合操作的实现4. 掌握有序集合合并的算法设计与存储结构的关系,及时空复杂度与算法性能的关系五、实验内容:1. 编程实现建立单链表的操作2. 编程实现单链表的排序3. 编程实现用单链表合并有序表,使得合并结果有序,但是要求不额外增加内存空间存放合并后的数据,时间开销尽量少六、实验器材(设备、元器件):电脑1台;XP或者windows 7操作系统Visual studio 2010开发环境七、实验步骤:1. 项目分析与概要设计(1)输入:第一个单链表长度第一个单链表的所有数据第二个单链表长度第二个单链表的所有数据(2)输出:2个有序单链表合并成一个有序表(3)算法分析与概要设计:a). 实现两个有序单链表的合并,首先要保证输入的单链表有序,因此要判断单链表是否有序,如果无序,要先重新对单链表进行排序,然后才能够做合并操作。
b). 因为单链表合并后不能增加额外空间,所以原来单链表的结点要串连到新的合并后的单链表中,原来的单链表合并后将不再存在。
原来的单链表有2个头结点,合并后只有一个单链表,因此有一个头结点将被释放。
这里选择A集合的头结点为合并后的头结点,而原来B集合的头结点将被释放。
合并有序单链表的算法流程图见图1所示。
图1 有序单链表的合并的概要设计流程图2. 数据结构与详细设计(1)数据结构采用带头结点的单链表存储数据,结点结构如下:struct node {int value;struct node * next;};typedef struct node Node;typedef struct node *ptrList,*List;(2)详细设计根据概要设计流程图,需要实现如下功能:建立带头结点的单链表;判断单链表是否有序;单链表排序;合并有序表使其仍然有序;打印输出单链表的所有数据。
顺序表合并实验体会
顺序表合并实验体会
在进行顺序表合并的实验过程中,我深刻体会到了数据结构的重要性以及合并操作的灵活性。
通过这个实验,我进一步巩固了对顺序表的理解,并学会了如何将两个有序的顺序表合并成一个有序表。
在合并两个顺序表时,我首先需要判断两个表是否为空,若有一个为空,则直接返回另一个表。
然后,我创建一个新的顺序表作为合并后的结果表,并设置两个指针分别指向两个表的起始位置。
接下来,我使用循环来比较两个指针所指向的元素大小,并将较小的元素插入结果表中。
然后,将指向较小元素的指针向后移动一位,再次进行比较,重复这个过程直到其中一个表中的元素全部插入到结果表中。
当其中一个表的元素全部插入到结果表后,我将剩余的表中的元素依次插入到结果表的末尾。
最后,返回结果表即可完成合并操作。
通过这个实验,我深刻认识到了顺序表合并的重要性。
顺序表合并不仅可以提高数据存储的效率,还可以简化数据操作的过程。
在实际应用中,顺序表合并被广泛应用于各个领域,如数据库查询、数据分析等。
在实验中我还发现,合并操作的灵活性可以通过改变合并的顺序来实现不同的效果。
例如,如果我将两个表的元素按照从大到小的顺
序合并,则结果表将按照从大到小的顺序排列。
这种灵活性使得顺序表合并操作具有很大的应用潜力。
总的来说,顺序表合并实验让我更加深入地理解了数据结构中的顺序表,并通过实际操作掌握了顺序表合并的方法和技巧。
这对我以后的学习和工作都具有重要的意义。
通过这个实验,我不仅提高了对数据结构的理解能力,还锻炼了自己的编程能力和问题解决能力。
我相信,在今后的学习和工作中,这些能力都将对我产生积极的影响。
算法分析与设计实验报告合并排序、快速排序[汇总]
实验报告实验一合并排序、快速排序一.实验目的(1)学习合并排序和快速排序算法的思想,掌握原理。
(2)运用合并排序和快速排序算法的思想进行编程实现,以加深理解。
二.实验内容(1)输入几个整数,运用合并排序的思想进行编程实现,输出正确的排序结果。
(2)输入10个整数,运用快速排序的思想进行编程实现,输出正确的排序结果三.实验代码(1)合并排序源代码如下:#include <iomanip.h>//调用setw#include <iostream.h> //将b[0]至b[right-left+1]拷贝到a[left]至a[right]template <class T>void Copy(T a[],T b[],int left,int right){ int size=right-left+1;for(int i=0;i<size;i++){a[left++]=b[i];}} //合并有序数组a[left:i],a[i+1:right]到b,得到新的有序数组btemplate <class T>void Merge(T a[],T b[],int left,int i,int right){ int a1cout=left,//指向第一个数组开头a1end=i,//指向第一个数组结尾a2cout=i+1,//指向第二个数组开头a2end=right,//指向第二个数组结尾bcout=0;//指向b中的元素for(int j=0;j<right-left+1;j++)//执行right-left+1次循环{ if(a1cout>a1end){ b[bcout++]=a[a2cout++];continue; } //如果第一个数组结束,拷贝第二个数组的元素到bif(a2cout>a2end){b[bcout++]=a[a1cout++];continue; } //如果第二个数组结束,拷贝第一个数组的元素到bif(a[a1cout]<a[a2cout]){ b[bcout++]=a[a1cout++];continue; } //如果两个数组都没结束,比较元素大小,把较小的放入belse{ b[bcout++]=a[a2cout++];continue;} } } //对数组a[left:right]进行合并排序template <class T>void MergeSort(T a[],int left,int right){ T *b=newint[right-left+1];if(left<right){int i=(left+right)/2;//取中点MergeSort(a,left,i);//左半边进行合并排序MergeSort(a,i+1,right);//右半边进行合并排序Merge(a,b,left,i,right);//左右合并到b中Copy(a,b,left,right);//从b拷贝回来}}int main(){ int n;cout<<"请输入您将要排序的数目:"; cin>>n;int *a=new int[n]; cout<<"请输入相应的数字:";for(int i=0;i<n;i++){ cin>>a[i]; }MergeSort( a, 0, n-1); cout<<"排序结果:";for(int j=0;j<n;j++){ cout<<setw(5)<<a[j]; }cout<<endl;return 1;}(2)快速排序源代码如下:#include <iostream.h>#define MAX 10int QuickSort(int a[],int l,int r){int pivot;//枢轴int i=l;int j=r;int tmp;pivot=a[(l+r)/2];//取数组中间的数为枢轴do {while (a[i]<pivot) i++; //i右移while (a[j]>pivot) j--; // j左移if (i<=j){tmp=a[i];a[i]=a[j];a[j]=tmp;//交换a[i]和a[j]i++;j--;}} while(i<=j);if (l<j) QuickSort(a,l,j);if (i<r) QuickSort(a,i,r);return 1;}int main(){int array[MAX];int i;cout<<"请输入"<<MAX<<" 个整数:"; for (i=0;i<MAX;i++)cin>>array[i];QuickSort(array,0,MAX-1);cout<<"快速排序后:"<<endl;for (i=0;i<MAX;i++)cout<<array[i]<<" ";cout<<endl;return 0;}四.实验结果五.总结与思考。
顺序表的合并
实验题目:顺序表的合并一、实验目的(1)、掌握顺序表的基本操作(2)、理解并分析算法的时间复杂度二、实验内容实现两个有序(从小到大)顺序表合并成为一个顺序表,合并后的结果放在第一个顺序表中(假设这两个有序顺序表中没有相同的元素)。
三、设计与编码1、基本思想合并两数组再用冒泡法从小到大排序2、C++编码#include<iostream>using namespace std;class as{private:int length1;int length2;int arr1[21];int arr2[21];int length;public:as(int len1,int a[],int len2,int b[]){int i;length1=len1;length2=len2;for(i=0;i<length1;i++)arr1[i]=a[i];for(i=0;i<length2;i++)arr2[i]=b[i];}int intser(){length=length1+length2;int i,j,t;for(i=0;i<length2;i++)arr1[length1+i]=arr2[i];for(i=0;i<length;i++)for(j=length-1;j>i;j--)if(arr1[j]<arr1[j-1]){t=arr1[j-1];arr1[j-1]=arr1[j];arr1[j]=t;}}return length;}void show(){int i;cout<<arr1[0];for(i=1;i<length;i++)cout<<" "<<arr1[i];}};int main(){int n,y;cin>>n;while(n--){int i,n1,n2,a[21],b[21];cin>>n1;for(i=0;i<n1;i++)cin>>a[i];cin>>n2;for(i=0;i<n2;i++)cin>>b[i];if(n1+n2>20){cout<<"not enough"<<endl;return 0;}as A(n1,a,n2,b);y=A.intser();cout<<y<<endl;A.show();cout<<endl;}}四、调试与运行1、调试时遇到的主要问题及解决少了“;”,“字母大小写没注意”2、运行结果(输入及输出,可以截取运行窗体的界面)五、实验心得通过这次实验,我认识到了我的不足,也懂得了很多。
实验报告 顺序表实验
《数据结构》实验报告1.上机题目:顺序表实验2.需求分析实现顺序表的建立、输出、查找、插入、删除、合并几项功能。
明确说明程序的开发环境和功能要求。
针对主要功能,给出如下说明:(1)输入参数的格式和合法取值范围输入参数范围输入格式菜单选择数字 0—6, getche()接受键盘上对应的按钮数据输入 0—9999 scanf(“%s”,data)程序是否执行 y n getche()接受键盘上对应按键(2)输出的格式输出参数输出格式文字输出 printf(“******”);数据输出 printf(“%d”,data[i])(3)测试数据能够完成顺序表的建立、输出、查找、插入、删除、合并几项功能。
********************************* 1.建立一个顺序表 ** 2.输出一个顺序表 ** 3.在顺序表中查找 ** 4.向顺序表中插入一个元素 ** 5.删除顺序表中的一个元素 ** 6.将两个顺序表合并 ** 0.退出 *********************************(4)开发环境Vc6.03.详细设计(1)确定存储结构,并给出所用数据类型的数据结构定义采用顺序表存储的线性表。
利用内存中的一片起始位置确定的连续存储区域来存放表中的所以元素。
可以根据需要对表中的任何数据元素进行访问,元素的插入,删除可以在表中任何位置进行。
typedef struct {ElemType data[MAXSIZE];int length;}SqList;(2)给出所用数据类型中每个操作的伪码算法A.初始化建立的顺序表Void InitList(SqList &L)置 L.length 为 0B.建立新的顺序表Void CreatSqlist(SqList &L,int n)开辟一个数据结构空间,容量是MAXSIZEif str 是四位正整数记录else重新输入正确值C.输出顺序表int Output(SqList L)if L.length 等于 0return 0elsereturn 1D. 在顺序表中按位置取值int GetElem(SqList L,int i)if 取值不在线性表范围内return -9999;elsereturn L.data[i];E.在顺序表中按位置取值int LocateElem(SqList L,ElemType x)While x=L.data[k]if(k<L.length)return k;elsereturn -1;F.在i处插入元素int Insert(SqList &L,ElemType x,int i)if 不在k的范围内插入return 0;else在 i处插入元素return 1;G.在i处删除元素int Delete(SqList &L,int i)if i不在L.length范围内return 0;else删除i处的元素return 1;H. 合并la lb两个顺序表Void MergeList(SqList la,SqList lb,SqList &lc) la,lb升序排序la先存在lclb再存在lc4.调试分析(1)调试过程中主要遇到哪些问题?是如何解决的?A.在程序结束时如果按书上的代码printf("继续执行吗Y(1)/N(0): ");scanf("%d",&k);if(!k)return;只要不输入0都会继续执行代码,所以我想让此时的程序只识别 y 和 n 两个按键通过查找 y的键盘值是 0x0079N的键盘值是 0x006e通过 key=getche(),判断key的值来决定标志位的值来。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验题目:顺序表的合并
一、实验目的
掌握顺序表的基本操作
理解并分析算法的时间复杂度
二、实验内容:实现两个有序(从小到大)的顺序表合并成为一个顺序表,合并后的结果放在第一个顺序表中(假设这两个有序顺序表中没有两个相同的元素)。
三、设计与编码
1、基本思想
从第二个表中从小到大依次取出一个元素与第一个表中的元素逐个进行比较,如果遇到第一个比它小的数就插到这个数后面,直到第二个表全部比较完。
2、编码
#include <stdlib.h>
#include <iostream.h>
const int MaxSize=100; //100只是示例性的数据,可以根据实际问题具体定义
class SeqList
{
public:
SeqList(); //无参构造函数
SeqList(int a[], int n); //有参构造函数
~SeqList(){} //析构函数为空
int Length(){return length;} //求线性表的长度
int Get(int i); //按位查找,取线性表的第i个元素
friend void MergeList(SeqList &A,SeqList B); //合并顺序表
void PrintList(); //遍历线性表,按序号依次输出各元素
private:
int data[MaxSize]; //存放数据元素的数组
int length; //线性表的长度
};
SeqList::SeqList(int a[],int n)
{
if(n>MaxSize)
cout<<"参数非法";
for(int i=0;i<n;i++)
{
data[i]=a[i];
length=n;
}
}
int SeqList::Get(int i)
{
if (i<1||i>length) throw "查找位置非法";
else return data[i-1];
int x=data[i-1];
}
void SeqList::PrintList()
{
for(int i=0;i<length;i++)
cout<<data[i]<<" ";
cout<<endl;
}
void MergeList(SeqList &A,SeqList B)
{
int a;
for (int i=0;i<B.length;i++)
{
a=-1;
for(int j=0;j<A.length;j++)
{
if (B.data[i]<A.data[j])
{
a=j;
break;
}
}
if(a==-1)
{
A.data[A.length]=
B.data[i];
A.length++;
}
else
{
for(int k=A.length-1;k>=a;k--)
A.data[k+1]=A.data[k];
A.data[a]=
B.data[i];
A.length++;
}
}
}
void main()
{
int a[100];int n=4;
for(int i=0;i<n;i++ )
{
cin>>a[i];
}
int b[100];int m=4;
for(int j=0;j<m;j++ )
{
cin>>b[j];
}
SeqList La(a,4),Lb(b,4);
La.PrintList ();
Lb.PrintList ();
MergeList(La,Lb);
La.PrintList ();
}
四、调试与运行
1、调试时遇到的主要问题及解决
遇到的主要问题:没有把找到的位置用一个变量记下
解决方法:通过请教同学
2、运行结果(输入及输出,可以截取运行窗体的界面)
五、实验心得
写程序的过程中如果卡住了就一定要请教一下同学,不要一错再错,也许一经过同学提醒就一下子懂了,胜过你一直在那儿磨。
还有小的细节也要注意。