课程实验报告1线性表

合集下载

实验1线性表及其应用实验报告

实验1线性表及其应用实验报告

实验1线性表及其应⽤实验报告暨南⼤学本科实验报告专⽤纸课程名称数据结构成绩评定实验项⽬名称线性表及其应⽤指导教师王晓明实验项⽬编号实验⼀实验项⽬类型综合性实验地点南海楼601 学⽣姓名朱芷漫学号2010051875学院信息科学技术学院系计算机专业计算机科学与技术实验时间2011年9⽉7⽇18:30午~9⽉7⽇20:30午温度℃湿度⼀、实验⽬的和要求实验⽬的:熟练掌握线性表基本操作的实现及应⽤实验要求:在上机前写出全部源程序完毕并调试完毕。

⼆、实验原理和主要内容1.建⽴4个元素的顺序表SqList={2,3,4,5},实现顺序表的基本操作;在SqList={2,3,4,5}的元素4与5之间插⼊⼀个元素9,实现顺序表插⼊的基本操作;在SqList={2,3,4,9,5}中删除指定位置(i=3)上的元素,实现顺序表删除的操作。

2.利⽤顺序表完成⼀个班级的⼀个学期的课程的管理:能够增加、删除、修改学⽣的成绩记录。

三、主要仪器设备PC机,Windows XP操作平台,Visual C++四、调试分析学⽣课程管理系统的调试过程中发现⼀些错误,主要是参数设置的问题,经过修改,错误得到排除。

五、测试结果1.顺序表2.学⽣课程管理系统附录(源程序)1.顺序表的操作#include#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int ElemType;#define LIST_INIT_SIZE 10 #define LISTINCREMENT 2 typedef struct shunxubiao{ElemType *list;int size;int Maxsize;}SqList;int InitList_Sq(SqList &L) {// 构造⼀个空的线性表L。

数据结构实验报告-线性表(顺序表实现)

数据结构实验报告-线性表(顺序表实现)

实验1:线性表(顺序表的实现)一、实验项目名称顺序表基本操作的实现二、实验目的掌握线性表的基本操作在顺序存储结构上的实现。

三、实验基本原理顺序表是由地址连续的的向量实现的,便于实现随机访问。

顺序表进行插入和删除运算时,平均需要移动表中大约一半的数据元素,容量难以扩充四、主要仪器设备及耗材Window 11、Dev-C++5.11五、实验步骤1.导入库和一些预定义:2.定义顺序表:3.初始化:4.插入元素:5.查询元素:6.删除元素:7.销毁顺序表:8.清空顺序表:9.顺序表长度:10.判空:11.定位满足大小关系的元素(默认小于):12.查询前驱:13.查询后继:14.输出顺序表15.归并顺序表16.写测试程序以及主函数对顺序表的每一个操作写一个测试函数,然后在主函数用while+switch-case的方式实现一个带菜单的简易测试程序,代码见“实验完整代码”。

实验完整代码:#include <bits/stdc++.h>using namespace std;#define error 0#define overflow -2#define initSize 100#define addSize 10#define compareTo <=typedef int ElemType;struct List{ElemType *elem;int len;int listsize;}L;void init(List &L){L.elem = (ElemType *) malloc(initSize * sizeof(ElemType)); if(!L.elem){cout << "分配内存失败!";exit(overflow);}L.len = 0;L.listsize = initSize;}void destroy(List &L){free(L.elem);L.len = L.listsize = 0;}void clear(List &L){L.len = 0;}bool empty(List L){if(L.len == 0) return true;else return false;}int length(List L){return L.len;}ElemType getElem(List L,int i){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}return L.elem[i - 1];}bool compare(ElemType a,ElemType b) {return a compareTo b;}int locateElem(List L,ElemType e) {for(int i = 0;i < L.len;i++){if(compare(L.elem[i],e))return i;}return -1;}int check1(List L,ElemType e){int idx = -1;for(int i = 0;i < L.len;i++)if(L.elem[i] == e)idx = i;return idx;}bool check2(List L,ElemType e){int idx = -1;for(int i = L.len - 1;i >= 0;i--)if(L.elem[i] == e)idx = i;return idx;}int priorElem(List L,ElemType cur_e,ElemType pre_e[]) {int idx = check1(L,cur_e);if(idx == 0 || idx == -1){string str = "";str = idx == 0 ? "无前驱结点" : "不存在该元素";cout << str;exit(error);}int cnt = 0;for(int i = 1;i < L.len;i++){if(L.elem[i] == cur_e){pre_e[cnt ++] = L.elem[i - 1];}}return cnt;}int nextElem(List L,ElemType cur_e,ElemType next_e[]){int idx = check2(L,cur_e);if(idx == L.len - 1 || idx == - 1){string str = "";str = idx == -1 ? "不存在该元素" : "无后驱结点";cout << str;exit(error);}int cnt = 0;for(int i = 0;i < L.len - 1;i++){if(L.elem[i] == cur_e){next_e[cnt ++] = L.elem[i + 1];}}return cnt;}void insert(List &L,int i,ElemType e){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}if(L.len >= L.listsize){ElemType *newbase = (ElemType *)realloc(L.elem,(L.listsize + addSize) * sizeof(ElemType));if(!newbase){cout << "内存分配失败!";exit(overflow);}L.elem = newbase;L.listsize += addSize;for(int j = L.len;j > i - 1;j--)L.elem[j] = L.elem[j - 1];L.elem[i - 1] = e;L.len ++;}void deleteList(List &L,int i,ElemType &e){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}e = L.elem[i - 1];for(int j = i - 1;j < L.len;j++)L.elem[j] = L.elem[j + 1];L.len --;}void merge(List L,List L2,List &L3){L3.elem = (ElemType *)malloc((L.len + L2.len) * sizeof(ElemType)); L3.len = L.len + L2.len;L3.listsize = initSize;if(!L3.elem){cout << "内存分配异常";exit(overflow);}int i = 0,j = 0,k = 0;while(i < L.len && j < L2.len){if(L.elem[i] <= L2.elem[j])L3.elem[k ++] = L.elem[i ++];else L3.elem[k ++] = L2.elem[j ++];}while(i < L.len)L3.elem[k ++] = L.elem[i ++];while(j < L2.len)L3.elem[k ++] = L2.elem[j ++];}bool visit(List L){if(L.len == 0) return false;for(int i = 0;i < L.len;i++)cout << L.elem[i] << " ";cout << endl;return true;}void listTraverse(List L){if(!visit(L)) return;}void partion(List *L){int a[100000],b[100000],len3 = 0,len2 = 0; memset(a,0,sizeof a);memset(b,0,sizeof b);for(int i = 0;i < L->len;i++){if(L->elem[i] % 2 == 0)b[len2 ++] = L->elem[i];elsea[len3 ++] = L->elem[i];}for(int i = 0;i < len3;i++)L->elem[i] = a[i];for(int i = 0,j = len3;i < len2;i++,j++) L->elem[j] = b[i];cout << "输出顺序表:" << endl;for(int i = 0;i < L->len;i++)cout << L->elem[i] << " ";cout << endl;}//以下是测试函数------------------------------------void test1(List &list){init(list);cout << "初始化完成!" << endl;}void test2(List &list){if(list.listsize == 0)cout << "线性表不存在!" << endl;else{int len;ElemType num;cout << "选择插入的元素数量:" << endl;cin >> len;cout << "依次输入要插入的元素:" << endl;for(int i = 1;i <= len;i++){cin >> num;insert(list,i,num);}cout << "操作成功!" << endl;}}void test3(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{cout << "请输入要返回的元素的下标" << endl;int idx;cin >> idx;cout << "线性表中第" << idx << "个元素是:" << getElem(L,idx) << endl;}}void test4(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{int idx;ElemType num;cout << "请输入要删除的元素在线性表的位置" << endl;cin >> idx;deleteList(L,idx,num);cout << "操作成功!" << endl << "被删除的元素是:" << num << endl; }}void test5(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{destroy(L);cout << "线性表已被销毁" << endl;}}void test6(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{clear(L);cout << "线性表已被清空" << endl;}}void test7(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else cout << "线性表的长度现在是:" << length(L) << endl;}void test8(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else if(empty(L))cout << "线性表现在为空" << endl;else cout << "线性表现在非空" << endl;}void test9(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num;cout << "请输入待判定的元素:" << endl;cin >> num;cout << "第一个与目标元素满足大小关系的元素的位置:" << locateElem(L,num) << endl;}}void test10(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num,num2[initSize / 2];cout << "请输入参照元素:" << endl;cin >> num;int len = priorElem(L,num,num2);cout << num << "的前驱为:" << endl;for(int i = 0;i < len;i++)cout << num2[i] << " ";cout << endl;}}void test11(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num,num2[initSize / 2];cout << "请输入参照元素:" << endl;cin >> num;int len = nextElem(L,num,num2);cout << num << "的后继为:" << endl;for(int i = 0;i < len;i++)cout << num2[i] << " ";cout << endl;}}void test12(List list){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{cout << "输出线性表所有元素:" << endl;listTraverse(list);}}void test13(){if(L.listsize == 0)cout << "初始线性表不存在!" << endl; else{List L2,L3;cout << "初始化一个新线性表" << endl;test1(L2);test2(L2);cout << "归并两个线性表" << endl;merge(L,L2,L3);cout << "归并成功!" << endl;cout << "输出合并后的线性表" << endl;listTraverse(L3);}}void test14(){partion(&L);cout << "奇偶数分区成功!" << endl;}int main(){std::ios::sync_with_stdio(false);cin.tie(0),cout.tie(0);int op = 0;while(op != 15){cout << "-----------------menu--------------------" << endl;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;cout << "--------------13:归并线性表-------------" << endl;cout << "--------------14:奇偶分区---------------" << endl;cout << "--------------15: 退出测试程序-----------" << endl;cout << "请输入指令编号:" << endl; if(!(cin >> op)){cin.clear();cin.ignore(INT_MAX,'\n');cout << "请输入整数!" << endl;continue;}switch(op){case 1:test1(L);break;case 2:test2(L);break;case 3:test3();break;case 4:test4();break;case 5:test5();break;case 6:test6();break;case 7:test7();break;case 8:test8();break;case 9:test9();break;case 10:test10();break;case 11:test11();break;case 12:test12(L);break;case 13:test13();break;case 14:test14();break;case 15:cout << "测试结束!" << endl;default:cout << "请输入正确的指令编号!" << endl;}}return 0;}六、实验数据及处理结果1.初始化:2.插入元素3.查询元素(返回的是数组下标,下标从0开始)4.删除元素(位置从1开始)5.销毁顺序表6.清空顺序表7.顺序表长度(销毁或清空操作前)8.判空(销毁或清空操作前)9.定位满足大小关系的元素(销毁或清空操作前)说明:这里默认找第一个小于目标元素的位置且下标从0开始,当前顺序表的数据为:1 4 2 510.前驱(销毁或清空操作前)11.后继(销毁或清空操作前)12.输出顺序表(销毁或清空操作前)13.归并顺序表(销毁或清空操作前)七、思考讨论题或体会或对改进实验的建议通过本次实验,我掌握了定义线性表的顺序存储类型,加深了对顺序存储结构的理解,进一步巩固和理解了顺序表的基本操作,如建立、查找、插入和删除等。

线性表的操作算法实验报告

线性表的操作算法实验报告

实验报告2013学年第一学期任课老师:2、在实验过程中遇到的问题与解决方法:问题有很多,比如局部变量与全局变量的声明,常常顾此失彼,此处概念仍然不清。

填写内容时,可把表格扩大。

附:实验源程序代码顺序表(链表):// 线性表(链表)#include <stdio.h>#include "malloc.h"#include <iostream>using namespace std;typedef struct LNode{int data;struct LNode *next;}LNode,*LinkList;//创建一个长度为n的链表void CreateList(LinkList &L, int n) {L = (LinkList)malloc(sizeof(LNode));L->next = NULL;for (int i=n; i>0; --i){LinkList p = (LinkList)malloc(sizeof(LNode));cin>>p->data;p->next = L->next;L->next = p;}}// 在链表L第i个元素之前插入元素eint ListInsert(LinkList &L, int i, int e) {LinkList p=L;int j=0;while(p&&j<i-1) {p=p->next; ++j;}if(!p ||j>i-1) return 0;LinkList s = (LinkList)malloc(sizeof(LNode)); s->data=e;s->next=p->next;p->next=s;return 1;}// 在链表L中删除第i个元素,并由e返回其值int ListDelete(LinkList &L, int i, int &e) { LinkList p=L;int j=0;while(p->next&&j<i-1) {p=p->next; ++j;}if(!(p->next)||j>i-1) return 0;LinkList q=p->next;p->next=q->next;e=q->data;free(q);cout<<"被删除的元素数据为"<<e<<"\n"; return 0;}//查找第i个元素,并由e返回其值int GetElem(LinkList &L,int i, int &e) {LinkList p=L->next;int j=1;while (p && j<i) {p=p->next; ++j;}if (!p||j>i) return 0;e=p->data;cout<<"该元素的值为"<<e<<"\n";return 1;}//让链表L中的元素按从小到大的顺序排列LinkList Sort(LinkList L){ LinkList p,q;int temp;for(p=L;p!=NULL;p=p->next){for(q=p->next;q!=NULL;q=q->next){if(p->data>q->data){temp=q->data;q->data=p->data;p->data=temp;}}}return L;}//归并L和La得到新的单链性表Lbvoid MergeList_L(LinkList &L,LinkList &La,LinkList &Lb) { LinkList p,pa,pb;p=L->next;pa=La->next;Lb=pb=L; //用L的头结点作为Lb的头结点while (p&&pa) {if (p->data<=pa->data) {pb->next=p;pb=p;p=p->next;}else {pb->next=pa;pb=pa;pa=pa->next;}}pb->next=p?p:pa;free(La);}int main(){LinkList L;int n,s,e,i,f,g,h;cout<<"输入链表长度n:";cin>>n;cout<<"请输入L中的元素:"<<endl;CreateList( L, n);cout<<"输入的链表为:"<<" ";LNode *q=L->next;while(q){cout<<q->data<<" ";q=q->next;} cout<<endl;int choice;cout<<"请选择功能:"<<endl;cout<<"1.插入元素"<<endl;cout<<"2.删除元素"<<endl;cout<<"3.查找元素"<<endl;cout<<"4.给元素排序"<<endl;cout<<"5.合并链表"<<endl;cout<<"0.退出程序"<<endl;cout<<"PS:若先排序再合并,可将得到新的排序后的合并链表。

数据结构实验报告-实验:1线性表的顺序存储和操作实现

数据结构实验报告-实验:1线性表的顺序存储和操作实现
System.exit(1);
}
for(inti=pos-1;i<length;i++)
if(listArray[i].equals(obj))returni+1;
return-1;
}
publicbooleanmodify(Object obj,intpos){
if(pos<1||pos>length){
List sort();
}
publicclasssequenceListimplementsList {
finalintmaxSize=10;
privateintlength;
privateObject[]listArray;
publicsequenceList(){//无参数的构造函数的定义
length=0;//线性表初始为空,即长度为0
System.out.println();
list2.preOrder();
System.out.println("线性表list2长度:"+list2.size());
}
}
publicinterfaceList {
Object value(intpos);
booபைடு நூலகம்eanadd(Object obj,intpos);
int[] a={20,16,38,42,29};
for(inti=0;i<a.length;i++) list1.add(a[i], i+1);
intn1=(Integer)list1.remove(2);
list1.add(80, 3);
intn2=(Integer)list1.value(4);

实验总结报告-线性表

实验总结报告-线性表

实验总结报告-线性表第一篇:实验总结报告-线性表实验总结报告—栈和队列学号:姓名:时间:一、目的 1.做实验的目的加深对线性表的理解,学会定义线性表的存储结构,掌握线性表的基本操作。

2.撰写实验报告的目的对本次实验情况进行总结,加强对实验内容的理解,对实验过程有一个系统的认识,从中获得本次试验的经验,并对实验结果进行适当的分析,加深对栈和队列的理解和认识。

二、内容1.说明实验次数及实验内容本次实验用一次实验课时完成实验内容:节点定义:typedef struct node{int idx;int age;struct node *next;}Node,*List;本次实验的对象的存储内容包括ID和AGE,所以定义了如上的结构体,idx用于存储ID 号,age用于存储年龄,next用于形成链式结构,Node定义了该类型的一个节点,List定义了该类型的一个链表。

(1)、编写函数CreateList()和PrintList(),从给定数组创建链表,打印链表。

int idx[8] = {1,2,3,4,5,6,7,8};int age[8] = {15,18,13,22,50,18,30,20};List CreatList(int idx[], int age[],int len){} int PrintList(List L){}(2)、编写函数DeleteNode(List L, int delete_age),完成以下操作。

int DeleteNodeAge(List L, int delete_age){} 该函数传入List L,可以直接修改链表的节点,建议返回值为int 或void类型,无需为List类型,3,4题同上。

2.1删除年龄为18的成员,打印链表。

2.2删除年龄为20的成员,打印链表。

2.3删除年龄为15的成员,打印链表。

2.4(可选)删除年龄为21的成员(因无此成员,报错),打印链表。

实验一线性表

实验一线性表

数据结构试验报告线性表学院:姓名:学号:时间:专业班级:线性表一、实验目的1.掌握线性结构中顺序表和链表的基本概念、基本操作和应用;2.掌握线性表的基本操作:建表、插入、删除、输出等运算在顺序存储结构和链式存储结构上的实现。

3.通过本次实习加深对高级语言C语言的使用(特别是函数参数、指针类型、链表的使用)。

熟悉线性表的基本运算在两种存储结构(顺序结构和链式结构)上的实现。

二、实验内容1.编写生成线性表的函数,线性表的元素从键盘输入,分别使用顺序和链式存储结构存储;2.编写在线性表中插入一个元素的函数;3.编写在线性表中删除一个元素的函数;4.编写输出线性表的函数;5.编写主函数,调用以上各函数,以便能观察出原线性表以及作了插入或删除后线性表的屏幕输出。

三、实验报告要求1.画出程序流程图并做简单分析2.源代码(包括主要结构、主要语句、函数注释说明)3.运行结果(包括程序如何使用,输入数据和输出结果)4.实验体会和问题分析四、基本原理(一)线性表是最常用的而且也是最简单的一种数据结构,线性表是N个数据元素的有限序列。

例如26个英文元素的字母表(A,B,C,D,···),其数据结构的描述为:Linear_list=(D,R)其中,D={ a i |a i属于ElemSet,i=1,2,3,···},R={<a i-1,a i>| i=2,3,4,…… }。

本实验是以数组的形式把线性表存放在计算机内存的一个连续的区域内,这样便有:LOC(a i+1)=LOC(a i)+mLOC(a i)=L0+m*(i-1)其中,m是存放每个元素所占的内存字数,L0是a的地址,即首地址。

(二)程序说明插入一个新元素到第i个位置,既把元素a i向后移一个位置,成为元素a i+1,把新元素放入到第i个位置,其他元素依次后移。

插入后的表长是n+1(n是原表长)。

实验一 线性表 实验报告

实验一 线性表 实验报告

数据结构实验报告实验名称:实验一线性表学生姓名:班级:班内序号:学号:日期:2012年11月3日1、实验要求据线性表的抽象数据类型的定义,选择下面任一种链式结构实现线性表,并完成线性表的基本功能。

线性表存储结构(五选一):1、带头结点的单链表2、不带头结点的单链表3、循环链表4、双链表5、静态链表线性表的基本功能:1、构造:使用头插法、尾插法两种方法2、插入:要求建立的链表按照关键字从小到大有序3、删除4、查找5、获取链表长度6、销毁7、其他:可自行定义编写测试main()函数测试线性表的正确性2、程序分析2.1存储结构单链表的存储结构2.2关键算法分析一:关键算法1:头插法自然语言描述:a:在堆中建立新结点b:将a[i]写入到新结点的数据域c:修改新结点的指针域d:修改头结点的指针域,并将新结点加入链表中伪代码描述:a:Node * s=new Node ;b:s->data=a[i] ;c:s->next=front->next;d:front->next=s;2:尾插法自然语言描述:a:在堆中建立新结点b:将a[i]写入到新结点的数据域c:将新结点加入到链表中d:修改尾指针伪代码描述:a:Node * s=new Node ;b:s->data=a[i] ;c:r->next=s;d:r=s;3:删除大于min小于max元素算法:自然语言描述:a:建立新结点b:保存第一个结点的位置c:执行循环,查找到p结点为第一个大于min小于max的元素,q为比min 大的前一个元素位置d:执行循环,查找到比max小的最后一个元素位置e:将上述两步骤中的满足条件的中间节点删掉f:将前后两条断链重新连接起来,连接p和q结点伪代码描述:a:Node *p,*q,*r;b: p=front->next;c:while(p&&p->data<=min){q=p;p=p->next;}d和e:while(p&&p->data<max) //找比max小的最后一个元素位置{r=p;p=p->next;delete r; //释放满足条件的结点}f: q->next=p;4:链表逆置算法自然语言描述:a:建立新结点b:判断链表是否为空表或者单结点链表c:将开始结点变成终端结点d:执行循环,使每次循环都将后一个结点变成开始结点e:遍历打印伪代码描述:a:Node *p,*q;b:if(front->next&&front->next->next)c: p=front->next;q=p->next;p->next=NULL;d:while(q){p=q; //每次循环将后一个结点变成起始结点q=q->next;p->next=front->next;front->next=p;}e: z=front->next;while(z) //遍历打印逆置后的序列{cout<<z->data<<"";z=z->next;}5.销毁函数自然语言描述:a:新建立一个指针,指向头结点b:判断要释放的结点是否存在c:暂时保存要释放的结点d:移动a中建立的指针e:释放要释放的指针伪代码描述:a:Node * p=frontb:while(p)c:front=pd:p=p->nexte:delete front6.按位查找函数(查找第i个元素的位置)自然语言描述:a:初始化工作指针p和计数器j,p指向第一个结点,j=1b:循环以下操作,直到p为空或者j等于1b1:p指向下一个结点b2:j加1c:若p为空,说明第i个元素不存在,抛出异常d:否则,说明p指向的元素就是所查找的元素,返回元素地址伪代码描述a:Node * p=front->next;j=1;b:while(p&&(j!=i))b1:p=p->nextb2:j++c:if(!p) throw ”查找位置有误”d:return p7:按位查找函数(查找值为x的元素并返回其位置)自然语言描述:a:初始化工作指针p和计数器j,p指向第一个结点,j=1b:循环以下操作,找到这个元素或者p指向最后一个结点b1:判断p指向的结点是不是要查找的值,如果是,返回j,否则p指向下一个结点,并且j的值加1c:如果找到最后一个结点还没有找到要查找的元素,返回查找失败信息伪代码描述:a:Node * p=front->next;j=1;b:while(p)b1: if(p->next==x)return j;p=p->next;j++ ;c:throw "找不到指定元素";8.插入函数自然语言描述:a:在堆中建立新结点b:将要插入的结点的数据写入到新结点的数据域c:修改新结点的指针域d:修改前一个指针的指针域,使其指向新插入的结点的位置伪代码描述:a:Node * s=new Node ;b:s-data=xc:s->next=p->nextd:p->next=s9.删除函数自然语言描述:a:从第一个结点开始,查找要删除的位数i前一个位置i-1的结点b:设q指向第i个元素c:将q元素从链表中删除d:保存q元素的数据e:释放q元素伪代码描述:a: if(i!=1)p=Get(i-1);b: q=p->nextc:p->next=q->nextd:x=q->datae:delete q10.遍历输出函数自然语言描述:a:判断该链表是否为空链表,如果是,报错b:如果不是空链表,新建立一个temp指针c:将temp指针指向头结点d:打印temp指针的data域e:逐个往后移动temp指针,直到temp指针指向的next域为空伪代码描述:a:If(front->next==NULL)cout<<"该链表为空链表!"<<endl;b和c:Node * temp=front->next;d和e:while(temp){cout<<temp->data<<"";temp=temp->next;}11.获取链表长度函数自然语言描述:a:判断该链表是否为空链表,如果是,输出长度0b:如果不是空链表,新建立一个temp指针,初始化整形数n为0c:将temp指针指向头结点d:判断temp指针是否为空,如果不是,n加1,否则return ne: 使temp指针逐个后移,重复d操作,直到temp指针指向的next域为0,返回n伪代码描述:a:int n=0;if(front->next==NULL) //如果为空链表{n=0;}b和c: else{Node * temp=front->next;d:while(temp){n++;e: temp=temp->next;}}return n;二、代码详细分析1、头插法关键代码:Node * s=new Node ;s->data=a[i] ;s->next=front->next;front->next=s;示意图:2、尾插法关键代码:Node * s=new Node ;s->data=a[i] ;r->next=s;r=s;示意图:3:删除大于min 小于max 元素算法:关键代码:Node *p,*q,*r,*s;p=front->next;while (p&&p->data<=min){q=p;p=p->next;} //此循环结束时,当前p 结点为第一个大于min 小于max 的元素,q 为比min 大的前一个元素位置while (p&&p->data<max) //找比max 小的最后一个元素位置{r=p;p=p->next;delete r; //释放满足条件的结点}q->next=p;流程图:4:链表逆置算法关键代码:Node *p,*q,*z;if (front->next&&front->next->next) //当链表不是空表或者单结点时{p=front->next;q=p->next;p->next=NULL; //将开始结点变成终端结点while(q){p=q; //每次循环将后一个结点变成起始结点q=q->next;p->next=front->next;front->next=p;}}流程图:5、查找算法关键代码:Node *p=front->next;int j=1;while(p&&(j!=i)) //i=1时循环体不执行{p=p->next;j++;}if(!p) throw"查找位置有误";elsereturn p;流程图:六、删除算法关键代码:Node *p=front;if (i!=1)p=Get(i-1); //查到第i-1个元素的地址Node *q=p->next;p->next=q->next;int x=q->data;delete q;return x;流程图:三、关键算法的时间、空间复杂度头插法/尾插法 O(n)按位查找/按值查找 O(n)插入操作 O(n)逆置操作 O(n)删除大于min小于max操作o(n)2.3其他函数中的按值查找可以修改,把终止条件改为直到指向的结点的next域为空,返回多个地址,那么在链表中如果存在多个待找元素都可以返回。

数据结构实验一实验报告——线性表

数据结构实验一实验报告——线性表

实验报告课程名称:数据结构实验名称:线性表班级:学生姓名:学号:指导教师评定:签名:题目:有两张非递增有序的线性学生表A,B,采用顺序存储结构,两张表合并用c表存,要求C为非递减有序的,然后删除C表中值相同的多余元素。

一、需求分析⒈本演示程序根据已有的两张表的信息,实现两张表的合并及删除值相同元素的操作,需要用户输入学生的信息。

⒉在演示过程序中,用户输入需要合并的顺序表,即可观看合并结果。

⒊程序执行的命令包括:(1)构造线性表A (2)构造线性表B (3)求两张表的并(4)删除C中值相同的元素二、概要设计⒈为实现上述算法,需要线性表的抽象数据类型:ADT Stack {数据对象:D={a i:|a i∈ElemSet,i=1…n,n≥0}数据关系:R1={<a i-1,a i>|a i-1,a i∈D,i=2,…n≥0}基本操作:init(list *L)操作结果:构造一个空的线性表L。

ListLength(List *L)初始条件:线性表L已经存在操作结果:返回L中数据元素的个数。

GetElem(List L, int i, ElemType *e)初始条件:线性表L已经存在,1≤i≤ListLength(&L)操作结果:用e返回L中第i个数据元素的值。

EqualList(ElemType *e1,ElemType *e2)初始条件:数据元素e1,e2存在操作结果:以e1,e2中的姓名项作为判定e1,e2是否相等的依据。

Less_EquaList(ElemType *e1,ElemType *e2)初始条件:数据元素e1,e2存在操作结果:以e1,e2中的姓名项(为字符串)的≤来判定e1,e2是否有≤的关系。

LocateElem(List *La,ElemType e,int type)初始条件:线性表La已经存在操作结果:判断La中是否有与e相同的元素。

MergeList(List *La,List *Lb,List *Lc)初始条件:非递减线性表La,Lb已经存在操作结果:合并La,Lb得到Lc,Lc仍按非递减有序排列。

线性表实验报告

线性表实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

实验报告_线性表

实验报告_线性表

电子科技大学实验报告课程名称:数据结构与算法学生姓名:学号:点名序号:指导教师:实验地点:基础实验大楼实验时间:4月3日2014-2015-2学期信息与软件工程学院实验报告(一)学生姓名:学号:指导教师:实验地点:基础实验大楼实验时间:4月3日一、实验室名称:软件实验室二、实验项目名称:数据结构与算法—线性表的实现三、实验学时:4四、实验原理:在链式存储结构中,存储数据结构的存储空间可以不连续,各数据结点的存储顺序与数据元素之间的逻辑关系可以不一致,而数据元素之间的逻辑关系是由指针域来确定的。

链式存储方式即可以用于表示线性结构,也可用于表示非线性结构。

一般来说,在线性表的链式存储结构中,各数据结点的存储符号是不连续的,并且各结点在存储空间中的位置关系与逻辑关系也不一致。

对于线性链表,可以从头指针开始,沿各结点的指针扫描到链表中的所有结点。

线性表的链接存储中,为了方便在表头插入和删除结点的操作,经常在表头结点(存储第一个元素的结点)的前面增加一个结点,称之为头结点或表头附加结点。

这样原来的表头指针由指向第一个元素的结点改为指向头结点,头结点的数据域为空,头结点的指针域指向第一个元素的结点。

五、实验目的:本实验通过定义单向链表的数据结构,设计创建链表、插入结点、遍历结点等基本算法,使学生掌握线性链表的基本特征和算法,并能熟练编写C 程序,培养理论联系实际和自主学习的能力,提高程序设计水平。

六、实验内容:使用数据结构typedef struct node {Elemtype data;struct node *next;} ListNode, *ListPtr;typedef struct stuInfo {char stuName[10]; /*学生姓名*/int Age /*年龄*/} ElemType实现带头结点的单向链表的创建、删除链表、插入结点等操作,并能实现年龄递增的两个单向链表合并一个链表,合并后的链表按年龄递减,可认为同名同年龄是同一个学生,每个学生在合并后的链表中仅出现一次。

数据结构实验报告(一)线性表的应用

数据结构实验报告(一)线性表的应用

数据结构实验报告(⼀)线性表的应⽤实验说明数据结构实验⼀ 线性表的实验——线性表的应⽤⼀、实验⽬的通过本实验使学⽣了解线性表的⼀种简单应⽤,熟悉线性表顺序存储与链式存储的特性,特别训练学⽣编程灵活控制链表的能⼒,为今后编程控制更为复杂的数据结构奠定基础。

⼆、实验内容1.⽤顺序表和链表分别分别编程实现教材中例⼦2-1与2-2。

要求:(1)只能⽤C语⾔编程实现;(2)完全保持书中算法2.1与算法2.2形式,不允许有任何变化,除⾮语法上不允许;所调⽤各函数参照书中19页的功能描述,其中函数名、参数个数及性质、函数功能必须与书中完全⼀致,不能有变化。

2.利⽤线性表表⽰⼀元多项式完成多项式的加、减、乘、求导、求值运算。

要求:(1)输⼊的⼀元多项式可以采⽤只输⼊各项的系数与指数这种简化的⽅式。

如对于多项式2x2+6x5,输⼊可为: 2,2 6,5 这样的简单形式。

(2)遇到有消项时应当处理,如2x2+6x5与3x2-6x5进⾏相加时,结果为5*x^2。

(3)当给定x的值时,能计算表达式相加或相减的结果。

(4)操作的结果放⼊⼀个新线性表中,原来的两个表达式存储表⽰不变,也可以不是产⽣新的线性表,⽽是将两上线性表合并为⼀个。

(5)要求程序功能模块划分合理(每个函数功能单⼀、可重⽤性好),使⽤空间尽可能少,算法尽可能⾼效。

实验报告1.实现功能描述使⽤线性表表⽰⼀元多项式完成多项式的加、减,乘,求导、求值运算。

2.⽅案⽐较与选择(1)因为使⽤的是线性表,所以主要⽅案有数组法和链表法。

(2)从时间复杂度来说,使⽤数组法更优;从空间复杂度来说,链表法更优。

因为数组法是指定好空间的,若式⼦⼤⼩超出设置⼤⼩,那程序必然出错;若式⼦⼤⼩⼩于设置⼤⼩,那就意味着有多余的空间被浪费了。

综合来讲,若计算式⼦较为庞⼤,使⽤链表法更佳;相反,若计算式⼦较⼩,数组法更佳。

3.设计算法描述(1)单个项式的数据存储使⽤了结构体,数组法是在⼀个结构体中定义两个⼀维数组;链表法是通过⼀个结构体作为⼀个节点,通过next指针连接起来。

数据结构实验一题目一线性表实验报告

数据结构实验一题目一线性表实验报告

数据结构实验报告实验名称:实验1——线性表学生姓名:班级:班内序号:学号:日期:1.实验要求1、实验目的:熟悉C++语言的基本编程方法,掌握集成编译环境的调试方法学习指针、模板类、异常处理的使用掌握线性表的操作的实现方法学习使用线性表解决实际问题的能力2、实验内容:题目1:线性表的基本功能:1、构造:使用头插法、尾插法两种方法2、插入:要求建立的链表按照关键字从小到大有序3、删除4、查找5、获取链表长度6、销毁7、其他:可自行定义编写测试main()函数测试线性表的正确性。

2. 程序分析存储结构带头结点的单链表关键算法分析1.头插法a、伪代码实现:在堆中建立新结点将x写入到新结点的数据域修改新结点的指针域修改头结点的指针域,将新结点加入链表中b、代码实现:Linklist::Linklist(int a[],int n)堆中建立新结点b.将a[i]写入到新结点的数据域c.将新结点加入到链表中d.修改修改尾指针b、代码实现:Linklist::Linklist(int a[],int n,int m)取链表长度函数a、伪代码实现:判断该链表是否为空链表,如果是,输出长度0如果不是空链表,新建立一个temp指针,初始化整形数n为0将temp指针指向头结点判断temp指针指向的结点的next域是否为空,如果不是,n加一,否则return n使temp指针逐个后移,重复d操作,直到temp指针指向的结点的next域为0,返回nb 、代码实现void Linklist::Getlength()Linklist();cout<<endl;}3. 程序运行结果1.测试主函数流程:2、运行结果4. 总结调试时出现的问题及解决的方法:在设计将x按顺序插入的函数时,没有分清p->next->next->data和 p->next->data的区别,通过认真查阅和理解书本知识解决。

实验一线性表操作实验报告

实验一线性表操作实验报告

实验一_线性表操作_实验报告实验一:线性表操作一、实验目的1.理解线性表的基本概念和特点。

2.掌握线性表的基本操作,包括插入、删除、查找等。

3.通过实验,提高动手能力和解决问题的能力。

二、实验原理线性表是一种较为常见的数据结构,它包含零个或多个数据元素,相邻元素之间有前后关系。

线性表具有以下特点:1.元素之间一对一的顺序关系。

2.除第一个元素外,每个元素都有一个直接前驱。

3.除最后一个元素外,每个元素都有一个直接后继。

常见的线性表有数组、链表等。

本实验主要针对链表进行操作。

三、实验步骤1.创建链表:首先创建一个链表,并给链表添加若干个节点。

节点包括数据域和指针域,数据域存储数据,指针域指向下一个节点。

2.插入节点:在链表中插入一个新的节点,可以选择在链表的头部、尾部或中间插入。

3.删除节点:删除链表中的一个指定节点。

4.查找节点:在链表中查找一个指定数据的节点,并返回该节点的位置。

5.遍历链表:从头节点开始,依次访问每个节点的数据。

四、实验结果与分析1.创建链表结果:我们成功地创建了一个链表,每个节点都有数据域和指针域,数据域存储数据,指针域指向下一个节点。

2.插入节点结果:我们成功地在链表的头部、尾部和中间插入了新的节点。

插入操作的时间复杂度为O(1),因为我们只需要修改指针域即可。

3.删除节点结果:我们成功地删除了链表中的一个指定节点。

删除操作的时间复杂度为O(n),因为我们可能需要遍历整个链表才能找到要删除的节点。

4.查找节点结果:我们成功地在链表中查找了一个指定数据的节点,并返回了该节点的位置。

查找操作的时间复杂度为O(n),因为我们可能需要遍历整个链表才能找到要查找的节点。

5.遍历链表结果:我们成功地遍历了整个链表,并访问了每个节点的数据。

遍历操作的时间复杂度为O(n),因为我们可能需要遍历整个链表。

通过本次实验,我们更加深入地理解了线性表的基本概念和特点,掌握了线性表的基本操作,包括插入、删除、查找等。

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

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

数据结构线性表实验报告五篇第一篇:数据结构线性表实验报告实验报告课程名:数据结构实验名:线性表及其操作姓名:班级:学号:撰写时间: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:实验结果截图实验分析:已在程序中按规定格式标注。

实验一-线性表操作-实验报告

实验一-线性表操作-实验报告

中国矿业大学计算机学院实验报告{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  线性表的基本操作

实验一线性表的基本操作一、实验目的(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 线性表及其应用 实验报告

实验1 线性表及其应用一、实验目的和要求:1.加深对线性表的结构特性的理解,熟练掌握单链表类的描述方法及其C++实现;2.掌握线性表的链式存储结构的应用;3.加强对算法的设计能力和程序调试能力的培养。

二、实验时间:2010-3-26三、实验内容:约瑟夫(Joseph)环问题1.问题描述:编号为1,2,…,n的n个人按顺时针方向围坐一圈,从1起报到k则出圈,下一个人再从1报起,如此下去直到圈中只有一人为止。

求最后剩下的人的编号。

2.数据结构设计:(包括类型设计和类的设计)编号为1,2,…,n的n个人可用线性表结构表示,因是围坐一圈,故可采用循环链表(不带表头结点)结构存储。

(1)结点结构定义template<class T>struct Node //定义链表结点结构{T data;Node<T>*link;Node(T e=-1,Node<T>*next=NULL):data(e),link(next){ }};(2)单循环链类设计template<class T>class LinkList //不带表头结点的单循环链类{ private:Node<T> *current,*front; //链表指针,front指向current的前驱结点public:LinkList(int mSize); //构造函数~LinkList(); //析构函数int RemoveCurrent(); //删除current所指结点void movenext(int n); //current后移n次T CurrentData(){return current->data;}bool toLocatioin(T &t); //将current指向元素为t的结点 void Output() const ; //输出链表}; // Class LinkList(3)Joseph类定义template<class T>class Joseph{ private:int numOfBoy;int startPosition;int Interval;public:Joseph(int boys=10,int start=1,int m=3): numOfBoy(boys), startPosition(start), Interval(m){ }int GetWinner();};// Joseph类3.算法设计:(主要包括算法原理、算法流程图、实现等)(1)单循环链类的算法(2)约瑟夫报数出圈算法:设计一个循环链表和一个报数器k,从current所指结点开始报数。

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

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

数据结构实验报告1线性表的顺序存储结构一、实验目的本次实验的主要目的是深入理解线性表的顺序存储结构,并通过编程实现其基本操作,包括创建线性表、插入元素、删除元素、查找元素以及输出线性表等。

通过实际操作,掌握顺序存储结构的特点和优势,同时也了解其在不同情况下的性能表现。

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

三、实验原理1、线性表的定义线性表是由 n(n≥0)个数据元素组成的有限序列。

在顺序存储结构中,线性表的元素存储在一块连续的存储空间中,通过数组来实现。

2、顺序存储结构的特点存储密度高,无需额外的指针来表示元素之间的关系。

可以随机访问表中的任意元素,时间复杂度为 O(1)。

插入和删除操作需要移动大量元素,平均时间复杂度为 O(n)。

四、实验内容及步骤1、定义线性表的数据结构```cppdefine MAX_SIZE 100 //定义线性表的最大长度typedef struct {int dataMAX_SIZE; //存储线性表元素的数组int length; //线性表的当前长度} SeqList;```2、初始化线性表```cppvoid InitList(SeqList L) {L>length = 0; //初始时线性表长度为 0}```3、判断线性表是否为空```cppbool ListEmpty(SeqList L) {return (Llength == 0);}```4、求线性表的长度```cppint ListLength(SeqList L) {return Llength;}```5、按位查找操作```cppint GetElem(SeqList L, int i) {if (i < 1 || i > Llength) {printf("查找位置不合法!\n");return -1;}return Ldatai 1;}```6、按值查找操作```cppint LocateElem(SeqList L, int e) {for (int i = 0; i < Llength; i++){if (Ldatai == e) {return i + 1;}}return 0; //未找到返回 0}```7、插入操作```cppbool ListInsert(SeqList L, int i, int e) {if (L>length == MAX_SIZE) {//表已满printf("表已满,无法插入!\n");return false;}if (i < 1 || i > L>length + 1) {//插入位置不合法printf("插入位置不合法!\n");return false;}for (int j = L>length; j >= i; j) {//移动元素L>dataj = L>dataj 1;}L>datai 1 = e; //插入元素L>length++;//表长加 1return true;}```8、删除操作```cppbool ListDelete(SeqList L, int i) {if (L>length == 0) {//表为空printf("表为空,无法删除!\n");return false;}if (i < 1 || i > L>length) {//删除位置不合法printf("删除位置不合法!\n");return false;}for (int j = i; j < L>length; j++){//移动元素L>dataj 1 = L>dataj;}L>length; //表长减 1return true;}```9、输出线性表```cppvoid PrintList(SeqList L) {for (int i = 0; i < Llength; i++){printf("%d ", Ldatai);}printf("\n");}```10、测试用例```cppint main(){SeqList L;InitList(&L);ListInsert(&L, 1, 10);ListInsert(&L, 2, 20);ListInsert(&L, 3, 30);ListInsert(&L, 4, 40);ListInsert(&L, 5, 50);printf("线性表的长度为:%d\n", ListLength(L));printf("查找第 3 个元素:%d\n", GetElem(L, 3));int loc = LocateElem(L, 30);if (loc) {printf("元素 30 的位置为:%d\n", loc);} else {printf("未找到元素 30\n");}ListDelete(&L, 3);printf("删除第 3 个元素后的线性表:");PrintList(L);return 0;}```五、实验结果及分析1、实验结果成功创建并初始化了线性表。

线性表的基本操作实验报告

线性表的基本操作实验报告

实验一:线性表的基本操作【实验目的】学习掌握线性表的顺序存储结构、链式存储结构的设计与操作。

对顺序表建立、插入、删除的基本操作,对单链表建立、插入、删除的基本操作算法。

【实验内容】1.顺序表的实践1) 建立4个元素的顺序表s=sqlist[]={1,2,3,4,5},实现顺序表建立的基本操作。

2) 在sqlist []={1,2,3,4,5}的元素4和5之间插入一个元素9,实现顺序表插入的基本操作。

3) 在sqlist []={1,2,3,4,9,5}中删除指定位置(i=5)上的元素9,实现顺序表的删除的基本操作。

2.单链表的实践3.1) 建立一个包括头结点和4个结点的(5,4,2,1)的单链表,实现单链表建立的基本操作。

2) 将该单链表的所有元素显示出来。

3) 在已建好的单链表中的指定位置(i=3)插入一个结点3,实现单链表插入的基本操作。

4) 在一个包括头结点和5个结点的(5,4,3,2,1)的单链表的指定位置(如i=2)删除一个结点,实现单链表删除的基本操作。

5) 实现单链表的求表长操作。

【实验步骤】1.打开VC++。

:点File->New,选Project标签,在列表中选Win32 Console Application,再在右边的框里为工程起好名字,选好路径,点OK->finish。

至此工程建立完毕。

:点File->New,选File标签,在列表里选C++ Source File。

给文件起好名字,选好路径,点OK。

至此一个源文件就被添加到了刚创建的工程之中。

4.写好代码5.编译->链接->调试1、#include "stdio.h"#include "malloc.h"#define OK 1#define OVERFLOW -2#define ERROR 0#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef int ElemType;typedef int Status;typedef struct {ElemType *elem;int length;int listsize;} SqList;Status InitList( SqList &L ) {int i,n;L.elem = (ElemType*) malloc (LIST_INIT_SIZE*sizeof (ElemType));if (!L.elem) return(OVERFLOW);printf("输入元素的个数:");scanf("%d",&n);printf("输入各元素的值:");for(i=0;i<n;i++)scanf("%d",&L.elem[i]);L.length = n;L.listsize = LIST_INIT_SIZE;return OK;}Status ListInsert(SqList &L, int i, ElemType e) {ElemType *newbase,*p,*q;gth+1) return ERROR;if (L.length >= L.listsize) {newbase = (ElemType *)realloc(L.elem, (L.listsize+LISTINCREMENT)*sizeof(ElemType));if (!newbase) return(OVERFLOW);L.elem = newbase;L.listsize += LISTINCREMENT;}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;}void VisitList(SqList L){ int i;for(i=0;i<L.length;i++)printf("%d\t",L.elem[i]);}void main(){int i,e;SqList L;InitList(L) ;VisitList(L);printf("输入插入位置和值:");scanf("%d,%d",&i,&e);printf("插入元素后,表中的值:"); ListInsert(L,i,e);VisitList(L);printf("输入删除位置:");scanf("%d",&i);printf("删除元素后,表中的值:"); ListDelete(L,i,e);VisitList(L);}2、#include "stdio.h"#include "malloc.h"#define OK 1#define OVERFLOW -2#define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 typedef int ElemType;typedef int Status;typedef struct {ElemType *elem;int length;int listsize;} SqList;Status InitList( SqList &L ) { int i,n;L.elem = (ElemType*) malloc (LIST_INIT_SIZE*sizeof (ElemType)); if (!L.elem) return(OVERFLOW);printf("输入元素的个数:");scanf("%d",&n);printf("输入各元素的值:");for(i=0;i<n;i++)scanf("%d",&L.elem[i]);L.length = n;L.listsize = LIST_INIT_SIZE;return OK;}void VisitList(SqList L){ int i;for(i=0;i<L.length;i++)printf("%d\t",L.elem[i]);}void main(){SqList L;InitList(L) ;VisitList(L);}3、#include "stdio.h"#include "malloc.h"#define OK 1#define OVERFLOW -2#define ERROR 0typedef int Status;typedef int ElemType;typedef struct LNode {ElemType data;struct LNode *next;} LNode,*LinkList;Status ListInsert(LinkList &L,int i,ElemType e){ LinkList p,s;int j;p=L;j=0;while(p&&j<i-1) {p=p->next;++j;}if(!p||j>i) return ERROR;s=(LinkList)malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s;return OK;}Status ListDelete(LinkList &L,int i,ElemType &e){ LinkList p,q;int j;p=L;j=0;while(p->next&&j<i-1){p=p->next;++j;}if(!(p->next)||j>i-1) return ERROR;q=p->next;p->next=q->next;e=q->data;free(q);return OK;}Status CreateList(LinkList &L, int n) {int i;LinkList p;L = (LinkList) malloc (sizeof (LNode));L->next = NULL;printf("输入元素的个数和相应值:");scanf("%d",&n);for (i = n; i > 0; --i) {p = (LinkList) malloc (sizeof (LNode));//生成新结点 scanf("%d",&p->data);//输入指针p指出i=n时所对应的数值 p->next = L->next;L->next = p;}return OK;}void VisitList(LinkList L){LNode *p;p=L->next;while(p){printf("%d\t",p->data);p=p->next;}}void main(){int i,n;LinkList L;ElemType e;CreateList(L,n);VisitList(L);printf("输入插入位置和值:");scanf("%d,%d",&i,&e);printf("插入元素后,表中的值:");ListInsert(L,i,e);VisitList(L);printf("输入删除位置:");scanf("%d",&i);printf("删除元素后,表中的值:");ListDelete(L,i,e);VisitList(L);}【实验心得】今天是本学期的第一次上机实验课,老师先给我们发了本次上机的内容以及部分实验代码,因为是第一次接触这门课程,还没有理解这门学科的特点和学习方法,所以同学们都觉得无从下手。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
LNode *p,*q;p=L->next;
while(p&&p->data!=e)
{q=p;p=p->next;}
if(!p) return ERROR;
else
{
q->next=p->next;free(p);
return OK;
}
}
int main(){
int n,i;ElemType e;
LinkList L=NULL; /*定义指向单链表的指针*/
查找算法代码:
int ListLocate(Sqlist *L,ElemType e){
for(int i=1; i<=L->length;i++)
{if(L->slist[i-1]==e)
return i;
return 0; }}
运行结果
算法分析
当在主函数里面调用查找功能函数并传参数进去时,程序将自动跳到函数体里面,利用所传参数一步步执行,在该函数里面,当把顺序表和要查找的值e传值进去时,程序开始从顺序表第一个元素开始依次遍历,直到找到值为e的元素,并返回其位置序号,查找成功。若遍历了顺序表所有元素依然没有符合条件的e的值,则返回0,表示查找失败。
实验步骤
1、阅读下面程序,在横线处填写函数的基本功能。并运行程序,写出结果。
#include<stdio.h>
#include<malloc.h>
#define ERROR 0
#define OK 1
#define INIT_SIZE 5 /*初始分配的顺序表长度*/
#define INCREM 5 /*溢出时,顺序表长度的增量*/
int i;
for(i=1;i<=L->length;i++)
printf("%5d",L->slist[i-1]);
return OK;
}/*PrintList*/
int ListInsert_sq(Sqlist *L,int i,ElemType e){
int k;
if(i<1||i>L->length+1)
ListDelete_sq(&sl,m);
printf("\n4-Print Sqlist\n");
PrintList_sq(&sl);
printf("\nplease input data data\n");
scanf("%d",&m);
ListLocate(&sl,m);
printf("\n5-Print Sqlist\n");
}
if(!p||j>i)
return ERROR;
*e=p->data;
return OK;
}/*GetElem*/
int InsertList(LinkList L,int i,ElemType e){
int j=1; LNode *p,*q; p=L->next;
while(p&&j<i-1){
scanf("%d",&q->data); /*输入元素值*/
q->next=NULL; /*结点指针域置空*/
p->next=q; /*新结点连在表末尾*/
p=q;
}
return head;
}/*CreateList*/
void PrintList(LinkList L){
LNode *p;
p=L->next; /*p指向单链表的第1个元素*/
p=p->next;j++;}
if(!p) return ERROR;
q=(LNode *)malloc(sizeof(LNode));
q->data=e; q->next=p->next; p->next=q;
return OK;
}
int DeleteList(LinkList L,ElemType e){
3、阅读下面程序,在横线处填写函数的基本功能。并运行程序,写出结果。
#include<stdio.h>
#include<malloc.h>
#define ERROR 0
#define OK 1
typedef int ElemType; /*定义表元素的类型*/
typedef struct LNode{ /*线性表的单链表存储*/
2、为第1题补充删除和查找功能函数,并在主函数中补充代码验证算法的正确性。
删除算法代码:
int ListDelete_sq(Sqlist *L,int i){
if (L->length==0) return 0;
if(i<1||i>L->length) return 0;
for(int j=i;j<L->length;j++)
}
for(k=L->length-1;k>=i-1;k--){
L->slist[k+1]= L->slist[k];
}
L->slist[i-1]=e;
L->length++;
return OK;
}/*ListInsert*/
/*在顺序表中删除第i个元素*/
int ListDelete_sq(Sqlist *L,int i){
if(!L->slist) return ERROR;
L->length=0;
L->listsize=INIT_SIZE;
return OK;
}/*InitList*/
int CreateList_sq(Sqlist *L,int n){
ElemType e;
int i;
for(i=0;i<n;i++){
LinkList CreateList(int n){
LNode *p,*q,*head;
int i;
head=(LinkList)malloc(sizeof(LNode)); head->next=NULL;
p=head;
for(i=0;i<n;i++){
q=(LinkList)malloc(sizeof(LNode)); printf("input data %i:",i+1);
while(p!=NULL){
printf("%5d",p->data);
p=p->next;
}
}/*PrintList*/
int GetElem(LinkList L,int i,ElemType *e){
LNode *p;int j=1;
p=L->next;
while(p&&j<i){
p=p->next;j++;
printf("please input n:"); /*输入单链表的元素个数*/
int ListDelete_sq(Sqlist *L,int i); /*删除第i个元素*/
int ListLocate(Sqlist *L,ElemType e); /*查找值为e的元素*/
int InitList_sq(Sqlist *L){
L->slist=(ElemType*)malloc(INIT_SIZE*sizeof(ElemType));
int CreateList_sq(Sqlist *L,int n); /*创建一个顺序表*/
int ListInsert_sq(Sqlist *L,int i,ElemType e);/*将新元素e插入到顺序表第i个位置*/
int PrintList_sq(Sqlist *L); /*输出顺序表的元素*/
printf("input data %d",i+1);
scanf("%d",&e);
if(!ListInsert_sq(L,i+1,e))
return ERROR;
}
return OK;
}/*CreateList*/
/*输出顺序表中的元素*/
int PrintList_sq(Sqlist *L){
课程实验报告
专业年级2012级软件工程
课程名称数据结构C语言描述
指导教师申红婷
学生姓名王晓霞
学号20122205041002
实验日期2012.10.31
实验地点A3笃行楼A栋306
实验成绩
教务处制
2013年10月31日
实验项目
名称
线性表实验
实验
目的及要求
一.目的:
1.使学生对线性表的顺序存储结构、基本操作和应用,能通过实验达到掌握和应用的目的。
2.使学生对线性表的线性表的链式结构、基本操作和应用,能通过实验达到掌握和应用的目的。
二.要求:
实验前认真预习实验内容。实验时自觉遵守课堂纪律,严格按操作规程操作,既要独立操作又要与其他同学配合,在实验过程中必须按照实验内容认真做完实验,并认真填写相关实验报告。
实验
内容
线性表的顺序存储结构和线性表的链式结构、基本操和应用。
return ERROR;
if(L->length>=L->listsize){
相关文档
最新文档