实验2:线性表的顺序及链式存储

合集下载

实习02_线性表的链式存储和操作(有序

实习02_线性表的链式存储和操作(有序

实验二线性表的链式存储和操作(有序表的合并)1.目的用链表(LinkList)类型实现书上算法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.12,理解算法的执行步骤和含义;4、算法设计#include <stdio.h>#include <stdlib.h>#include <malloc.h># define TRUE 1# define ERROR 0# define OK 1# define OVERFLOW -2# define FALSE 0void main(){LinkList La,Lb,Lc;CreatList_L(La,4);CreatList_L(Lb,7);MergeList_L(La, Lb, Lc);}5.小结线性表是软件设计中最基础的数据结构。

用顺序方法存储的线性表称为顺序表,当线性表中很少做插入和删除操作,线性表的长度变化不大,易于事先确定其大小时,可以采用顺序表作为存储结构。

用链接方法存储的线性表称为线性链表,当线性表的长度变化较大,难以估计其存储规模,另外对线性表频繁进行插入和删除操作时,则采用链表作为存储结构可能会更好一些。

在实际应用中应该考虑以下因素:(1)应有利于运算的实现;(2)应有利于数据的特性;(3)应有利于软件环境。

数据结构习题及答案与实验指导(线性表)2

数据结构习题及答案与实验指导(线性表)2

第2章线性表线性表是一种最基本、最常用的数据结构,它有两种存储结构——顺序表和链表。

本章主要介绍线性表的定义、表示和基本运算的实现。

重点讨论了线性表的存储结构,以及在顺序、链式两种存储结构上基本运算的实现。

重点提示:●线性表的逻辑结构特征●线性表的顺序存储和链式存储两种存储结构的特点●在两种存储结构下基本操作的实现2-1 重点难点指导2-1-1 相关术语1.线性表线性表是具有相同数据类型的n(n≥0)个数据元素的有限序列,通常记为:(a1,a2,…,a n),其中n为表长,n=0时称为空表。

要点:一种逻辑结构,其数据元素属于相同数据类型,之间的关系是线性关系。

2.顺序表顺序存储的线性表。

要点:按线性表中的元素的逻辑顺序依次存放在地址连续的存储单元里,其存储特点:用物理上的相邻实现逻辑上的相邻。

3.链表用链表存储的线性表。

要点:链表是通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的,对每个结点的地址是否连续没有要求。

4.单链表每个结点除了数据域外还有一个指向其后继的指针域。

要点:通常将每个元素的值和其直接后继的地址作为一个结点,通过每个结点中指向后继结点的指针表示线性表的逻辑结构。

5.头指针要点:头指针是一个指针变量,里面存放的是链表中首结点的地址,并以此来标识一个链表。

如链表H,链表L等,表示链表中第一个结点的地址存放在指针变量H、L中。

通常用头指针来惟一标识一个链表。

6.头结点要点:附加在第一个元素结点之前的一个结点,头指针指向头结点。

当该链表表示一个非空的线性表时,头结点的指针域指向第一个元素结点;为空表时,该指针域为空。

7.头结点的作用要点:其作用有两个,一是使对空表和非空表的处理得到统一;二是在链表的第一个位置上的操作和在其他位置上的操作一致,无需特殊处理。

2-1-2 线性表的顺序存储1.顺序表顺序存储的线性表称为顺序表。

其特点是:用一组地址连续的存储单元来依次存放线性表的数据元素,因此数据元素的逻辑顺序和物理次序一致(这是顺序存储的核心所在)。

线性表ADT的顺序存储与链式存储实验报告

线性表ADT的顺序存储与链式存储实验报告

实验报告题目:完成线性表ADT的顺序存储和链式存储方式的实现一、需求分析1、本演示程序中,线性表的数据元素类型限定为整型2、演示程序以用户和计算机的对话方式执行,即在计算机的终端上显示“提示信息”之后由用户在键盘上键入演示程序规定的运算命令,相应的输出结果显示在后面。

3、程序的执行命令包括:创建、撤销、清空、插入、修改、删除、定位等线性表ADT各项基本操作二、概要设计为实现上述功能,我们给出线性表的抽象数据类型定义,具体的有单向链,双向链,顺序表等,同时对于上述功能的实现还采用有/无头结点两种方式来实现1.线性表的抽象数据类型定义为ADT List{数据对象:D={a i|a i∈ElemSet,i=1,2,…,n,n≥0}数据关系:R1={<a i-1,a i>|ai-1,ai∈D,i=2,…,n}基本操作:InitList(&L)操作结果:构造一个空的线性表LDestroyList(&L)初始条件:线性表L已存在。

操作结果:销毁线性表L。

ClearList(&L)初始条件:线性表L已存在。

操作结果:将L重置为空表。

ListEmpty(L)初始条件:线性表L已存在。

操作结果:若L为空表,则返回TRUE,否则返回FALSE。

ListLength(L)初始条件:线性表L已存在。

操作结果:返回L中的i个数据元素的值。

GetElem(L,i,&e)初始条件:线性表L已存在,1≤i≤ListLength(L)。

操作结果:用e返回L中第i个数据元素的值。

LocateElem(L,e,compare())初始条件:线性表L已存在,compare()是数据元素判定函数操作结果:返回L中第一个与e满足compare()的数据元素的位序。

若这样的数据元素不存在,则返回值为0.PriorElem(L,cur_e,&pre_e)初始条件:线性表已存在操作结果:若cur_e是L的数据元素,且不是第一个,则用pre_e返回它的前驱,否则操作失败,pre_e无定义。

线性表之顺序存储结构

线性表之顺序存储结构

一、实验目的:1. 熟练掌握线性表的基本操作在顺序存储和链式存储上的实现;2. 以线性表的各种操作(建立、插入、删除等)的实现为重点;3. 掌握线性表的动态分配顺序存储结构的定义和基本操作的实现;二、实验内容:1.输入一组整型数据,建立顺序表。

2.实现该线性表的删除。

3、实现该线性表的插入。

4.实现线形表中数据的显示。

5.实现线性表数据的查找和定位5、编写一个主函数,调试上述算法。

三、实验原理、方法和手段1.根据实验内容编程,上机调试、得出正确的运行程序。

2. 编译运行程序,观察运行情况和输出结果。

3. 写出实验报告(包括源程序和运行结果)。

四、实验条件运行Visual stadio 2010的微机一台五、实验步骤(程序清单):// 实验一.cpp : 定义控制台应用程序的入口点。

//#include"stdafx.h"#include<iostream>#include<string.h>#include<stdlib.h>using namespace std;typedef int ElemType;struct List{ElemType *list;int size;int MaxSize;};void InitList(List &L,int n) //初始化线性表{L.MaxSize =n+5;L.list=new ElemType [L.MaxSize];if(L.list==NULL){ cout<<"动态可分配的存储空间已用完,退出运行!"<<endl;exit(1);}L.size=0;}void InputList(List &L) //输入元素{L.size =L.MaxSize-5;for(int i=0;i<L.size;i++){cout<<"请输入第"<<i+1<<"个元素:"<<endl;cin>>L.list[i];}}void FindList(List &L) //查找位置{if(L.size==0){cout<<"线性表为空,查找失败!"<<endl;return;}else{int item;Find:cout<<"请输入要查找的元素:";cin>>item;int i;for(i=0;i<L.size;i++)if(L.list[i]==item){item=L.list[i];cout<<"查找成功!您所查找的数据"<<item<<" 在第"<<i+1<<"个位置"<<endl;break;}if(i>=L.size){cout<<"您所查找的数据不存在!"<<endl;Find2:cout<<"是否继续查找?(y/n):";char c[100];cin>>c;if(strlen(c)==1){if(c[0]=='y')goto Find;else if(c[0]!='y'&&c[0]!='n'){cout<<"您输入的操作无效!";goto Find2;}else return;}else{cout<<"您输入的操作无效!请重新选择:";goto Find2;}}}}void DisplayList(List &L) //按位置查找元素{if(L.size ==0){cout<<"线性表为空,查找失败!"<<endl;return;}else{int pos;Display:cout<<"请输入您要查找元素的位置:";cin>>pos;if(pos<1||pos>L.size){cout<<"您输入的位置无效!"<<endl;Display2:cout<<"是否继续按位置查找?(y/n):";char c[100];cin>>c;if(strlen(c)==1){if(c[0]=='y')goto Display;else if(c[0]!='y'&&c[0]!='n'){cout<<"您输入的操作不合法!";goto Display2;}else return;}else{cout<<"您输入的操作不合法!";goto Display2;}}elsecout<<"您要查找的第 "<<pos<<" 个数据为 "<<L.list[pos-1]<<endl;}}void ClearList(List &L) //清空线性表{if(L.list!=NULL){ delete [ ]L.list;L.list=NULL;}L.MaxSize=0;L.size=0;cout<<"清空成功!"<<endl;}void InsertList(List &L) //插入一个元素{if(L.size==0){cout<<"线性表为空,插入失败!"<<endl;return;}else{Insert:cout<<"请选择要插入的方式:按有序插入请输入0 按位置插入请输入位置值:";int pos;cin>>pos;cout<<"请输入要插入的元素:";ElemType item;cin>>item;if(pos<-1||pos>L.size+1){cout<<"位置值无效!"<<endl;Insert2:cout<<"是否继续插入?(y/n):";char c[100];cin>>c;if(strlen(c)==1){if(c[0]=='y')goto Insert;else if(c[0]!='y'&&c[0]!='n'){cout<<"您输入的操作无效!";goto Insert2;}else return;}else{cout<<"您输入的操作无效!";goto Insert2;}}int i;if(pos==0){ for(i=0;i<L.size;i++)if(item<L.list[i]) break;pos=i+1;}else if(pos==-1) pos=L.size+1;if(L.size==L.MaxSize){int k=sizeof(ElemType);L.list=(ElemType*)realloc(L.list,2*L.MaxSize*k);if(L.list==NULL){cout<<"动态可分配的存储空间已用完,退出运行!"<<endl;exit(1);}L.MaxSize=2*L.MaxSize;}for(i=L.size-1;i>=pos-1;i--)L.list[i+1]=L.list[i];L.list[pos-1]=item;L.size++;cout<<"插入成功!"<<endl;}}void DisplayAllList(List &L) //显示线性表数据{if(L.size ==0)cout<<"线性表不存在,请先创建!"<<endl;else{cout<<"Size="<<L.size<<" MaxSize="<<L.MaxSize<<endl;for(int i=0;i<L.size;i++)cout<<L.list[i]<<" ";cout<<endl;}}void DeleteList(List &L) //删除一个元素{if(L.size==0){cout<<"线性表为空,删除无效!"<<endl;return;}Delete:cout<<"请选择要删除的方式:删除指定元素请输入0 按位置删除请输入位置值:";int pos;cin>>pos;ElemType item;if(pos<0||pos>L.size){cout<<"位置值无效!"<<endl;Delete2:cout<<"是否继续删除?(y/n):";char c[100];cin>>c;if(strlen(c)==1){if(c[0]=='y')goto Delete;else if(c[0]!='y'&&c[0]!='n'){cout<<"您输入的操作不合法!";goto Delete2;}return;}else{cout<<"您输入的操作不合法!";goto Delete2;}}int i;if (pos==0){cout<<"按查找删除,请输入要删除的元素:";cin>>item;for(i=0;i<L.size;i++ )if(item==L.list[i]) break;if(i==L.size){cout<<"按查找删除,没有找到您要删除的元素! "<<endl; Delete3:cout<<"是否继续按查找删除?(y/n):";char c[100];cin>>c;if(strlen(c)==1){if(c[0]=='y')goto Delete;else if(c[0]!='y'&&c[0]!='n'){cout<<"您输入的操作不合法!";goto Delete3;}else return;}else{cout<<"您输入的操作不合法!";goto Delete3;}}pos=i+1;}else if(pos==-1)pos=L.size;item=L.list[pos-1];cout<<"您要删除的元素 "<<L.list[pos-1]<<"已删除成功!"<<endl;for(i=pos;i<L.size ;i++)L.list[i-1]=L.list [i];L.size--;if(float(L.size)/L.MaxSize<0.4&&L.MaxSize>10){int k=sizeof(ElemType);L.list=(ElemType*)realloc(L.list,L.MaxSize*k/2);L.MaxSize=L.MaxSize/2;}}void menu(){List t;InitList(t,0);menu:cout<<"欢迎进入线性表管理系统:"<<endl;cout<<" 1. 创建一个线性表"<<endl;cout<<" 2. 查找元素位置"<<endl;cout<<" 3. 按位置查找元素"<<endl;cout<<" 4. 插入一个元素"<<endl;cout<<" 5. 删除一个元素"<<endl;cout<<" 6. 清空该线性表"<<endl;cout<<" 7. 显示该线性表"<<endl;cout<<" 0. 退出系统"<<endl;menu2:cout<<"请输入你想要执行的操作:";char n[100];cin>>n;if(strlen(n)==1){if(n[0]<'0' || n[0]>'7'){cout<<"您输入的操作不合法,请重新选择!"<<endl;goto menu2;}}else{cout<<"您输入的操作不合法,请重新选择!"<<endl;goto menu2;}switch(n[0]){case'1':cout<<"请输入您所创建线性表元素的个数:";int m;cin>>m;InitList(t,m);InputList(t);cout<<endl;goto menu;case'2':FindList(t);cout<<endl;goto menu;case'3':DisplayList(t);cout<<endl;goto menu;case'4':InsertList(t);cout<<endl;goto menu;case'5':DeleteList(t);cout<<endl;goto menu;case'6':ClearList(t);cout<<endl;goto menu;case'7':DisplayAllList(t);cout<<endl;goto menu;case'0':break;default:cout<<"您输入的操作有误,请重新输入:";goto menu2;}}int _tmain(int argc, _TCHAR* argv[]){menu();}六、调试及运行:1.在未创建一个线性表前,选择其它操作会提示“线性表为空,操作打败”的提示,如图2.选择操作【1】.创建一个线性表,并输入11,22,33,44.如图3.选择操作【7】,显示线性表,便于查找元素位置。

数据结构实验二链表的链式存储结构

数据结构实验二链表的链式存储结构

贵州大学实验报告#include<iostream>using namespace std;typedef int Elemtype;struct LNode{Elemtype data;LNode *next;};void BuildLNode(LNode *&hl)/*建立带头结点单链表*/{hl=new LNode;hl->data=NULL;hl->next=NULL;}void ClearList(LNode *&hl)/*清空线性表*/ {LNode *p=hl;LNode *q;while(p!=NULL){q=p->next;delete p;p=q;}hl=NULL;}bool InsertList(LNode *&hl,Elemtype item,int pos)/*在线性表中插入一个元素*/{if(pos<-1){cout<<"位置无效"<<endl;return false;}if(pos==-1||pos==0)pos=1;LNode *p;int i=1;p=hl;while(p!=NULL&&i<pos){p=p->next;i++;}if(p==NULL){cout<<"位置无效"<<endl;return false;}LNode *q;q=new LNode;q->data=item;q->next=p->next;p->next=q;return true;}bool DeleteList(LNode *&hl,int pos)/*删除线性表中的一个元素*/{if(pos<-1){cout<<"位置无效"<<endl;return false;}if(pos==-1||pos==0)pos=1;LNode *p=hl,*q;int i=1;while(p->next!=NULL&&i<pos){p=p->next;i++;}if(p->next==NULL){cout<<"位置无效或该链表为空"<<endl;return false;}q=p->next;p->next=q->next;delete q;return true;}bool GetList(LNode *p,Elemtype &item,int pos)/*线性表中数据的定位*/{if(pos<-1){cout<<"位置无效"<<endl;return false;}if(pos==-1||pos==0)pos=1;int i=0;while(p!=NULL&&i<pos){p=p->next;i++;}if(p==NULL){cout<<"位置无效"<<endl;return false;}item=p->data;return true;}int FindList(LNode *p,Elemtype item)/*线性表中数据的查找*/{int i=0;while(p!=NULL){if(p->data==item)break;i++;p=p->next;}if(p==NULL){cout<<"找不到该元素"<<endl;return 0;}return i;}void DisplayList(LNode *hl)/*显示线性表中所有数据*/{if(hl==NULL){cout<<"该表为空"<<endl;}LNode *p=hl->next;while(p!=NULL){cout<<p->data<<" ";p=p->next;}} void main(){LNode *head;BuildLNode(head);int pos;Elemtype data;for(int i=0;i<10;i++)InsertList(head,2*i+1,i+1);DisplayList(head);cout<<endl;cout<<"一、插入操作"<<endl;cout<<"位置:";cin>>pos;cout<<"数据:";cin>>data;if(InsertList(head,data,pos))cout<<"插入成功"<<endl;elsecout<<"插入失败"<<endl;DisplayList(head);cout<<endl<<endl;cout<<"二、删除操作"<<endl;cout<<"位置:";cin>>pos;if(DeleteList(head,pos))cout<<"删除成功"<<endl;elsecout<<"删除失败"<<endl;DisplayList(head);cout<<endl<<endl;cout<<"三、定位操作:"<<endl;cout<<"位置:";cin>>pos;if(GetList(head,data,pos))cout<<"该位置数据为"<<data<<endl;elsecout<<"定位失败"<<endl;cout<<"四、查找操作:"<<endl;cout<<"数据:";cin>>data;if(FindList(head,data))cout<<"线性表中第一个等于该数据的位置为"<<FindList(head,data)<<endl;elsecout<<"查找失败"<<endl;ClearList(head);}。

实验二 线性表的链式存储

实验二  线性表的链式存储

实验二线性表的链式存储
一、实验目的
1.掌握线性表的链式存储结构。

2.能熟练地利用链式存储结构实现线性表的基本操作。

3.能熟练地掌握链式存储结构中算法的实现。

二、实验内容
1.分别用头插法和尾插法建立带头结点的单链表。

2.实现单链表上的插入、删除、修改、查找、计数、输出等基本操作。

3.解决约瑟夫问题:假设有n个人按1、2、3、…、n的顺序围成一圈,现在,从第s个人开始按1、2、3、…、m的顺序报数,数到m的人出圈,接着从出圈的下一个人开始重复此过程,直到所有人出圈为止。

试用循环链表解决这个问题。

三、算法描述
1.第1题、第2题的算法提示
先定义单链表的数据类型,然后将头插法和尾插法、插入、删除、修改、查找、计数、输出等基本操作都定义成单独的子函数形式,最后在主函数中调用,并将每一种操作前后的结果输出,以查看每一种操作的效果。

2.第3题的算法提示
首先将n个人的信息建立成一个单循环链表,链表中的每个结点信息就是每个人的编号(1~n)。

然后利用循环找到出圈人位置的结
点,输出该结点的信息,再在链表中删除该结点,接着从删除的结点的后面重复此步骤,直到链表中剩下一个结点时停止循环,再把链表中的最后一个结点删除。

实验报告的要求与实验一相同。

《软件技术基础》实验指导

《软件技术基础》实验指导

说明每个实验题目含有一个main函数和一些函数, 与实验题目相关的基本运算的函数定义和main函数定义的代码在附录以及对应的文件夹中给出, 供上机实验参考使用。

对于每个题目, 只需要根据题目要求设计算法, 补充函数定义, 然后对程序进行编译、调试。

实验一线性表一、实验目的1.熟悉线性表的顺序和链式存储结构2.掌握线性表的基本运算3.能够利用线性表的基本运算完成线性表应用的运算二、实验内容设有一个线性表E={e1, e2, …, en-1, en}, 设计一个算法, 将线性表逆置, 即使元素排列次序颠倒过来, 成为逆线性表E’={ en , en-1 , …, e2 , e1 }, 要求逆线性表占用原线性表空间, 并且用顺序表和单链表两种方法表示, 分别用两个程序来完成。

(文件夹: 顺序表逆置、单链表逆置)已知由不具有头结点的单链表表示的线性表中, 含有三类字符的数据元素(字母、数字和其他字符), 试编写算法构造三个以循环链表表示的线性表, 使每个表中只含有同一类的字符, 且利用原表中的结点空间, 头结点可另辟空间。

(文件夹: 分解单链表)实验二栈和队列一、实验目的1.熟悉栈和队列的顺序和链式存储结构2.掌握栈和队列的基本运算3.能够利用栈和队列的基本运算完成栈和队列应用的运算二、实验内容1.设单链表中存放有n个字符, 试编写算法, 判断该字符串是否有中心对称的关系, 例如xyzzyx是中心对称的字符串。

(提示: 将单链表中的一半字符先依次进栈, 然后依次出栈与单链表中的另一半字符进行比较。

)(文件夹: 判字符串中心对称)假设以数组sequ[m]存放循环队列的元素, 同时设变量rear和quelen 分别指示循环队列中队空的条件:sq->quelen==0;队满的条件:sq->quelen==m。

(文件夹:循环队列)实验三串一、实验目的1.熟悉串的顺序存储结构2.掌握串的基本运算及应用二、实验内容1. 串采用顺序存储结构, 编写朴素模式匹配算法, 查找在串中是否存在给定的子串。

数据结构实验报告-线性表的顺序存储

数据结构实验报告-线性表的顺序存储
学 号
姓 名
专业班级
实验地点
指导教师
实验时间
一、实验目的及要求
本次实验目的是通过上机练习,熟悉和掌握课堂所讲授的基本知识点。要求上机以前要认真复习课堂教学内容。完成教师带领实验,完成线性表的顺序存储实验。
二、实验设备(环境)及要求
计算机;学生不许把食物带到机房吃;不许上网做与实验无关的内容;不许同学之间聊天;保持实验室安静卫生。下课把键盘,座椅放回原处。
Integer length;/*当前线性表长度,线性表中现有元素个数*/
Integer listsize;/*当前分配的存储量以下定义线性表的操作*/
Integer InitList(Class_List *SqList)
/*构造一个空的线性表*/
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
typedef int Integer;
typedef char *String;
typedef struct
{
Integer number;
String name[10];
Integer age;
String interest[50];
完成一个有多于3个学生的线性表。并且显示学生信息。删除其中一个学生。然后再打印显示。
Source.cpp
#include"header.h"
void main()
{
Class_List xinji2013;
InitList(&xinji2013);
Student st;
Integer i,n=2,w,q,e;
三、实验内容与步骤

项目二-线性表 顺序存储课件

项目二-线性表 顺序存储课件
项目二 线性表
项目二 线性表
⭘ 任务一:线性表的定义和基本运算 ⭘ 任务二:线性表的顺序存储结构 ⭘ 任务三:线性表的链式存储结构
⚫ 线性表的逻辑结构、存储结构,及它们之间的相互关系; ⚫ 定义与之相适应的运算; ⚫ 设计相应的算法; ⚫ 分析算法的效率。
任务一 线性表的定义和基本操作
一、线性表
while(i<=LA.len){InsertList(LC,k+1,GetElem(LA,i)); k++;i++;}
while(j<=LB.len){InsertList(LC,k+1,GetElem(LB,j)); k++;j++;}
任务一 线性表的定义和基本操作
⭘ 算法分析:该算法中包含了三个WHILE语句,其中,第一 个处理了某一张表的全部元素和另一张表的部分元素;后两 个WHILE循环只可能有一个执行,用来完成将未归并到LC 中的余下部分元素插入到LC中,“插入”是估量归并算法时 间复杂度的基本操作,其语句频度为: ListLength(LA)+ListLength(LB)
任务一 线性表的定义和基本操作
⭘ 抽象数据类型线性表的定义:
{ 引用型操作} ListEmpty (L) ListLength(L) PriorElem(L,e) NextElem(L,e) GetElem(L,i) Locate(L,e)
⭘ ListEmpty (L)
初始条件:线性表L已存在。 操作结果:若L为空表,则返回TRUE,否则
⭘ 抽象数据类型线性表的定义:
{ 加工型操作} ClearList (L) InsertList (L,i,e) DeleteList (L,i,e)

线性表实验报告

线性表实验报告

线性表实验报告一、实验目的本次实验的主要目的是深入理解线性表的基本概念和操作,通过实际编程实现线性表的存储和基本运算,掌握线性表在数据结构中的应用,提高对数据结构的理解和编程能力。

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

三、实验原理线性表是一种最基本、最简单的数据结构,它是由 n(n≥0)个数据元素组成的有限序列。

在这个序列中,每个数据元素的位置是按照其逻辑顺序排列的。

线性表有两种存储结构:顺序存储结构和链式存储结构。

顺序存储结构是用一组地址连续的存储单元依次存储线性表中的数据元素,使得逻辑上相邻的两个元素在物理位置上也相邻。

其优点是可以随机访问表中的任意元素,时间复杂度为 O(1);缺点是插入和删除操作需要移动大量元素,时间复杂度为 O(n)。

链式存储结构是通过指针将各个数据元素链接起来,每个数据元素由数据域和指针域组成。

其优点是插入和删除操作不需要移动大量元素,时间复杂度为 O(1);缺点是不能随机访问表中的元素,需要从头指针开始遍历,时间复杂度为 O(n)。

四、实验内容本次实验实现了顺序表和链表的基本操作,包括创建、插入、删除、查找、遍历等。

1、顺序表的实现定义顺序表的结构体,包括数据存储数组和表的长度。

实现顺序表的初始化函数,将表的长度初始化为 0。

实现顺序表的插入函数,在指定位置插入元素,如果插入位置非法或表已满,则返回错误。

实现顺序表的删除函数,删除指定位置的元素,如果删除位置非法,则返回错误。

实现顺序表的查找函数,查找指定元素,如果找到则返回元素的位置,否则返回-1。

实现顺序表的遍历函数,输出表中的所有元素。

2、链表的实现定义链表的结构体,包括数据域和指向下一个节点的指针域。

实现链表的创建函数,创建一个空链表。

实现链表的插入函数,在指定位置插入元素,如果插入位置非法,则返回错误。

实现链表的删除函数,删除指定位置的元素,如果删除位置非法,则返回错误。

数据结构实验报告二线性表的顺序存储

数据结构实验报告二线性表的顺序存储

实验报告二线性表的顺序存储班级: 2010XXX 姓名: HoogLe 学号: 2010XXXX 专业: XXXX*****************一、实验目的:(1)掌握顺序表的基本操作的实现方法。

(2)应用顺序表的基本算法实现集合A=AUB算法。

(3)应用顺序表的基本算法实现两有序顺序表的归并算法。

二、实验内容:1、线性表顺序存储结构的基本操作算法实现(要求采用类模板实现)[实现提示] (同时可参见教材p5822-p60页算法、ppt)函数、类名称等可自定义,部分变量请加上学号后3位。

库函数载和常量定义:(代码)#include<iostream>using namespace std;const int MaxSize=100;(1)顺序表存储结构的定义(类的声明):(代码)template <class datatype> //定义模板类SeqListclass SeqList{public:SeqList( ); //无参构造函数SeqList(datatype a[ ], int n); //有参构造函数~SeqList(){}; //析构函数为空int Length(); //求线性表的长度datatype Get(int i); //按位查找,取线性表的第i个元素int Locate(datatype item); //查找元素itemvoid Insert(int i, datatype item); //在第i个位置插入元素itemdatatype Delete(int i); //删除线性表的第i个元素void display(); //遍历线性表,按序号依次输出各元素private:datatype data[MaxSize]; //存放数据元素的数组int length; //线性表的长度};(2)初始化顺序表算法实现(不带参数的构造函数)/**输入:无*前置条件:顺序表不存在*功能:构建一个顺序表*输出:无*后置条件:表长为0*/实现代码:template <class datatype>SeqList<datatype>:: SeqList( ){length=0;}(3)顺序表的建立算法(带参数的构造函数)/**输入:顺序表信息的数组形式a[],顺序表长度n*前置条件:顺序表不存在*功能:将数组a[]中元素建为长度为n的顺序表*输出:无*后置条件:构建一个顺序表*/实现代码:template <class datatype>SeqList<datatype>:: SeqList(datatype a[], int n) {if (n>MaxSize){cout<<"数组元素个数不合法"<<endl;}for (int i=0; i<n; i++)data[i]=a[i];length=n;}(4)在顺序表的第i个位置前插入元素e算法/**输入:插入元素e,插入位置i*前置条件:顺序表存在,i要合法*功能:将元素e插入到顺序表中位置i处*输出:无*后置条件:顺序表插入新元素,表长加1*/实现代码:template <class datatype>void SeqList<datatype>::Insert(int i, datatype item) {int j;if (length>=MaxSize){cout<<"溢出"<<endl;}if (i<1 || i>length+1){cout<<"i不合法!"<<endl;}for (j=length; j>=i; j--)data[j]=data[j-1];data[i-1]=item;length++;}(5)删除线性表中第i个元素算法/**输入:要删除元素位置i*前置条件:顺序表存在,i要合法*功能:删除顺序表中位置为i的元素*输出:无*后置条件:顺序表册除了一个元素,表长减1*/实现代码:template <class datatype>datatype SeqList<datatype>::Delete(int i){int item,j;if (length==0){cout<<"表为空,无法删除元素!"<<endl;}if (i<1 || i>length){cout<<"i不合法!"<<endl;}item=data[i-1];//获得要删除的元素值for (j=i; j<length; j++)data[j-1]=data[j]; //注意数组下标从0记length--;return item;}(6)遍历线性表元素算法/**输入:无*前置条件:顺序表存在*功能:顺序表遍历*输出:输出所有元素*后置条件:无*/实现代码:template<class datatype>void SeqList<datatype>::display(){if(length==0){cout<<"表为空,无法输出!"<<endl;}for(int i=0;i<length;i++){cout<<data[i]<<" ";}}(7)获得线性表长度算法/**输入:无*前置条件:顺序表存在*功能:输出顺序表长度*输出:顺序表长度*后置条件:无*/实现代码:template <class datatype>int SeqList<datatype>::Length(){return Length;}(8)在顺序线性表中查找e值,返回该元素的位序算法/**输入:查询元素值e*前置条件:顺序表存在*功能:按值查找值的元素并输出位置*输出:查询元素的位置*后置条件:无*/实现代码:template <class datatype>int SeqList<datatype>::Locate(datatype item){for (int i=0; i<length; i++)if (data[i]==item)return i+1 ;//下标为i的元素等于item,返回其序号i+1return 0; //查找失败}(9)获得顺序线性表第i个元素的值/**输入:查询元素位置i*前置条件:顺序表存在,i要合法*功能:按位查找位置为i的元素并输出值*输出:查询元素的值*后置条件:无*/实现代码:template <class datatype>datatype SeqList<datatype>::Get(int i){if (i<0||i>length){cout<<"i不合法!"<<endl;}else return data[i-1];}(10)判表空算法/**输入:无*前置条件:无*功能:判表是否为空*输出:为空返回1,不为空返回0*后置条件:无*/实现代码:template <class datatype>bool SeqList<datatype>::Empty(){if (length==0){return 1;}else{return 0;}}(11)求直接前驱结点算法/**输入:要查找的元素e,待存放前驱结点值e1*前置条件:无*功能:查找该元素的所在位置,获得其前驱所在位置。

线性表的实验报告

线性表的实验报告

线性表的实验报告线性表的实验报告概述:线性表是一种常见的数据结构,它是由一组具有相同数据类型的元素组成的序列。

本次实验旨在通过实际操作线性表,掌握线性表的基本操作以及了解其应用场景。

实验目的:1. 理解线性表的概念和基本操作;2. 掌握线性表的顺序存储结构和链式存储结构;3. 熟悉线性表的常见应用场景。

实验材料:1. 计算机;2. 编程软件(如C、C++、Java等);3. 实验教材或参考资料。

实验步骤:一、线性表的顺序存储结构实验1. 创建一个空的线性表;2. 向线性表中插入若干元素;3. 删除线性表中的某个元素;4. 根据索引查找线性表中的元素;5. 遍历线性表,输出所有元素。

二、线性表的链式存储结构实验1. 创建一个空的链表;2. 向链表中插入若干节点;3. 删除链表中的某个节点;4. 根据节点值查找链表中的节点;5. 遍历链表,输出所有节点。

实验结果:1. 顺序存储结构实验结果:- 成功创建空的线性表;- 成功插入若干元素;- 成功删除某个元素;- 成功根据索引查找元素;- 成功遍历线性表,输出所有元素。

2. 链式存储结构实验结果:- 成功创建空的链表;- 成功插入若干节点;- 成功删除某个节点;- 成功根据节点值查找节点;- 成功遍历链表,输出所有节点。

实验分析:1. 顺序存储结构适用于元素个数固定或变化不大的情况,插入和删除操作需要移动大量元素,效率较低;2. 链式存储结构适用于元素个数不固定的情况,插入和删除操作只需修改指针,效率较高;3. 线性表的应用场景包括但不限于:图书馆图书管理系统中的图书列表、学生信息管理系统中的学生列表等。

实验总结:通过本次实验,我深入了解了线性表的概念、基本操作以及两种常见存储结构。

顺序存储结构适用于元素个数固定的情况,而链式存储结构适用于元素个数不固定的情况。

线性表在实际应用中有着广泛的应用场景,如图书馆管理系统、学生信息管理系统等。

在以后的学习和工作中,我将灵活运用线性表,为解决实际问题提供便利。

国家开放大学《数据结构》课程实验报告(实验2——线性表)参考答案

国家开放大学《数据结构》课程实验报告(实验2——线性表)参考答案
printf("\n");
//在链表中删除最高分和最低分结点
for(q=head,p=head->next;p!=NULL;q=p,p=p->next)
{
if(p==pmin) { q->next=p->next; p=q; } //删除最低分结点
};
typedef struct pw PW;
//定义链表结点
struct node
{
PW data;
struct node * next;
};
typedef struct node NODE;
NODE *create(int n); //建立单链表
void input(NODE *s,int i); //输入第i个评委信息
(5)遍历链表,累加求和,计算总分及平均分,并输出相关信息。
完整程序
//实验1.1线性表的链接存储结构
#include
#include
#include
#define PWRS 5 //定义评委人数
//定义评委信息
struct pw
{
char name[8]; //姓名
short age; //年龄
float score; //评分
NODE *create(int n)
{
NODE *head,*p,*q;
inti;
p=(NODE*)malloc(sizeof(NODE));
head=p; q=p; p->next=NULL;
for(i=1; i<=n; i++)
{
p=(NODE*)malloc(sizeof(NODE));

数据结构线性表实验报告五篇

数据结构线性表实验报告五篇

数据结构线性表实验报告五篇第一篇:数据结构线性表实验报告实验报告课程名:数据结构实验名:线性表及其操作姓名:班级:学号:撰写时间:2014.09.24一实验目的与要求1.掌握线性表的实现2.掌握线性表的基本操作的实现二实验内容• 分别完成线性表的顺序表示及链式表示• 在两种表示上, 分别实现一些线性表的操作, 至少应该包括–在第i个位置插入一个元素–删除第i个元素–返回线性表长–返回第i个元素的值三实验结果与分析#include #include //---------线性表链式表示-----------struct V//声明一个结构体类型struct V { int value;struct V * next;//定义结构体变量};void PrintLink(struct V*p)//定义一个结构体指针{ while(p!=NULL)//只要指针指向的变量不为NULL;就会一直循环链表指向下一个结构体{printf(“%d, ”,(*p).value);p=(*p).next;//指针指向下一个结构体} printf(“n”);} void Link(){struct V*head;head=(struct V*)malloc(sizeof(struct V));//开辟一个长度为size的内存(*head).value=-100;//表头为-100(*head).next=NULL;printf(“------------线性表链式表示------------n”);int i,n=10;struct V*p=head;printf(“10个数据:n”);for(i=0;i(*p).next=(struct V*)malloc(sizeof(struct V));p=(*p).next;(*p).value=2*i;(*p).next=NULL;} PrintLink(head);//调用PrintLink函数printf(“删除第四个数据:n”);int k=4;p=head;for(i=1;ip=(*p).next;} struct V*temp=(*p).next;//k表示插入和删除的位置(*p).next=(*temp).next;free(temp);PrintLink(head);printf(“插入第十个数据:n”);k=10;p=head;for(i=1;ip=(*p).next;} temp=(*p).next;(*p).next=(struct V*)malloc(sizeof(struct V));(*(*p).next).value=-99;(*(*p).next).next=temp;PrintLink(head);}//---------线性表顺序表示-----------void seq1(){ int i,n=10,k=4;int a[10];//---------输出数组元素------------printf(“-------------线性表顺序表示---------n”);for(i=0;ia[i]=i;} printf(“数组元素为:n”);for(i=0;iprintf(“%3d”,a[i]);} printf(“n”);//--------插入一个数组元素---------int m=n+1,j=12;//插入元素12 int b[20];for(i=0;i if(i{b[i]=a[i];}else if(i==k){b[i]=j;}else{b[i]=a[i-1];} } printf(“输出插入一个元素的数组:n”);for(i=0;i{if(i{c[i]=a[i];}else{c[i]=a[i+1];} } printf(“输出删除一个元素的数组:n”);for(i=0;i printf(“数组元素为:n”);for(i=1;i<=a[0];i++){a[i]=i;} for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);//-----在k 位置插入一个元素------------for(i=a[0];i>=k;i--){a[i+1]=a[i];} a[k]=-100;++a[0];for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);//-------在k---------------for(i=0;i>k;i++){a[i]=a[i+1];} a[k]=-1;a[0]=n;--a[0];for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);} int main(int argc,char *argv[]){ seq1();seq2();Link();return 0;} 图1:实验结果截图实验分析:已在程序中按规定格式标注。

数据结构与算法(二)-线性表之单链表顺序存储和链式存储

数据结构与算法(二)-线性表之单链表顺序存储和链式存储

数据结构与算法(⼆)-线性表之单链表顺序存储和链式存储前⾔:前⾯已经介绍过数据结构和算法的基本概念,下⾯就开始总结⼀下数据结构中逻辑结构下的分⽀——线性结构线性表⼀、简介1、线性表定义 线性表(List):由零个或多个数据元素组成的有限序列; 这⾥有需要注意的⼏个关键地⽅: 1.⾸先他是⼀个序列,也就是说元素之间是有个先来后到的。

2.若元素存在多个,则第⼀个元素⽆前驱,⽽最后⼀个元素⽆后继,其他元素都有且只有⼀个前驱和后继。

3.线性表强调是有限的,事实上⽆论计算机发展到多钱⼤,他所处理的元素都是有限的。

使⽤数学语⾔来表达的话: a1,…,ai-1,ai,ai+1,…an 表中ai-1领先于ai,ai领先于ai+1,称ai-1是ai的直接前驱元素,ai+1是ai的直接后继元素。

所以线性表元素的各数n(n>0)定义为线性表的长度,当n=0时,称为空表。

2、抽象数据类型 数据类型:是指⼀组性质相同的值得集合及定义在此集合上的⼀些操作的总称。

例如很多编程语⾔的整型,浮点型,字符型这些指的就是数据类型。

不同的数据结构满⾜不同的计算需求,所以出现了各种各样样的数据类型,它可以分为两类: 1.原⼦类型:不可以再分解的基本数据类型,例如整型、浮点型等; 2.结构类型:有若⼲个类型组合⽽成,是可以再分解的,例如整型数组是由若⼲整型数据组成的; 抽象:是指抽取处事务具有的普遍性的本质。

他要求抽出问题的特征⽽忽略⾮本质的细节,是对具体事务的⼀个概括。

抽象是⼀种思考问题的⽅式,他隐藏了复杂的细节。

⽽我们对数据类型进⾏抽象,就有了抽象数据类型,抽象数据类型是指⼀个数据模型及定义在该模型上的⼀组操作。

抽象数据类型的定义仅取决于它的⼀组逻辑特性,⽽与其在计算机内部如何表⽰和实现⽆关。

抽象数据类型表⽰:ADT 抽象数据类型 Data 数据结构 Operation 具体数据操作(例,增删改查) ⽐如1+1=2这样⼀个操作,在不同CPU的处理上可能不⼀样,但由于其定义的数学特性相同,所以在计算机编程者看来,它们都是相同的。

线性表实验报告

线性表实验报告

线性表实验报告导言:线性表是数据结构中最基本也是最常用的一种结构之一。

它以一种线性的方式存储和组织数据,简单而高效。

本实验旨在通过对线性表的实践操作,加深对线性表概念的理解,并掌握其基本操作。

实验目的:1. 了解线性表的基本概念和特点;2. 掌握线性表的基本操作,如插入、删除、查找等;3. 熟悉线性表的顺序存储和链式存储结构;4. 学会通过编程实现线性表的基本操作。

实验内容:本次实验分为两个部分,分别是线性表的顺序存储和链式存储结构。

一、顺序存储结构的线性表操作1. 初始化线性表:定义一个固定大小的数组,用于存储线性表中的元素;2. 插入元素:从表尾开始,逐个向前移动元素,为新元素腾出位置;3. 删除元素:从指定位置开始,逐个向后移动元素,覆盖待删除元素;4. 查找元素:按照线性表的顺序依次比较元素,直到找到目标元素或遍历结束;5. 获取表长度:通过记录插入和删除操作的次数,得到线性表的长度。

二、链式存储结构的线性表操作1. 定义结点:创建一个结点类,包含数据域和指向下一结点的指针;2. 初始化链表:定义一个头指针,将其初始化为 NULL,表示链表为空;3. 插入元素:找到插入位置的前一个结点,将新结点插入到其后面;4. 删除元素:找到待删除结点的前一个结点,将其指针指向待删除结点的下一个结点;5. 查找元素:从链表头部开始遍历,逐个比较结点中的数据,直到找到目标元素或遍历结束;6. 获取表长度:通过遍历链表中的结点,计数来获取表长度。

实验过程:1. 根据实验目的,在 C/C++ 环境下创建一个项目,并命名为"LinearList";2. 依次完成顺序存储结构和链式存储结构的线性表操作函数的编写;3. 调用这些函数,对线性表进行初始化、插入、删除、查找等操作;4. 验证线性表操作的正确性,并检查函数是否能正确处理各种边界情况;5. 根据实验内容,编写实验报告,记录实验过程和结果。

数据结构线性表实验报告

数据结构线性表实验报告

数据结构线性表实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中线性表的基本概念、存储结构和操作算法,并通过实际编程实现来提高对线性表的应用能力和编程技能。

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

三、实验内容(一)线性表的顺序存储结构顺序表是用一组地址连续的存储单元依次存储线性表的数据元素。

其特点是逻辑上相邻的元素在物理位置上也相邻,便于随机存取,但插入和删除操作需要移动大量元素,效率较低。

(二)线性表的链式存储结构链表是通过指针将一组零散的存储单元链接成一个线性序列。

常见的链表有单链表、双向链表和循环链表。

链表的插入和删除操作只需修改指针,无需移动元素,但随机存取效率较低。

(三)线性表的基本操作实现1、初始化线性表2、销毁线性表3、清空线性表4、判断线性表是否为空5、获取线性表的长度6、获取指定位置的元素7、查找指定元素在线性表中的位置8、在线性表指定位置插入元素9、删除线性表指定位置的元素四、实验步骤(一)顺序表的实现1、定义顺序表的结构体,包括数据存储数组和表的长度。

2、实现顺序表的初始化函数,分配初始存储空间并设置表长度为0。

3、销毁顺序表函数,释放存储空间。

4、清空顺序表函数,将表长度置为 0。

5、判断顺序表是否为空,根据表长度判断。

6、获取顺序表长度,直接返回表长度。

7、获取指定位置元素,检查位置合法性后返回对应元素。

8、查找指定元素位置,遍历表进行比较。

9、插入元素函数,检查插入位置合法性,若合法则移动后续元素,插入新元素并更新表长度。

10、删除元素函数,检查删除位置合法性,若合法则移动后续元素,更新表长度。

(二)链表的实现1、定义链表节点结构体,包含数据域和指针域。

2、实现链表的初始化函数,创建头节点。

3、销毁链表函数,遍历链表释放节点内存。

4、清空链表函数,遍历链表删除节点但保留头节点。

5、判断链表是否为空,检查头节点的指针域是否为空。

数据结构实验二 线性表

数据结构实验二 线性表

数据结构实验二线性表数据结构实验二线性表1. 实验目的1.1 理解线性表的概念和特性1.2 学习线性表的顺序存储结构和链式存储结构1.3 掌握线性表的基本操作:初始化、插入、删除、查找、修改、遍历等1.4 熟悉线性表的应用场景2. 实验内容2.1 线性表的顺序存储结构实现2.1.1 定义线性表结构体2.1.2 初始化线性表2.1.3 插入元素2.1.4 删除元素2.1.5 查找元素2.1.6 修改元素2.1.7 遍历线性表2.2 线性表的链式存储结构实现2.2.1 定义链表节点结构体2.2.2 初始化链表2.2.3 插入元素2.2.4 删除元素2.2.5 查找元素2.2.6 修改元素2.2.7 遍历链表3. 实验步骤3.1 实现顺序存储结构的线性表3.2 实现链式存储结构的线性表3.3 编写测试程序,验证线性表的各种操作是否正确3.4 进行性能测试,比较两种存储结构的效率差异4. 实验结果与分析4.1 执行测试程序,检查线性表的操作结果是否正确4.2 对比顺序存储结构和链式存储结构的性能差异4.3 分析线性表的应用场景,总结线性表的优缺点5. 实验总结5.1 总结线性表的定义和基本操作5.2 回顾实验中遇到的问题和解决方法5.3 提出对线性表实现的改进方向和思考附件:请参考附件中的源代码和实验报告模板。

法律名词及注释:1. 版权:指对某一作品享有的法律上的权利,包括复制权、发行权、改编权等。

2. 法律责任:指违反法律或合同规定所承担的责任。

3. 保密义务:指个人或组织根据法律、法规、合同等规定需要承担的保密责任。

4.知识产权:指人们在社会实践中所创造的智力劳动成果所享有的权利,包括专利权、著作权、商标权等。

实验二 链式存储线性表

实验二  链式存储线性表

实验二 链式存储线性表的基本操作一、 实验目的1. 掌握用Turbo C2.0上机调试线性表的基本方法。

2. 掌握线性表的基本操作,插入、删除、查找,以及线性表合并等运算在链接存储结构上的运算。

二、 实验内容1.typedef int ElemType;typedef struct LNode { //创建结构体数据类型LNodeElemType data; //存放数值的数据域struct LNode *next; //存放后继结点地址的指针域}LNode;2. 链表的创建:创建n 个结点,利用scanf( )函数为每个结点的数据域赋值,一次将每个结点插入链表,形成一个包含n 个元素的链表。

#define NULL 0#define OVERFLOW 0#define OK 1#define ERROR -1typedef int ElemType;typedef struct LNode { //创建LNode 数据类型ElemType data;struct LNode *next;}LNode;typedef LNode *LinkList; //定义LinkList 指针型数据类型int CreateList_L(LinkList L, int n) { //创建拥有n 个元素的线性链表//int i;struct LNode *p;L->next = NULL; //线性链表初始化,见右图for (i = n; i > 0; --i) { //循环n 次在头结点和第一个结点间插入新结点,形成长度为n 的线性链表p =(LNode*)malloc(sizeof(LNode));scanf("%d",&p->data);p->next = L ->next;L->next =p;}return 1;}data next data nextl1)2)3)int VistList_L(LinkList L) { //遍历链表L中每个结点的函数struct LNode *p;p = L->next;while (p) {printf("%d ",p->data); //访问输出p结点的数据域p = p->next; } //p指针前进一位,指向后继结点printf("\n");return OK;}}lmain(){int m;LNode l;ElemType e;printf("please input the length of the linklist that you want to build");scanf("%d",&m);printf("please give the number that you want to insert");CreateList_L(&l,m); //调用创建链表函数VistList_L(&l); //调用遍历链表结点函数}3. 链表的插入算法:向链表中某个位置上插入一个结点#define NULL 0#define OVERFLOW 0#define OK 1#define ERROR -1typedef int ElemType;typedef struct LNode { //创建LNode 数据类型ElemType data;struct LNode *next;}LNode;typedef LNode *LinkList;int CreateList_L(LinkList L, int n) { //创建包含n 个元素的链表int i;struct LNode *p;L->next = NULL;for (i = n; i > 0; --i) {p =(LNode*)malloc(sizeof(LNode));scanf("%d",&p->data);p->next = L ->next;L->next =p;}return 1;}int ListInsert_L(LinkList L, int i, ElemType e) { //向链表中第i位插入数据e struct LNode *s,*p;int j;p = ; j = 0; //p指针指向线性链表的头结点while (p && j < ) //循环查找第i-1位作为数据e的插入位置{ p = ; ++j; } //p指针向前移动if (!p || j > i-1)return ERROR;s =(LNode*)malloc(sizeof(LNode)); //见下图1)if ( s == NULL) return ERROR;s-> = e; //将插入数据e的值赋值给s结点的数据域1)s->next = ; p->next = ; //旧链断开,新链产生2)3)return OK;}1)2)3)int VistList_L(LinkList L) { //遍历链表所有结点的函数struct LNode *p;p = L->next;while (p) {printf("%d",p->data);p = p->next; }return OK;}main(){int m;LNode l;ElemType e;int i;printf("please input the length of the linklist that you want to build");scanf("%d",&m);printf("please give the number that the initial list have");CreateList_L(&l,m);VistList_L(&l);printf("please input the positon and data of the insert number i&e");scanf("%d,%d",&i,&e);ListInsert_L(&l,i,e);VistList_L(&l);}附:一元多项式的相加#include<stdio.h>#include<stdlib.h>#define LEN sizeof(node)typedef struct polynode /*用单链表存储多项式的结点结构*/{int coef; /*多项式的系数*/int exp; /*指数*/struct polynode *next; /*next是struct polynode类型中的一个成员,它又指向struct polynode类型的数据,以此建立链表*/}node;/*若定为"node,*list;",意即node*与list同为结构指针类型*/node * create(void) /*指针函数,返回指针类型;用尾插法建立一元多项式的链表的函数*/ {node *h,*r,*s;int c,e;h=(node *)malloc(LEN); /*建立多项式的头结点,为头结点分配存储空间*/r=h; /*r指针始终动态指向链表的当前表尾,以便于做尾插入,其初值指向头结点*/ printf("coef:");scanf("%d",&c); /*输入系数*/printf("exp: ");scanf("%d",&e); /*输入指针*/while(c!=0) /*输入系数为0时,表示多项式的输入结束*/{s=(node *)malloc(LEN); /*申请新结点*/s->coef=c; /*申请新结点后赋值*/s->exp=e; /*申请新结点后赋值*/r->next=s; /*做尾插,插入新结点*/r=s; /*r始终指向单链表的表尾*/printf("coef:");scanf("%d",&c);printf("exp: ");scanf("%d",&e);}r->next=NULL; /*将表的最后一个结点的next置NULL,以示表结束*/return(h);}void polyadd(node *polya, node *polyb)/*一元多项式相加函数,用于将两个多项式相加,然后将和多项式存放在多项式polya中,并将多项式ployb删除*/{node *p,*q,*pre,*temp;int sum;p=polya->next;/*令p和q分别指向polya和polyb多项式链表中的第一个结点*/q=polyb->next;pre=polya; /*位置指针,指向和多项式polya*/while(p!=NULL&&q!=NULL) /*当两个多项式均未扫描结束时,执行以下操作*/{if(p->exp<q->exp) /*若p指向的多项式指数小于q指的指数*/{pre->next=p; /*将p结点加入到和多项式中*/pre=pre->next;p=p->next;}else if(p->exp==q->exp) /*若指数相等,则相应的系数相加*/{sum=p->coef+q->coef;if(sum!=0){p->coef=sum;pre->next=p;pre=pre->next;p=p->next;temp=q;q=q->next;free(temp);}else /*如果系数和为零,则删除结点p与q,并将指针指向下一个结点*/{temp=p->next;free(p);p=temp;temp=q->next;free(q);q=temp;}}else /*若p指数大于q指数*/{pre->next=q; /*p结点不动,将q结点加入到和多项式中*/pre=pre->next;q=q->next;}}if(p!=NULL) /*多项式A中还有剩余,则将剩余的结点加入到和多项式中*/ pre->next=p;else /*否则将B的结点加入到和多项式中*/pre->next=q;}void print(node * p) /*输出函数,打印出一元多项式*/{while(p->next!=NULL){p=p->next;printf(" %d*x^%d",p->coef,p->exp);}}main() /*主函数*/{node * polya,* polyb;printf("Welcome to use!\n");printf("\nPlease input the ploya include coef && exp:\n");polya=create(); /*调用建立链表函数,创建多项式A*/print(polya);printf("\nPlease input the ployb include coef && exp:\n");polyb=create(); /*同理,创建B*/print(polyb);printf("\nSum of the poly is:\n");polyadd(polya,polyb); /*调用一元多项式相加函数*/print(polya); /*调用输出函数,打印结果*/printf("\n");}。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
度为 n 的顺序存储的线性表中,向第 i 个元素(1≤i≤n+1)之前插入一个新元素时, 需要从年向前依次移______个元素。 A n-i B n-i+1 C n-i-1 Di 2、除了______,其它任何指针都不能在算法中作为常量出现,也无法显示。 A 头指针 B 尾指针 C 指针型变量 D 空指针 3、在一个长度为 n 的线性表中顺序查找值为 x 的元素时,查找成功的平均查找长度(即 x 同元素的平均比较次数,假定查找每个元素的概率都相等)为______。 An B n/2 C (n+1)/2 D (n-1)/2 4、在一个单链表 HL 中,若要向表头插入一个自由指针 p 指向的结点,则执行______。 A HL=p;p->next=HL;B p->next=HL; HL=p; C p->next=HL; p=HL;D p->next=HL->next;HL->next=p; 5、在一个单链表 HL 中,若要在指针 q 所指结点的后面插入一个自由指针 p 所指向的结点, 则执行 。 B p->next=q->next;q=p; D p->next=q->next;q->next=p; 。 B p=q->next;q->next=p; A q->next=p->next;p->next=q; C q->next=p->next;p->next=q A p=q->next;p->next=q->next;
6、在一个单链表 HL 中,若要删除由指针 q 所指向结点的后继结点,则执行 C p=q->next;q->next=p->next; D q->next=q=->next->next;q->next=q; 7、对于顺序表,下面说法错误的是______。 A 顺序表是用一维数组实现的线性表,数组的下标可以看成是元素的绝对地址 B 顺序表的所有存储结点按相应数据元素间的逻辑关系决定的次序依次排列 C 顺序表的特点是:逻辑结构中相邻的结点在存储结构中仍相邻 D 顺序表的特点是:逻辑上相邻的元素,存储在物理位置也相邻的单元中; (二) 1. 2. 3. 种。 填空题 (每空 2 分,共计 40 分)
《数据结构》实验报告 2.1 学号: 姓名: 班级: 实验地点:
实验名称:线性表的顺序及链式存储 所使用的工具软件及环境: 一、 实验目的:
1、通过本实验,掌握线性表的顺序存储和链接存储的表示方法 2、并能在线性结构的基本操作的基础上,设计合适的算法解决实际问题 二、 实验内容:
(每题 5 分,共计 35 分)
1
结点有且仅有一个直接______;除终端结点没有直接______外,其它结点有且仅有一 个直接______。 4. 5. 6. 7. 8. 在线性表的单链接存储中,若一个元素所在结点的地址为 p ,则后继结点的地址为 ______,若假定 p 为一个数组 a 中的下标,则其后继结点的下标为______。 在循环单链接表中,最后一个结点的指针域指向______结点。 在双向链接表中每个结点包含有两个针域, 一个指向其______点, 另一个指向其______ 结点。 在循环双向链接表中表头结点的左指针域指向______结点, 最后一个结点的右指针域指 向______结点。 在由数组 a 中元素结点构成的单链表中,在下标为 i 的结点的后面插入一个下标为 j 的 结点时,需要进行的操作为______。 (三)程序填空,利用线性表的“顺序存储结构”解决两个英文单词比大小。 (每空 3 分, 共计 15 分) #include <string.h> #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 typedef char ElemType; typedef struct{ ElemType int length; int listsize; int incrementsize; }SqList; void InitList_Sq(SqList L) { L.elem=(ElemType*)malloc(sizeof( L.length=0; L.listsize=LIST_INIT_SIZE; L.incrementsize=LISTINCREMENT; } int compare(SqList A,SqList B) { /* if A<B return -1;if A=B return 0;if A>B return 1 */ int j; j=0; while(j<A.length && j<B.length){ if(A.elem[j]<B.elem[j]) return(-1); else if( ) return(1);
3
struct Node; typedef struct Node *LNode,*LinkList; struct Node{ ElemType }; LinkList CreateList_L(LinkList L, ElemType A[],int n) { /**/ int i; L=NULL; for(i=n-1;i>=0;i--){ LNode s=(LNode)malloc(sizeof(struct Node)); s->data= s->next= L= } return L; } main() { ElemType A[5]={'a','b','c','d','e'}; int n; LinkList L; LNode p; n=5; p=CreateList_L(L,A,n); printf("\n\n"); while(p!=NULL){ printf("%c\n",p->data); p=p-> } } ; ; ; ; data; struct Node *next;
线性表典型的基本运算包括:______、______、______、______、______、______等六 对于一个长度为 n 的顺序存储的线性表, 在表头插入元素的时间复杂度为______, 在表 尾插入元素的时间复杂度为______。 线性结构的基本特征是:若至少含有一个结点,则除起始结点没有直接______外,其他
2
*elem;
)*LIST_INIT_SIZE);
else j++; } if ( else return(1); } main() { SqList A,B; int result; InitList_Sq(A); InitList_Sq(B); printf("\n\n"); printf("input value of List A:"); scanf("%s",A.elem); A.length= printf("\n\n"); printf("input value of List B:"); scanf("%s",B.elem); B.length=strlen( printf("\n\n"); result=compare(A,B); if(result==1) printf("the result is:(A>B)"); else if(result==-1) printf("the result is:(A<B)"); else printf("the result is:(A=B)"); } (四)程序填空,利用线性表的“链接存储结构”实现逆序创建链表(每空 2 分,共 8 分) #define NULL 0 #define TRUE 1 #define FALSE 0 typedef char ElemType; ); (A.elem); ) return(0); else if(A.length<B.length) return(-1);
任课教师:
成绩:
201



4
相关文档
最新文档