实验一 线性表基本操作
实验一 线性表的基本操作实现及其应用

实验一线性表的基本操作实现及其应用一、实验目的1、熟练掌握线性表的基本操作在两种存储结构上的实现。
2、会用线性链表解决简单的实际问题。
二、实验内容题目一、该程序的功能是实现单链表的定义和操作。
该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。
其中,程序中的单链表(带头结点)结点为结构类型,结点值为整型。
单链表操作的选择以菜单形式出现,如下所示:please input the operation:1.初始化2.清空3.求链表长度4.检查链表是否为空5.检查链表是否为满6.遍历链表(设为输出元素)7.从链表中查找元素8.从链表中查找与给定元素值相同的元素在表中的位置9.向链表中插入元素 10. 从链表中删除元素其他键退出。
其中黑体部分必做题目二、约瑟夫环问题:设编号为1,2,3,……,n的n(n>0)个人按顺时针方向围坐一圈,每个人持有一个正整数密码。
开始时任选一个正整数做为报数上限m,从第一个人开始顺时针方向自1起顺序报数,报到m时停止报数,报m的人出列,将他的密码作为新的m值,从他的下一个人开始重新从1报数。
如此下去,直到所有人全部出列为止。
令n最大值取30。
要求设计一个程序模拟此过程,求出出列编号序列。
struct node(一)1.进入选择界面后,先选择7,进行插入:2.选择4,进行遍历,结果为:3.选择2,得出当前链表长度.4.选择3,得出当前链表为.5.选择分别选择5、6进行测试.6.选择8,分别按位置和元素值删除.7.选择9,或非1-8的字符,程序结束.(二) 实验总结通过这次实验,我对线性链表有了更深的理解,深入明白了线性存储结构与链式存储结构在内存存储的不同特点,同时我还学会了用这些知识实际解决一些问题,能够更加熟练地将算法转化为实际程序。
同时,在写程序和调试程序的过程中,学会了一些书写技巧和调试技巧,这对于自己能在短时间高效的写出正确地程序有很大作用。
四、主要算法流程图及程序清单 1. 主要算法流程图:(1) 从单链表表中查找与给定元素值相同的元素在链表中的位置p=p->nextp&&!(p->data==xtrue调用函数,传入参数L ,xp=L->next2.程序清单:#include<iostream> using namespace std; #include<>#include<>/* 预处理命令 */#define OK 1;#define ERROR 0;#define OVERFLOW -1;/* 单链表的结点类型 */typedef struct LNode{int data;struct LNode *next;}LNode,*LinkedList;/*初始化单链表*/LinkedList LinkedListInit(){空"<<endl;cout<<"\t\t\t"<<"2.求链表长度"<<endl;cout<<"\t\t\t"<<"3.检查链表是否为空"<<endl;cout<<"\t\t\t"<<"4.遍历链表"<<endl;cout<<"\t\t\t"<<"5.从链表中查找元素 "<<endl;cout<<"\t\t\t"<<"6.从链表中查找与给定元素值相同的元素在表中的位置"<<endl;cout<<"\t\t\t"<<"7.向链表中插入元素"<<endl;cout<<"\t\t\t"<<"8.从链表中删除元素"<<endl;cout<<"\t\t\t"<<"9.退出"<<endl;}/*主函数*/int main(){链表长度case 2:{cout<<"\t\t\t链表长度为:"<<LinkedListLength(L)<<endl;getch();}break;查链表是否为空case 3:{if (!LinkedListEmpty(L)){cout<<"\t\t\t链表不为空!"<<endl;}else{cout<<"\t\t\t链表为空!"<<endl;}getch();}break;历链表case 4:{LinkedListTraverse(L);getch();}break;链表中查找元素case 5:{cout<<"\t\t\t请输入要查询的位置i:";int j;cin>>j;if (LinkedListGet(L,j)){cout<<"\t\t\t位置i的元素值为:"<<LinkedListGet(L,j)->data<<endl;}else{cout<<"\t\t\ti大于链表长度!"<<endl;}getch();}break;链表中查找与给定元素值相同的元素在表中的位置case 6:{cout<<"\t\t\t请输入要查找的元素值:";int b;cin>>b;if (LinkedListGet1(L,b)){cout<<"\t\t\t要查找的元素值位置为:"<<LinkedListGet1(L,b)<<endl;cout<<"\t\t\t要查找的元素值内存地址为:"<<LinkedListLocate(L,b)<<endl;}else{cout<<"\t\t\t该值不存在!"<<endl;}getch();}break;链表中插入元素case 7:{cout<<"\t\t\t请输入要插入的值:";int x; cin>>x;cout<<"\t\t\t请输入要插入的位置:";int k; cin>>k;if(LinkedListInsert(L,k,x)){cout<<"\t\t\t插入成功!"<<endl;}else{cout<<"\t\t\t插入失败!"<<endl;}getch();}break;链表中删除元素case 8:{cout<<"\t\t\t1.按位置删除"<<endl;cout<<"\t\t\t2.按元素删除"<<endl;int d;cout<<"\t\t请选择:";cin>>d;switch(d){case 1:{cout<<"\t\t\t请输入删除位置:";cin>>d;int y;if (LinkedListDel(L,d,y)){cout<<"\t\t\t"<<y<<"被删除!"<<endl;}else{cout<<"\t\t\t删除失败!"<<endl;}}break;case 2:{cout<<"\t\t\t请输入删除元素:";int y;cin>>y;if (LinkedListDel(L,y)){cout<<"\t\t\t"<<y<<"被删除!"<<endl;}else{cout<<"\t\t\t删除失败!"<<endl;}}}getch();}break;}}return 1;}题二约瑟夫环问题算法、思想为了解决这一问题,可以先定义一个长度为30(人数)的数组作为线性存储结构,并把该数组看成是一个首尾相接的环形结构,那么每次报m的人,就要在该数组的相应位置做一个删除标记,该单元以后就不再作为计数单元。
实验01 线性表的基本操作

实验01 线性表的基本操作一、实验目的1. 了解线性表的结构特点及有关概念;2. 理解线性表的存储结构;3. 掌握顺序表及单链表的基本操作算法。
二、实验内容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.顺序表初始化:(1)为顺序表L动态分配一个预定大小的数组空间,使elem 指向这段空间的基地址。
(2)将表的当前长度设为0.2.顺序表的取值:(1)判断指定的位置序号i值是否合理(1<=i<=L.length),若不合理则返回ERROR.(2)若i值合理,则将i个数据元素L.elem[i]赋给参数e,通过e返回第i个数据元素的传值。
3.顺序表的查找:(1)从第一个元素起,依次和e相比较,若找到与e相等的元素L.elem[i],则查找成功,返回该元素的序号i+1.(2)若查遍整个顺序表都没要找到,则查找失败,返回0.4.顺序表的插入:(1)判断插入位置i是否合法(i值的合法范围是1<=i<=n+1),若不合法则返回值ERROR.(2)判断顺序表的存储空间是否已满,若满则返回值ERROR(3)将第n个至第i个位置的元素依次向后移动一个位置,空出第i个位置(i=n+1时无需移动)。
实验一线性表的基本操作

实验⼀线性表的基本操作⼀、线性结构的顺序表基本操作实验⽬的1.学会定义单链表的结点类型、线性表的顺序存储类型,实现C程序的基本结构,对线性表的⼀些基本操作和具体的函数定义。
2.掌握顺序表的基本操作,实现顺序表的插⼊、删除、查找以及求并集等运算。
3.掌握对多函数程序的输⼊、编辑、调试和运⾏过程。
实验要求1.预习C语⾔中结构体的定义与基本操作⽅法。
2.对顺序表的每个基本操作⽤单独的函数实现。
3.编写完整程序完成下⾯的实验内容并上机运⾏。
实验内容1.编写程序实现顺序表的下列基本操作:(1)初始化顺序表La。
(2)将La置为空表。
(3)销毁La。
(4)在La中插⼊⼀个新的元素。
(5)删除La中的某⼀元素。
(6)在La中查找某元素,若找到,则返回它在La中第⼀次出现的位置,否则返回0。
(7)打印输出La中的元素值。
2.(选做)编写程序完成下⾯的操作:(1)构造两个顺序线性表La和Lb,其元素都按值⾮递减顺序排列。
(2)实现归并La和Lb得到新的顺序表Lc,Lc的元素也按值⾮递减顺序排列。
(3)假设两个顺序线性表La和Lb分别表⽰两个集合A和B,利⽤union_Sq操作实现A=A∪B。
⼆、单链表基本操作(选做)实验⽬的1. 学会定义单链表的结点类型、线性表的链式存储类型,实现对单链表的⼀些基本操作和具体的函数定义,了解并掌握单链表的类定义以及成员函数的定义与调⽤。
2. 掌握单链表基本操作及两个有序表归并、单链表逆置等操作的实现。
实验要求1.预习C语⾔中结构体的定义与基本操作⽅法。
2.对单链表的每个基本操作⽤单独的函数实现。
3.编写完整程序完成下⾯的实验内容并上机运⾏。
实验内容1.编写程序完成单链表的下列基本操作:(1)初始化单链表La。
(2)在La中插⼊⼀个新结点。
(3)删除La中的某⼀个结点。
(4)在La中查找某结点并返回其位置。
(5)打印输出La中的结点元素值。
2.构造⼀个单链表L,其头结点指针为head,编写程序实现将L逆置。
数据结构--实验报告 线性表的基本操作

数据结构..实验报告线性表的基本操作数据结构实验报告线性表的基本操作1.引言本实验报告旨在介绍线性表的基本操作。
线性表是一种常见的数据结构,它是一组有限元素的有序集合,其中每个元素之间存在一个特定的顺序关系。
线性表的操作包括插入、删除、查找等,这些操作对于有效地管理和利用数据非常重要。
2.实验目的本实验的目的是通过实践理解线性表的基本操作,包括初始化、插入、删除、查找等。
通过编写相应的代码,加深对线性表的理解,并掌握相应的编程技巧。
3.实验内容3.1 初始化线性表初始化线性表是指创建一个空的线性表,为后续的操作做准备。
初始化线性表的方法有多种,如顺序表和链表等。
下面以顺序表为例进行说明。
顺序表的初始化包括定义表头指针和设置表的长度等操作。
3.2 插入元素插入元素是指将一个新的元素插入到线性表的指定位置。
插入元素有两种情况:插入到表的开头和插入到表的中间。
插入元素的操作包括移动其他元素的位置以腾出空间,并将新的元素插入到指定位置。
3.3 删除元素删除元素是指将线性表中的某个元素删除。
删除元素有两种情况:删除表的开头元素和删除表的中间元素。
删除元素的操作包括将被删除元素的前一个元素与后一个元素进行连接,断开被删除元素与表的联系。
3.4 查找元素查找元素是指在线性表中寻找指定的元素。
查找元素的方法有多种,如遍历线性表、二分查找等。
查找元素的操作包括比较目标元素与线性表中的元素进行匹配,直到找到目标元素或遍历完整个线性表。
4.实验步骤4.1 初始化线性表根据线性表的类型选择相应的初始化方法,如创建一个空的顺序表并设置表的长度。
4.2 插入元素输入要插入的元素值和插入的位置,判断插入的位置是否合法。
如果合法,移动其他元素的位置以腾出空间,将新的元素插入到指定位置。
如果不合法,输出插入位置非法的提示信息。
4.3 删除元素输入要删除的元素值,判断元素是否在线性表中。
如果在,则找到目标元素的前一个元素和后一个元素,进行连接删除操作。
数据结构--实验报告 线性表的基本操作

数据结构--实验报告线性表的基本操作数据结构--实验报告线性表的基本操作一、引言本实验报告旨在通过实际操作,掌握线性表的基本操作,包括初始化、插入、删除、查找等。
线性表是最基本的数据结构之一,对于理解和应用其他数据结构具有重要的作用。
二、实验目的1·了解线性表的定义和基本特性。
2·掌握线性表的初始化操作。
3·掌握线性表的插入和删除操作。
4·掌握线性表的查找操作。
5·通过实验巩固和加深对线性表的理解。
三、线性表的基本操作1·初始化线性表线性表的初始化是将一个线性表变量设置为空表的过程。
具体步骤如下:(1)创建一个线性表的数据结构,包括表头指针和数据元素的存储空间。
(2)将表头指针指向一个空的数据元素。
2·插入元素插入元素是向线性表中指定位置插入一个元素的操作。
具体步骤如下:(1)判断线性表是否已满,如果已满则无法插入元素。
(2)判断插入位置是否合法,如果不合法则无法插入元素。
(3)将插入位置及其后面的元素都向后移动一个位置。
(4)将待插入的元素放入插入位置。
3·删除元素删除元素是从线性表中删除指定位置的元素的操作。
具体步骤如下:(1)判断线性表是否为空,如果为空则无法删除元素。
(2)判断删除位置是否合法,如果不合法则无法删除元素。
(3)将删除位置后面的元素都向前移动一个位置。
(4)删除最后一个元素。
4·查找元素查找元素是在线性表中查找指定元素值的操作。
具体步骤如下:(1)从线性表的第一个元素开始,逐个比较每个元素的值,直到找到目标元素或遍历完整个线性表。
(2)如果找到目标元素,则返回该元素的位置。
(3)如果未找到目标元素,则返回找不到的信息。
四、实验步骤1·初始化线性表(1)定义线性表的数据结构,包括表头指针和数据元素的存储空间。
(2)将表头指针指向一个空的数据元素。
2·插入元素(1)判断线性表是否已满。
实验一 线性表基本操作

实验一线性表基本操作一、实验目的掌握线性表的顺序表和链表的基本操作:建立、插入、删除、查找、合并、打印等运算。
二、实验要求包含有头文件和main函数;1.格式正确,语句采用缩进格式;2.设计子函数实现题目要求的功能;3.编译、连接通过,熟练使用命令键;4.运行结果正确,输入输出有提示,格式美观。
三、实验设备、材料和工具1.奔腾2计算机或以上机型2.turboc2,win-tc四、实验内容和步骤实验内容:1.分析程序。
2.用头插入法建立带头结点的单链表3.用尾插入法建立带头结点的单链表4.单链表就地逆置5.约瑟夫问题步骤:1.确定数据的结构;2.利用main函数调用各子函数;3.调试、分析运行结果。
五、实验报告要求1.根据实验内容初步设计好程序,并从理论上排除错误;2.针对程序的健壮性准备好测试数据;3.结果分析中如实填写运行后的结果,记录调试过程中产生的重要问题和解决方法。
六、根据实验过程填写下面内容基础部分1.请认真阅读理解,上机运行并分析结果。
#include "seqlist.h"#include <stdio.h>main( ){ SeqList a;int i, m, x;printf("请输入顺序表元素,从小到大排列,元素为整型量,用空格分开,-99为结束标志:\n");st = 0; i = 0; scanf("%d",&i);while (i != -99){ a.elem[st] = i;st++;scanf("%d",&i); }st--;scanf("%d",&x);for (i = 0; i <= st; i++)printf("%4d",a.elem[i]);printf("\n");i = st;while ((i >= 1) && ( x < a.elem[i])) i--;for(m = st; m >= i + 1; m--) a.elem[m + 1] = a.elem[m];a.elem[i + 1] = x;st++;for (i = 0; i <= st; i++)printf("%4d",a.elem[i]);printf("\n");}结果:以上程序的功能是什么?2.下面的程序实现用头插法建立带头结点的单链表,请补充完整程序。
线性表的基本操作

实验一线性表的基本操作一、实验目的学习掌握线性表的顺序存储结构、链式存储结构。
设计顺序表的创建、插入、删除等基本操作,设计单链表的建立、插入、删除等基本操作。
二、实验内容1.顺序表的实践(1)顺序表的创建:基于顺序表的动态分配存储结构,创建一个顺序表S,初始状态S=(1,2,3,4,5)。
(2)顺序表的遍历:依次输出顺序表的每个数据元素。
(3)顺序表的插入:在顺序表S=(1,2,3,4,5)的数据元素4和5之间插入一个值为9的数据元素。
(4)顺序表的删除:顺序表S=(1,2,3,4,9,5)中删除指定位置(i=3)的数据元素3。
(5)顺序表的按值查找:查找顺序表S中第1个值等于4的数据元素位序。
(6)顺序表的清空:释放顺序表的存储空间。
2.单链表的实践(1)单链表的创建:创建一个包括头结点和4个元素结点的单链表L=(5,4,2,1)。
(2)单链表的遍历:依次输出顺序表的每个数据元素。
(3)单链表的取值:输出单链表中第i个(i=2)数据元素的值。
(4)单链表的插入:在已建好的单链表的指定位置(i=3)插入一个结点3。
(5)单链表的删除:在一个包括头结点和5个结点的单链表L=(5,4,3,2,1)中,删除指定位置(i=2)的结点,实现的基本操作。
(6)求单链表的表长:输出单链表的所有元素和表长。
(7)单链表的判空:判断单链表是否为空表。
(8)单链表的清空:释放单链表的存储空间。
三、程序源代码1.线性表的基本操作#include <iostream>#include<stdlib.h>using namespace std;#define OK 1#define OVERFLOW -2#define ERROR 0#define LIST_INIT_SIZE 100#define LISTINCEREMENT 10typedef int Status;typedef int Elemtype;typedef Elemtype *Triplet;typedef struct { //定义结构体类型:顺序表Elemtype *elem;int length;int listsize;} Sqlist;Status Initlist( Sqlist &L ) { //int n,i;L.elem = (Elemtype*) malloc (LIST_INIT_SIZE*sizeof(Elemtype));if(!L.elem) {return(OVERFLOW);}cout << "输入元素个数和各元素的值:";cin >> n;for(int i=0; i<n; i++) {cin >> L.elem[i];}L.length = n;L.listsize = LIST_INIT_SIZE;return OK;}Status TraverList(Sqlist L) {for(int i=0; i<L.length; i++) {cout << L.elem[i]<<" ";}cout << endl;}Status ListInsert (Sqlist &L,int i,Elemtype e) { //插入Elemtype *newbase,*p,*q;if(i<1||i>L.length+1) return ERROR;//i不合法if(L.length >= L.listsize) { //需要重新分配存储空间newbase = (Elemtype *) realloc(L.elem,(L.listsize + LISTINCEREMENT)*sizeof (Elemtype));if(!newbase) exit(OVERFLOW);//分配失败L.elem = newbase;L.listsize += LISTINCEREMENT;}q = &(L.elem[i-1]);for(p=&(L.elem[L.length-1]); p>=q; --p)*(p+1)=*p;*q=e;++L.length;return OK;}Status ListDelete(Sqlist &L,int i,Elemtype &e) { //删除Elemtype *p,*q;if((i<1)||(i>L.length)) return ERROR;p=&(L.elem[i-1]);e=*p;q=L.elem+L.length-1;for(++p; p<=q; ++p)*(p-1)=*p;--L.length;return OK;}Status LocateElem(Sqlist L,Elemtype &e) { //查找int i;Elemtype *p;i=1;p=L.elem;while(i<=L.length&&*(p++)!=e) ++i;if(i<=L.length) return i;else return 0;}Status ClearList(Sqlist &L) {free(L.elem);cout << "该表已被清空!";return OK;}int main() {Sqlist L;int i,z;Elemtype e;if(Initlist(L)==OVERFLOW) {cout << endl << "OVERFLOW";return 0;}TraverList(L);while(1) {cout << "-------------------" << endl;cout << "选择要执行的基本操作:" << endl << "1:插入元素" << endl << "2.删除元素" << endl << "3.查找元素" << endl<< "4.退出" << endl;cin >> z;switch(z) {case 1:cout << "输入要插入元素的位置和值:" << endl;cin >> i >> e;if(ListInsert(L,i,e)==OK)TraverList(L);elsecout << "插入的位置不合法。
数据结构--实验报告 线性表的基本操作

数据结构--实验报告线性表的基本操作线性表的基本操作实验报告1.引言线性表是最基本的数据结构之一,它可以用来存储一系列具有相同数据类型的元素。
本实验旨在通过实践掌握线性表的基本操作,包括插入、删除、查找和修改元素等。
本文档将详细介绍实验所需的步骤和操作方法。
2.实验目的1.掌握线性表的插入和删除操作。
2.理解线性表的查找和修改元素的方法。
3.熟悉线性表的基本操作在算法中的应用。
3.实验环境本实验使用编程语言/软件名称作为开发环境,具体要求如下:________●操作系统:________操作系统名称和版本●编程语言:________编程语言名称和版本4.实验步骤4.1 初始化线性表在程序中创建一个空的线性表,用于存储元素。
实现方法:________具体的初始化方法和代码示例 4.2 插入元素在线性表中指定位置插入一个新元素。
实现方法:________具体的插入元素方法和代码示例 4.3 删除元素删除线性表中指定位置的元素。
实现方法:________具体的删除元素方法和代码示例 4.4 查找元素在线性表中查找指定元素的位置。
实现方法:________具体的查找元素方法和代码示例 4.5 修改元素修改线性表中指定位置的元素值。
实现方法:________具体的修改元素方法和代码示例5.实验结果在完成上述步骤后,我们得到了一个可以进行插入、删除、查找和修改元素的线性表。
具体操作结果如下:________●插入元素操作结果:________插入元素的具体操作结果●删除元素操作结果:________删除元素的具体操作结果●查找元素操作结果:________查找元素的具体操作结果●修改元素操作结果:________修改元素的具体操作结果6.实验总结通过本次实验,我们深入理解了线性表的基本操作,并且掌握了这些操作的实现方法。
线性表在实际应用中十分常见,熟练掌握线性表的操作对于开发高效的算法和数据结构具有重要意义。
实验一--线性表基本操作的编程实现

实验一--线性表基本操作的编程实现实验一线性表基本操作的编程实现【实验目的】线性表基本操作的编程实现要求:线性表基本操作的编程实现(2学时,验证型),掌握线性表的建立、遍历、插入、删除等基本操作的编程实现,也可以进一步编程实现查找、逆序、排序等操作,存储结构可以在顺序结构或链表结构中任选,可以完成部分主要功能,也可以用菜单进行管理完成大部分功能。
还鼓励学生利用基本操作进行一些更实际的应用型程序设计。
【实验性质】验证性实验(学时数:2H)【实验内容】把线性表的顺序存储和链表存储的数据插入、删除运算其中某项进行程序实现。
建议实现键盘输入数据以实现程序的通用性。
为了体现功能的正常性,至少要编制遍历数据的函数。
【注意事项】1.开发语言:使用C。
2.可以自己增加其他功能。
【思考问题】1.线性表的顺序存储和链表存储的差异?优缺点分析?2.那些操作引发了数据的移动?3.算法的时间效率是如何体现的?4.链表的指针是如何后移的?如何加强程序的健壮性?【参考代码】(以下内容,学生任意选择一个完成即可)(一)利用顺序表完成一个班级学生课程成绩的简单管理1、预定义以及顺序表结构类型的定义(1) #include<stdio.h>#include<conio.h>#define ListSize 100 //根据需要自己设定一个班级能够容纳的最大学生数(2) typedef struct stu{int num; //学生的学号char name[10]; //学生的姓名float physics; //物理成绩float math; //数学成绩float english; //英语成绩}STUDENT; //存放单个学生信息的结构体类型typedef struct List{STUDENT stu[ListSize]; //存放学生的数组定义,静态分配空间int length; //记录班级实际学生个数}LIST; //存放班级学生信息的顺序表类型2、建立班级的学生信息void listcreate(LIST *Li,int m) //m为该班级的实际人数{int i;Li->length=0;for(i=1; ;i++) //输入m个学生的所有信息{printf("请输入第%d位学生的信息:\n",i);printf("学号=");scanf("%d",&Li->stu[i].num); //输入第i个学生的学号printf("姓名=");scanf("%s",&Li->stu[i].name); //输入第i个学生的姓名printf("物理成绩=");scanf("%f",&Li->stu[i].physics); //输入第i 个学生的物理成绩printf("数学成绩=");scanf("%f",&Li->stu[i].math); //输入第i个学生的数学成绩printf("英语成绩=");scanf("%f",&Li->stu[i].english); //输入第i 个学生的英语成绩; //学生人数加1}}3、插入一个学生信息int listinsert(LIST *Li,int i) //将学生插入到班级Li的第i个位置。
实验一线性表的基本操作

实验一线性表的基本操作一、实验目的1、熟悉C或VC++语言上机环境。
2、会定义线性表的顺序存储结构和链式存储结构。
3、熟悉顺序表和链表的一些基本操作和应用。
4、加深对线性表的理解,逐步培养解决实际问题的编程能力。
二、实验环境运行C或VC++的微机。
三、实验内容1.已知线性表LA的数据元素(n个,n为偶数),现要求将LA拆开成两个新的线性表LB,LC。
要求LB中的数据元素为LA中的奇数位序的数据元素(a1, a3, …, a n-1),LC中的数据元素为LA中的偶数位序的数据元素(a2, a4, …, a n)。
#include<stdio.h>#include<malloc.h>#define max 600//定义线性表的最大长度typedef struct{char *elem;char list[max];//线性表int length;//指示当前线性表的长度}sqlist;void initial(sqlist &);//初始化线性表void insert(sqlist &,int,char);//在线性表中插入元素void initlist(sqlist &);void print(sqlist);//显示线性表中所有元素void main(){sqlist la,lb,lc;//la,lb,lc为线性表initial(la);initlist(lc);int i;for(i=0;i<la.length;i++){if(i%2==0)insert(lb,i/2,la.list[i]);elseinsert(lc,i/2,la.list[i]);}printf("\n您输入的线性表元素为:\n");print(la);printf("线性表的奇数位次的元素为:\n");print(lb);printf("线性表的偶数位次的元素为:\n");print(lc);}void initial(sqlist &v){printf(" ***本程序可以实现线性表奇偶位序的元素分别输出***\n");int i,a;printf("请输入一个偶数作为线性表的长度:\n");scanf("%d",&a);while(a%2!=0){printf("您刚才输入的是奇数,请重新输入一偶数:\n");scanf("%d",&a);}v.length=a;printf("\n请输入线性表的元素:\n");getchar();for(i=0;i<v.length;i++)scanf("%c",&v.list[i]);}void initlist(sqlist &v){v.elem=(char*)malloc(max*sizeof(char));v.length=0;}void insert(sqlist &v,int j,char c){v.list[j]=c;v.length++;}{int i;for(i=0;i<v.length;i++){printf("%c",v.list[i]);}printf("\n\n");}2. 已知线性表LA的数据元素(n个),现要求将LA的数据元素复制到另一个线性表LB中。
实验1 线性顺序表的基本操作

实验一一、实验目的1、掌握使用VC6.0上机调试线性表的基本方法;2、掌握线性表的基本操作:插入、删除、查找以及线性表合并等运算在顺序存储结构和链接存储结构上的运算。
二、实验要求1、认真阅读和掌握本实验的程序。
2、上机运行本程序。
3、保存和打印出程序的运行结果,并结合程序进行分析。
4、按照你对线性表的操作需要,重新改写主程序并运行,打印出文件清单和运行结果三、注意事项:在磁盘上创建一个目录,专门用于存储数据结构实验的程序。
四、实验内容程序1:线性表基本操作的实现这个程序中演示了顺序表的创建、插入、删除和查找,请修改并完成。
程序如下:#include <stdio.h>#include <stdlib.h>/*顺序表的定义:*/#define ListSize 100typedef struct{ int data[ListSize]; /*向量data用于存放表结点*/int length; /*当前的表长度*/}SeqList;void CreateList(SeqList *L,int n);void PrintList(SeqList *L,int n);int LocateList(SeqList *L,int x);void InsertList(SeqList *L,int x,int i);void DeleteList(SeqList *L,int i);void main(){SeqList L;int i,x;int n=10; /*THE LENGTH OF LIST*/L.length=0;clrscr();CreateList(&L,n); /*CREAT THE LIST*/PrintList(&L,n); /*PRINT THE LIST*/printf("INPUT THE RESEARCH ELEMENT");scanf("%d",&x);i=LocateList(&L,x);printf("the research position is %d\n",i); /*顺序表查找*/printf("input the position of insert:\n");scanf("%d",&i);printf("input the value of insert\n");scanf("%d",&x);InsertList(&L,x,i); /*顺序表插入*/PrintList(&L,n); /*打印顺序表*/printf("input the position of delete\n");scanf("%d",&i);DeleteList(&L,i); /*顺序表删除*/PrintList(&L,n);getch();/*打印顺序表*/}/*顺序表的建立:*/void CreateList(SeqList *L,int n){int i;printf("please input n numbers\n");for(i=1;i<=n;i++){scanf("%d",&L->data[i]);}L->length=n;}/*顺序表的打印:*/void PrintList(SeqList *L,int n){int i;printf("the sqlist is\n");for(i=1;i<=n;i++)printf("%d ",L->data[i]);}/*顺序表的查找:*/int LocateList(SeqList *L,int x){int i;for(i=1;i<=10;i++)if((L->data[i])==x) return(i);else return(0);}/*顺序表的插入:*/void InsertList(SeqList *L,int x,int i){int j;for(j=L->length;j>=i;j--)L->data[j+1]=L->data[j];L->data[i]=x;L->length++;}/*顺序表的删除:*/void DeleteList(SeqList *L,int i) { int j;for(j=i;j<=(L->length)-1;j++)L->data[j]=L->data[j+1];}。
实验一线性表操作实验报告

实验一_线性表操作_实验报告实验一:线性表操作一、实验目的1.理解线性表的基本概念和特点。
2.掌握线性表的基本操作,包括插入、删除、查找等。
3.通过实验,提高动手能力和解决问题的能力。
二、实验原理线性表是一种较为常见的数据结构,它包含零个或多个数据元素,相邻元素之间有前后关系。
线性表具有以下特点:1.元素之间一对一的顺序关系。
2.除第一个元素外,每个元素都有一个直接前驱。
3.除最后一个元素外,每个元素都有一个直接后继。
常见的线性表有数组、链表等。
本实验主要针对链表进行操作。
三、实验步骤1.创建链表:首先创建一个链表,并给链表添加若干个节点。
节点包括数据域和指针域,数据域存储数据,指针域指向下一个节点。
2.插入节点:在链表中插入一个新的节点,可以选择在链表的头部、尾部或中间插入。
3.删除节点:删除链表中的一个指定节点。
4.查找节点:在链表中查找一个指定数据的节点,并返回该节点的位置。
5.遍历链表:从头节点开始,依次访问每个节点的数据。
四、实验结果与分析1.创建链表结果:我们成功地创建了一个链表,每个节点都有数据域和指针域,数据域存储数据,指针域指向下一个节点。
2.插入节点结果:我们成功地在链表的头部、尾部和中间插入了新的节点。
插入操作的时间复杂度为O(1),因为我们只需要修改指针域即可。
3.删除节点结果:我们成功地删除了链表中的一个指定节点。
删除操作的时间复杂度为O(n),因为我们可能需要遍历整个链表才能找到要删除的节点。
4.查找节点结果:我们成功地在链表中查找了一个指定数据的节点,并返回了该节点的位置。
查找操作的时间复杂度为O(n),因为我们可能需要遍历整个链表才能找到要查找的节点。
5.遍历链表结果:我们成功地遍历了整个链表,并访问了每个节点的数据。
遍历操作的时间复杂度为O(n),因为我们可能需要遍历整个链表。
通过本次实验,我们更加深入地理解了线性表的基本概念和特点,掌握了线性表的基本操作,包括插入、删除、查找等。
使用数据结构基础第五版王中华课后实验

使用数据结构基础第五版王中华课后实验
本次实验是基于《数据结构基础》第五版王中华教授所编写的课本,实验内容包含了
课后习题的部分,并且结合课本中的数据结构实现,加以实践与验证。
实验一:线性表的基本操作
1、目的:加深对线性表基本概念的理解与掌握。
掌握线性表的初始化,清空,判空,获取长度等基本操作。
2、实验步骤:
(1)根据课本提供的线性表结构体定义,编写相应的初始化函数。
(2)编写线性表的清空、判空、获取长度等基本操作函数。
(3)测试以上函数是否正确。
3、实验结果:
测试函数结果均正确。
加深了对线性表基本操作的理解。
实验二:顺序表的插入与删除
1、目的:了解顺序表的插入和删除的实现过程,掌握插入和删除的操作方式和效
果。
(2)实现顺序表的插入(在指定位置插入)和删除(删除指定位置元素)操作。
测试函数结果正确。
了解了单链表和双链表的实现过程,掌握了链表的插入和删除操
作方法。
1、目的:了解栈的基本概念和操作方法,掌握栈的初始化、入栈、出栈、获取栈顶
元素、栈空及栈长等基本操作方法。
(2)实现队列的初始化、入队、出队、获取队头元素、队空及队长等基本操作方法。
总结:通过对《数据结构基础》第五版王中华教授所编写的课本进行实验,加深了对
线性表、顺序表、链表、栈和队列的理解,掌握了这些数据结构的基本操作方法和实现原理。
本次实验让我更有信心在数据结构的学习与实践中取得更好的结果。
实验一-线性表操作-实验报告

中国矿业大学计算机学院实验报告{cin>>y;if(y==1){cout<<"请输入插入位置和元素的值:"<<endl;cin>>m>>n;ListInsert_Sq(List,m,n);disp(List);}else if(y==2){cout<<"请输入要删除第几个元素:"<<endl;cin>>m;ListDelete_Sq(List,m,j);cout<<j<<endl;disp(List);}else{cout<<"请输入所要查找的元素:"<<endl;cin>>m;cout<<LocateElem_Sq(List,m)<<endl;}}cout<<endl;}运行结果:加强、提高题:2、编写一个求解Josephus问题的函数。
用整数序列1, 2, 3, ……, n表示顺序围坐在圆桌周围的人。
然后使用n = 9, s = 1, m = 5,以及n = 9, s = 1, m = 0,或者n = 9, s = 1, m = 10作为(2)提高:#include<iostream>using namespace std;typedef struct LNode{struct LNode *next;int a;}LNode,*LinkList;class JosephouCircle //定义一个类包括三个元素{public:void SetValue();void PickOut();private:int n;int s;int m;};void JosephouCircle::SetValue() //设置初值的大小{cout<<"请输入参加游戏的总人数:"<<endl;cin>>n;cout<<"请输入开始人的位置:"<<endl;cin>>s;JosephouCircle Jo1;Jo1.SetValue();Jo1.PickOut();return 0;}运行结果:四、实验体会与总结1、对于线性链表和顺序表都属于线性表问题,但是线性链表比顺序表要灵活,方便;2、线性表在做元素寻找的操作的时候,必须从头结点开始寻找。
实验1 线性表的基本操作

实验一线性表的基本操作一、实验目的(1)掌握线性表顺序存储和链式存储的方法及基本运算的实现。
(2)掌握将算法在VC++6.0语言环境下实现的过程。
二、实验准备(1)复习线性表的定义,掌握顺序存储、链式存储的方法及操作。
(2)复习C语言中指针与结构体的概念、定义方式。
(3)掌握链表的C语言的实现。
(4)实验的计算机中安装了Microsoft VC++ 6.0。
三、实验内容顺序表1)首先创建一个顺序表:从键盘读入一组整数(长度小于等于20),按输入顺序放入顺序表,输入以-1结束(注意-1不放到顺序表内);将创建好的顺序表元素依次输出到屏幕上。
2)在已创建好的顺序表中插入一个元素:从键盘读入需插入的元素值和插入位置,调用插入函数完成插入操作;然后将顺序表元素依次输出到屏幕上。
3)在已创建好的顺序表中删除一个元素:从键盘读入欲删除的元素位置(序号),调用删除函数完成删除操作;然后将顺序表元素依次输出到屏幕上。
算法提示:➢需求分析:1.功能(1)建立一顺序表(2)显示顺序表中每个元素(3)在上述的顺序表中的指定位置插入指定的元素,并输出顺序表中所有数据。
(4)在上述的顺序表中的指定位置删除指定的元素,并输出顺序表中所有数据。
2.输入要求从键盘输入顺序表中所有数据,输入以-1结束(注意-1不放到顺序表内);需插入的数据元素的位置、值;要删除的数据元素的位置(序号)。
3. 测试数据顺序表中所有数据:15,26,58,27,9插入的数据元素的位置、值:1,28;6,28;0,28要删除的数据元素的位置:3➢概要设计:1.数据结构:提示:相关常量和顺序表数据类型定义#define MAXNUM 20#define true 1#define false 0typedef struct{int data[MAXNUM];int length;}list_type;2.模块划分:a)建立顺序表的createlist函数;b)显示输出顺序中每个结点的数据的showlist函数;c)insertlist函数:插入函数。
线性表的基本操作实验报告

线性表的基本操作实验报告线性表的基本操作1、需求分析:构建一个顺序表并实现顺序表的一些基本操作,例如创建列表,插入、删除元素,求元素的前驱等功能。
(1) 顺序表中数据元素为整形数字,范围属于int型。
(2) 输出部分操作提示以及功能操作所得到的数据(int型)。
(3) 顺序表建立、删除、插入、查询、判空、判满、查询前后驱等功能。
(4) 测试数据:a)b)2、概要设计:用一个结构定义了一个数组,和数组内容的长度。
主程序使用switch语句对将要进行的操作进行选择,调用各个功能函数。
3、实验源代码如下:#include<iostream>using namespace std;typedef struct{int date[100];int length;}SeqList;SeqList L;SeqList SeqListInit()//初始化顺序表 {cout<<"你定义的顺序表的长度(长度小于)"<<endl;cin>>L.length;cout<<"顺序表里面储存数据为"<<endl;for(int i=0;i<L.length;i++){int a;cin>>a;L.date[i]=a;}return L;}void ListClear()/* 清空顺序表*/{L.length=0;}int ListLength()/* 求顺序表长度*/{cout<<L.length<<endl;return 0;}int ListEmpty()/* 检查顺序表是否为空*/ { if(L.length==0)cout<<"为空"<<endl;elsecout<<"不为空"<<endl;return 0;}int ListFull()/*检查顺序表是否为满*/ { if(L.length==100)cout<<"为满"<<endl;elsecout<<"未满"<<endl;return 0;}void ListTraverse()/* 遍历顺序表*/{for(int i=0;i<L.length;i++)cout<<L.date[i]<<" ";cout<<endl;}int ListGet(int i)/* 从顺序表中查找元素*/ { if(i>=0&&i<L.length)cout<<L.date[i-1]<<endl;return 0;}int ListLocate(int x){for(int i=0;i<L.length;i++)if(L.date[i]==x)cout<<L.date[i];return 0;}void ListInsert(int i, int x){if(i>=0&&i<L.length){for(int m=0;i<=L.length-i;m++)L.date[L.length]=L.date[L.length-1];L.date[i-1]=x;L.length++;}}void ListDelete(int i){if(i>=0&&i<L.length){for(i;i<L.length;i++)L.date[i-1]=L.date[i];L.length--;}}int ListPrior(int e){if(e-2>=0&&e-2<L.length)cout<<L.date[e-2]<<endl;return 0;}int ListNext(int e){if(e>=0&&e<L.length)cout<<L.date[e]<<endl; return 0; }int main(){while(1){int i;cout<<"1初始化顺序表"<<endl;cout<<"2清空顺序"<<endl;cout<<"3求顺序表长度"<<endl;cout<<"4检查顺序表是否为空"<<endl;cout<<"5检查顺序表是否为满"<<endl;cout<<"6遍历顺序表"<<endl;cout<<"7从顺序表中查找元素"<<endl;cout<<"8从顺序表中查找与给定元素值相同的元素的位置"<<endl; cout<<"9向顺序表插入元素"<<endl;cout<<"10从顺序表中删除元素"<<endl;cout<<"11求元素前驱"<<endl;cout<<"12求元素后继"<<endl;cin>>i;switch (i){case 1:SeqListInit();break;case 2:ListClear();break;case 3:ListLength();break;case 4:ListEmpty();break;case 5:ListFull();break;case 6:ListTraverse();break;case 7:{int m;cout<<"请输入查找元素的位置"<<endl; cin>>m;ListGet(m);break;}case 8:{int m;cout<<"请输入查找元素"<<endl; cin>>m;ListLocate(m);break;}case 9:{int x;cout<<"请输入插入的元素"<<endl; cin>>x;ListInsert(i,x);break;}case 10:{int m;cout<<"请输入删除的元素"<<endl; cin>>m;ListDelete(m);break;}case 11:{int m;cout<<"请输入元素的位置"<<endl; cin>>m;ListPrior(m);break;}case 12:{int m;cout<<"请输入元素的位置"<<endl; cin>>m;ListNext(m);break;}default:break;}}}4、a) 遇见形参与实参搞混问题,改形参里面的内容并不影响其原本数据。
实验1 线性表的基本操作

ElemType *p=L.elem+1;
while(i<=L.length&&*p!=cur_e)
{
p++;
i++;
}
if(i>L.length)
return*--p;
return 1;
}
}
int NextElem(SqList L,ElemType cur_e,ElemType &next_e)
int i;
p=L.elem;
for(i=1;i<=L.length;i++)
vi(*p++);
cout<<endl;
return 1;
} void print(ElemType &c) {
printf("%d ",c); } // 线性表的单链表存储结构 struct LNode { ElemType data; LNode *next; }; typedef LNode *LinkList; // 另一种定义LinkList的方法 // 操作结果:构造一个空的线性表L Status InitList(LinkList &L) { L=(LinkList)malloc(sizeof(LNode)); // 产生头结点,并使L指向此头结点 if(!L) // 存储分配失败
// 操作结果:用e返回L中第i个数据元素的值 if(i<1||i>L.length)
exit(1); e=*(L.elem+i-1); return 1; } int equal(ElemType c1,ElemType c2) { // 判断是否相等的函数,Union()用到 if(c1==c2)
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
{
printf("申请空间失败");
return ERORR;
}
s->number=i;
printf("请输入第%d个人的密码:",i);
scanf("%d",&s->password);
t->next=s;
t=s;
}
t->next=NULL;
return (OK);
}
int Josephus(LinkList H,int m)
p1=InsList(p,e);
show(p1);
}
运行结果:
分析:该程序一共有三个子函数:InitList(int r)初始化顺序表、InsList (SeqList *L,ElemType e)插入元素、show(SeqList *L)显示顺序表。主函数先得到数序表的长度r,把r传给初始化函数,经输入和排序得到一个顺序表,返回表的收地址L。输入一个待插入数e,再调用插入函数把它插入到该顺序表中(先用for循环通过比较找到该插入的位置,在用for循环把后面的元素都向后移一位,再把e插入,最后last++),返回首地址L。最后在调用显示函数,输出插入后的顺序表
printf("请输入从哪开始删除:");
scanf("%d",&i);
printf("请输入删除的位数:");
scanf("%d",&k);
p1= DelList(p,i,a,k);
show(p1);
}
运行结果:
分析:该函数有三个子函数:InitList(int r)初始化顺序表、DelList (SeqList *L,int i,ElemType a[],int k)删除元素、show(SeqList *L)显示顺序表。主函数先得到数序表的长度r,把r传给初始化函数,经输入和排序得到一个顺序表,返回表的收地址L。输入要删除的首位置i和删除的位数k,再调用删除函数把该顺序表中的相应元素删掉(先用for循环删除这k个元素,在用for循环把后面的元素向前移,最后last-k),返回首地址L。最后在调用显示函数,输出插入后的顺序表
l->elem[j+1]=temp;
}
}
}return(l);
}
SeqList * DelList(SeqList *l,int i,ElemType a[],int k)//删除
{
int j,p;
if((i<1)||(i>l->last+1))
{
printf("删除位置不合法");
return (ERROR);
p=head=(link*)malloc(sizeof(link));
for(i=1;i<=n;i++)
{
printf("输入第%d个数据",i);
s=(link*)malloc(sizeof(link));
scanf("%d",&s->data);
p->next=s;
p=s;
}
p->next=NULL;
{
ElemType1 number;
ElemType2 password;
struct Node* next;
}Node,*LinkList;
int InitList(LinkList H,int n)
{
Node *s,*t;
int i;
t=H;
for(i=1;i<=n;i++)
{
s=(Node *)malloc(sizeof(Node));
6.将运行结果截图,并粘在文档的相应位置。
三、实验环境
1.turboc2,win-tc,VC++
四、实验内容和步骤
1.编程实现在顺序存储的有序表中插入一个元素。
2.编程实现把顺序表中从i个元素开始的k个元素删除。
3.编程序实现将单链表的数据逆置,即将原表的数据(a1,a2….an)变成(an,…..a2,a1)。
4.约瑟夫环问题。
约瑟夫问题的一种描述是:编号为1,2,…,n的n个人按顺时针方向围坐一圈,每人持有一个密码(正整数)。一开始任选一个整数作为报数上限值m,从第一个人开始顺时针自1开始顺序报数,报到m时停止报数。报m的人出列,将他的密码作为新的m值,从他在顺时针方向上的下一个人开始重新从1报数,如此下去,直至所有的人全部出列为止。试设计一个程序,求出出列顺序。
#define OK 1
#define ERROR 0
#define ElemType int
#define MAXSIZE 100
typedef struct//顺序表申明
{
ElemType elem[MAXSIZE];
int last;
}SeqList;
SeqList * InitList(int r)//初始化顺序表输入顺序表的元素
}
SeqList * InsList (SeqList *L,ElemType e)//插入元素
{
int K,i,j;
if(L->last>=MAXSIZE-1)
{
printf("表已满无法插入");
return(ERROR);
}
for(K=0;K<L->last;K++)
{
if(e<=L->elem[K])
实验一 线性表
(4课时)
一、实验目的
掌握线性表的顺序表和链表的基本操作:建立、插入、删除、查找、合并、打印等运算。
二、实验要求
1.格式正确,语句采用缩进格式;
2.设计子函数实现题目要求的功能;
3.编译、连接通过,熟练使用命令键;
4.运行结果正确,输入输出有提示,格式美观。
5.输入数据至少三组,分别代表不同的情况,以测试程序的正确性。
}
for(i=0;i<l->last;i++)//排序
{
for(j=0;j<l->last-i;j++)
{
if(l->elem[j]>l->elem[j+1])
{
temp=l->elem[j];
l->elem[j]=l->elem[j+1];
l->elem[j+1]=temp;
}
}
}return(l);
}
for(j=i,p=0;j<i+k,p<k;j++,p++)
{
a[p]=l->elem[j-1];
}
for(j=i;j<l->last;j++)
{
l->elem[j-1]=l->elem[j+k-1];
}
l->last=l->last-k;
return (l);
}
void show(SeqList *L)//显示顺序表
return(head);
}
void reverse(link *head )//置换
{
link *p,*s,*t;
p=head;
s=p->next;
t=s->next;
while(s->next!=NULL)
{
t=s->next;
s->next=p;
p=s;
s=t;
}
s->next=p;
p=s;
head->next->next=NULL;
{
i=K;break;
}
}
for(j=L->last;j>=i;j--)
{
L->elem[j+1]=L->elem[j];
}
L->elem[i]=e;
L->last++;
return (L);
}
void show(SeqList *L)//显示顺序表
{
int i;
for(i=0;i<=L->last;i++)
{
printf("%d ",L->elem[i]);
}
}
void main()//主函数
{
int e,r;
SeqList *p,*p1;
printf("请输入线性表的长度:");
scanf("%d",&r);
p=InitList(r);
printf("请输入插入的元素:");
scanf("%d",&e);
{
int i;
for(i=0;i<=L->last;i++)
{
printf("%d ",L->elem[i]);
}
}
void main()//主函数
{
int a[100],r,i,k;
SeqList *p,*p1;
printf("请输入线性表的长度:");
scanf("%d",&r);
p=InitList(r);
printf("请输入链表的长度:");