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

实验报告实验一线性表实验目的:1. 理解线性表的逻辑结构特性;2. 熟练掌握线性表的顺序存储结构的描述方法,以及在该存储结构下的基本操作;并能灵活运用;3. 熟练掌握线性表的链表存储结构的描述方法,以及在该存储结构下的基本操作;并能灵活运用;4•掌握双向链表和循环链表的的描述方法,以及在该存储结构下的基本操作。
实验原理:线性表顺序存储结构下的基本算法;线性表链式存储结构下的基本算法;实验内容:2 - 21设计单循环链表,要求:(1 ) 单循环链表抽象数据类型包括初始化操作、求数据元素个数操作、插入操作、删除操作、取消数据元素操作和判非空操作。
(2 ) 设计一个测试主函数,实际运行验证所设计单循环链表的正确性。
2 — 22 .设计一个有序顺序表,要求:(1 ) 有序顺序表的操作集合有如下操作:初始化、求数据元素个数、插入、删除和取数据元素。
有序顺序表与顺序表的主要区别是:有序顺序表中的数据元素按数据元素值非递减有序。
(2 ) 设计一个测试主函数,实际运行验证所设计有序顺序表的正确性。
(3) 设计合并函数ListMerge ( L1,L2,L3 ),功能是把有序顺序表 L1和L2中的数据元素合并到L3,要求L3中的数据元素依然保持有序。
并设计一个主函数,验证该合并函数的正确性。
程序代码:2-21 (1)头文件 LinList.h 如下:typedef struct node{DataType data;struct node *next;}SLNode;/* ( 1 )初始化 ListInitiate(SLNode * * head)*/void ListInitiate(SLNode * * head){ /* 如果有内存空间,申请头结点空间并使头指针 head 指向头结点 */if((*head=(SLNode *)malloc(sizeof(SLNode)))==NULL)exit(1);(*head)->next=NULL; /* 置结束标记 NULL*/}/*(2) 求当前数据元素个数 ListLength(SLNode * head)*/int ListLength(SLNode * head){SLNode *p=head;int size=0;while(p->next!=head){p=p->next;size++;}return size;}/*(3) 插入 ListInsert(SLNode * head , int i , DataType x)*//* 在带头结点的单链表的第 i(0<=i<=size) 个结点前 *//* 插入一个存放数据元素 x 的结点。
数据结构实验报告-线性表(顺序表实现)

实验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.归并顺序表(销毁或清空操作前)七、思考讨论题或体会或对改进实验的建议通过本次实验,我掌握了定义线性表的顺序存储类型,加深了对顺序存储结构的理解,进一步巩固和理解了顺序表的基本操作,如建立、查找、插入和删除等。
数据结构上机实验报告

else insert(lc,i/2,la.list[i]); //偶数位次元素插入lc
}
printf("\n您输入的线性表元素为:\n\n");
print(la);
printf("线性表的奇数位次的元素为:\n\n");
print(lb);
printf("线性表的偶数位次的元素为:\n\n");
print(lc);
}
void initial(sqlist &v)
{printf(" ****本程序可以实现线性表奇偶位序的元素分别输出****\n\n\n");
int i,a;
printf("请输入一个偶数作为线性表的长度:\n\n");
void initlist(sqlist &);
void print(sqlist); //输出线性表
void main()
{printf(" *****************本程序可以实现线性表的复制******************\n");
sqlist la,lb; //声明线性表
initial(la);
【程序设计细想】:
建立三个线性表la,lb,lc,对线性表la进行输入,然后利用循环结构对la中奇数位序的元素对lb进行插入操作,对偶数位序的元素对lc进行插入操作,从而得到线性表lb和lc。
【程序代码】:
#include<stdio.h>
#include<malloc.h>
数据结构实验一题目一线性表实验报告

数据结构实验报告实验名称:实验1——线性表学生:班级:班序号:学号:日期:1.实验要求1、实验目的:熟悉C++语言的基本编程方法,掌握集成编译环境的调试方法学习指针、模板类、异常处理的使用掌握线性表的操作的实现方法学习使用线性表解决实际问题的能力2、实验容:题目1:线性表的基本功能:1、构造:使用头插法、尾插法两种方法2、插入:要求建立的链表按照关键字从小到大有序3、删除4、查找5、获取链表长度6、销毁7、其他:可自行定义编写测试main()函数测试线性表的正确性。
2. 程序分析2.1 存储结构带头结点的单链表2.2 关键算法分析1.头插法a、伪代码实现:在堆中建立新结点将x写入到新结点的数据域修改新结点的指针域修改头结点的指针域,将新结点加入链表中b、代码实现:Linklist::Linklist(int a[],int n)//头插法{front=new Node;front->next=NULL;for(int i=n-1;i>=0;i--){Node*s=new Node;s->data=a[i];s->next=front->next;front->next=s;}}2、尾插法a、伪代码实现:a.在堆中建立新结点b.将a[i]写入到新结点的数据域c.将新结点加入到链表中d.修改修改尾指针b、代码实现:Linklist::Linklist(int a[],int n,int m)//尾插法{front=new Node;Node*r=front;for(int i=0;i<n;i++){Node*s=new Node;s->data=a[i];r->next=s;r=s;}r->next=NULL;}时间复杂度:O(n)3、按位查找a、伪代码实现: 初始化工作指针p和计数器j,p指向第一个结点,j=1循环以下操作,直到p为空或者j等于1b1:p指向下一个结点b2:j加1若p为空,说明第i个元素不存在,抛出异常否则,说明p指向的元素就是所查找的元素,返回元素地址b、代码实现Node* Linklist::Get(int i)//得到指向第i个数的指针{Node*p=front->next;int j=1;while(p&&j!=i)//p非空且j不等于i,指针后移{p=p->next;j++;}return p;}4、插入操作a、伪代码实现: 如果链表为空,直接插入判断p的下一个结点的值大于x且p的值小于x在堆中建立新结点将要插入的结点的数据写入到新结点的数据域修改新结点的指针域修改前一个指针的指针域,使其指向新插入的结点的位置b、代码实现void Linklist::Insert(int x)//将x按顺序插入{Node*p=front->next;if(!p)//如果链表为空,直接插入{Node*s=new Node;s->data=x;s->next=front->next;front->next=s;}elsewhile(!((p->next->data>x)&&(p->data<x)))//判断p的下一个结点的值大于x且p 的值小于x{p=p->next;}Node*s=new Node;//将x插入到p之后s->data=x;s->next=p->next;p->next=s;}5、删除操作a、伪代码实现:从第一个结点开始,查找要删除的位数i前一个位置i-1的结点设q指向第i个元素将q元素从链表中删除保存q元素的数据释放q元素b、代码实现int Linklist::Delete(int i)//删除第i个位置的结点{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;}6遍历打印函数a、伪代码实现:判断该链表是否为空链表,如果是,报错如果不是空链表,新建立一个temp指针将temp指针指向头结点打印temp指针的data域逐个往后移动temp指针,直到temp指针的指向的指针的next域为空b、代码实现void Linklist::show()//打印数组元素{Node*p=front->next;while(p){cout<<p->data<<" ";p=p->next;}}7.获取链表长度函数a、伪代码实现:判断该链表是否为空链表,如果是,输出长度0如果不是空链表,新建立一个temp指针,初始化整形数n为0将temp指针指向头结点判断temp指针指向的结点的next域是否为空,如果不是,n加一,否则return n使temp指针逐个后移,重复d操作,直到temp指针指向的结点的next域为0,返回nb 、代码实现void Linklist::Getlength()//得到数组长度{Node*p=front->next;int j=0;while(p){p=p->next;j++;}cout<<j;}2.3 其他源代码#include<iostream>using namespace std;struct Node{int data;struct Node* next;};class Linklist{public:Linklist(int a[],int n);Linklist(int a[],int n,int m);Node* Get(int i);void Insert(int x);int Delete(int i);int Locate(int x);void Getlength();void show();~Linklist();private:Node*front;};Linklist::Linklist(int a[],int n)//头插法{front=new Node;front->next=NULL;for(int i=n-1;i>=0;i--){Node*s=new Node;s->data=a[i];s->next=front->next;front->next=s;}}Linklist::Linklist(int a[],int n,int m)//尾插法{front=new Node;Node*r=front;for(int i=0;i<n;i++){Node*s=new Node;s->data=a[i];r->next=s;r=s;}r->next=NULL;}Node* Linklist::Get(int i)//得到指向第i个数的指针{Node*p=front->next;int j=1;while(p&&j!=i)//p非空且j不等于i,指针后移{p=p->next;j++;}return p;}void Linklist::Insert(int x)//将x按顺序插入{Node*p=front->next;if(!p)//如果链表为空,直接插入{Node*s=new Node;s->data=x;s->next=front->next;front->next=s;}elsewhile(!((p->next->data>x)&&(p->data<x)))//判断p的下一个结点的值大于x且p的值小于x {p=p->next;}Node*s=new Node;//将x插入到p之后s->data=x;s->next=p->next;p->next=s;}int Linklist::Delete(int i)//删除第i个位置的结点{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;}int Linklist::Locate(int x)//得到值为x的位置{Node*p=front->next;int j=1;while(p){if(p->data==x)return j;p=p->next;j++;}return -1;}void Linklist::Getlength()//得到数组长度{Node*p=front->next;int j=0;while(p){p=p->next;j++;}cout<<j;}Linklist::~Linklist()//析构{Node*p=front;while(p){front=p;p=p->next;delete front;}}void Linklist::show()//打印数组元素{Node*p=front->next;while(p){cout<<p->data<<" ";p=p->next;}}void main()//主函数{int a[10]={1,2,3,4,5,6,7,8,9,11}; Linklist A(a,10);Linklist B(a,10,1);cout<<"原数组为:";A.show();cout<<endl;A.Insert(10);cout<<"插入操作后的数组变为:";A.show();cout<<endl;A.Delete(7);cout<<"删除操作后的数组为:";A.show();cout<<endl;A.Locate(1);cout<<"数组长度为:";A.Getlength();A.~Linklist();cout<<endl;}3. 程序运行结果1.测试主函数流程:2、运行结果4. 总结调试时出现的问题及解决的方法:在设计将x按顺序插入的函数时,没有分清p->next->next->data和 p->next->data的区别,通过认真查阅和理解书本知识解决。
数据结构线性表试验报告(最终定稿)

数据结构线性表试验报告(最终定稿)第一篇:数据结构线性表试验报告线性表上机实习1、实验目的(1)熟悉将算法转换为程序代码的过程。
(2)了解顺序表的逻辑结构特性,熟练掌握顺序表存储结构的C 语言描述方法。
(3)熟练掌握顺序表的基本运算:查找、插入、删除等,掌握顺序表的随机存取特性。
(4)了解线性表的链式存储结构,熟练掌握线性表的链式存储结构的C语言描述方法。
(5)熟练掌握线性链表(单链表)的基本运算:查找、插入、删除等,能在实际应用中灵活选择适当的链表结构。
2、实验要求(1)熟悉顺序表的插入、删除和查找。
(2)熟悉单链表的插入、删除和查找。
3、实验内容: ① 顺序表(1)抽象数据类型定义typedef struct {TypeData data[maxsize];//容量为maxsize的静态顺手表int n;//顺序表中的实际元素个数}SeqList;//静态顺序表的定义在本次实验中,首先建立一个空的静态顺序表,然后键盘输入数据存入表中,然后进入菜单选择界面,通过不同的数字输入,实现对顺序表,删除,插入,查找,显示等操作。
(2)存储结构定义及算法思想在顺序表结构体的定义中,typedef int TypeData 为整型,存储结构如下:for(n=0;ncout<<“请输入线性表数据”<cin>>L.data[n];//顺序将数据存入顺序表}//其他存储与此类似,都是直接赋值与数组的某一位插入版块子函数:void insert(SeqList &L)//插入数据 {int a,b,c,k;cout<<“请输入插入的数及其插入的位置”<cin>>a>>b;if(b<=0||b>(L.n+1)){cout<<“不能在该位置插入”<k=L.data[b-1];L.data[b-1]=a;c=L.n;L.n=L.n+1;while(c>b){L.data[c]=L.data[c-1];c--;//通过循环,实现插入位置后的数据挨个往后移动一位}L.data[b]=k;} 顺序表的插入与删除操作类似,在插入与删除后,都要循环调整后面数组的每一位元素,同时记录数据元素的长度的标示符也要跟着改变。
数据结构实验报告1线性表的顺序存储结构

数据结构实验报告1线性表的顺序存储结构数据结构实验报告1线性表的顺序存储结构第一章引言线性表是计算机中最常见的数据结构之一,它是一种有序的数据元素集合,其中的数据元素之间具有一对一的关系。
线性表的存储结构有多种方式,其中顺序存储结构是最简单的一种,它使用一段连续的存储单元来存储线性表中的元素。
第二章顺序存储结构的定义顺序存储结构是将线性表中的元素按照其逻辑顺序依次存储在一块连续的存储空间中。
顺序存储结构的特点是可以快速地访问任意位置的元素,但插入和删除操作需要移动大量的元素。
第三章顺序存储结构的实现1.存储空间的分配顺序存储结构通常使用数组来实现,数组的长度应该大于等于线性表的长度,以防止溢出。
存储空间的分配可以使用静态分配或动态分配两种方式来实现。
2.线性表的初始化初始化线性表时,需要设置线性表的长度和当前元素的个数。
3.线性表的增删改查操作●插入操作:________在指定位置插入一个元素时,需要将插入位置之后的元素依次后移,给待插入的元素腾出位置。
●删除操作:________删除指定位置的元素时,需要将删除位置之后的元素依次前移,覆盖删除位置上的元素。
●修改操作:________修改指定位置的元素时,直接对该位置上的元素进行修改即可。
●查找操作:________根据指定的元素值,查找其在顺序存储结构中的位置。
4.线性表的遍历操作遍历操作可以按照顺序访问线性表中的每个元素,可以使用循环结构实现遍历操作。
第四章顺序存储结构的优缺点分析1.优点:________可以快速地访问任意位置的元素,节省存储空间。
2.缺点:________插入和删除操作需要移动大量的元素,不适用于频繁插入和删除的场景。
第五章实验过程和结果分析在本次实验中,我们以顺序存储结构为基础,实现了线性表的增删改查操作,并进行了遍历操作。
通过实验,我们发现顺序存储结构在查询操作上有较好的性能,但在插入和删除操作上的性能较差。
第六章附件本文档涉及的附件详见附件文件。
(完整版)数据结构线性表的应用实验报告

实验报告课程名称____数据结构上机实验__________ 实验项目______线性表的应用 ____________实验仪器________PC机___________________系别_____电子信息与通信学院___专业________ ___班级/学号______ __学生姓名______ ___________实验日期_______________________成绩_______________________指导教师_______________________实验一.线性表的应用1.实验目的:掌握线性链表的存储、运算及应用。
利用链表实现一元多项式计算。
2.实验内容:1)编写函数,实现用链表结构建立多项式;2)编写函数,实现多项式的加法运算;3)编写函数,实现多项式的显示;4)测试:编写主函数,它定义并建立两个多项式,显示两个多项式,然后将它们相加并显示结果。
变换测试用的多项式,检查程序的执行结果。
选做内容:修改程序,选择实现以下功能:5)多项式求值:编写一个函数,根据给定的x值计算并返回多项式f(x)的值。
测试该函数(从终端输入一个x的值,调用该函数并显示返回结果)。
6)多项式相减:编写一个函数,求两个多项式相减的多项式。
7)多项式相乘:编写一个函数,求两个多项式的乘积多项式。
3.算法说明:1)多项式的建立、显示和相加算法见讲义。
可修改显示函数,使输出的多项式更符合表达规范。
2)多项式减法:同次项的系数相减(缺项的系数是0)。
例如a(x)=-5x2+2x+3,b(x)= -4x3+3x,则a(x)-b(x)=4x3-5x2-x+3。
提示:a(x)-b(x) = a(x)+(-b(x))。
3)多项式乘法:两个多项式的相乘是“系数相乘,指数相加”。
算法思想是用一个多项式中的各项分别与另一个多项式相乘,形成多个多项式,再将它们累加在一起。
例如,a(x)=-5x2+2x+3,b(x)=-4x3+3x,则a(x)*b(x) = (-4x3)*(-5x2+2x+3)+(3x)*(-5x2+2x+3)= (20x5-8x4-12x3) + (-15x3+6x2+9x) =20x5-8x4-27x3+6x2+9x。
《数据结构》实验1实验报告

南京工程学院实验报告<班级>_<学号>_<实验X>.RAR文件形式交付指导老师。
一、实验目的1.熟悉上机环境,进一步掌握语言的结构特点。
2.掌握线性表的顺序存储结构的定义及实现。
3.掌握线性表的链式存储结构——单链表的定义及实现。
4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。
5.掌握线性表在链式存储结构——单链表中的各种基本操作。
二、实验内容1.顺序线性表的建立、插入及删除。
2.链式线性表的建立、插入及删除。
三、实验步骤1.建立含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。
2.利用前面的实验先建立一个顺序表L={21,23,14,5,56,17,31},然后在第i个位置插入元素68。
3.建立一个带头结点的单链表,结点的值域为整型数据。
要求将用户输入的数据按尾插入法来建立相应单链表。
四、程序主要语句及作用程序1的主要代码(附简要注释)public struct sequenlist{public const int MAXSIZE=1024; /*最大值为1024*/public elemtype[] vec;public int len; /* 顺序表的长度 */public sequenlist( int n){vec=new elemtype[MAXSIZE ];len = n;}};class Program{static void Main(string[] args){sequenlist list1 = new sequenlist(5);for (int i = 0; i < 5; i++){list1.vec[i] = i;}for (int i = 0; i < 5; i++){Console.Write("{0}---", list1.vec[i]) ;}Console.WriteLine("\n");Console.WriteLine("表长:{0}\n",list1.len );Console.ReadKey();}}程序2的主要代码(附简要注释)public void insertlist(int i, int x){if (len >= MAXSIZE)throw new Exception("上溢"); /*长度大于最大值则抛出异常*/if (i < 1 || i > len + 1)throw new Exception("位置");/插入位置小于1或大于len+1则抛出插入位置错误的异常for (int j = len; j >= i; j--)vec[j] = vec[j - 1]; //注意第j个元素存在数组下标为j-1处vec[i - 1] = x;len++;}};class Program{static void Main(string[] args){sequenlist list2 = new sequenlist(7);list2.vec[0] = 21;list2.vec[1] = 23;list2.vec[2] = 14;list2.vec[3] = 5;list2.vec[4] = 56;list2.vec[5] = 17;list2.vec[6] = 31;Console.Write("请输入第i个位置插入元素:");int loc =Convert.ToInt32( Console.ReadLine());Console.Write("请输入第{0}个位置插入的元素:", loc);int ele = Convert.ToInt32(Console.ReadLine());Console.WriteLine("插入前的线性表:");for (int i = 0; i < list2.len ; i++){Console.Write("{0}---", list2.vec[i]);}Console.WriteLine("\n");list2.insertlist(loc, ele);Console.WriteLine("插入后的线性表:");for (int i = 0; i < list2.len ; i++){Console.Write("{0}---", list2.vec[i]);}Console.WriteLine("\n");Console.ReadKey();}}程序3的主要代码(附简要注释)class Node{private int num;public int Num{set { num = value; }/输入值get { return num; }/获得值}private Node next;public Node Next{set { next = value; }get { return next; }}}class Pp{static void Main(string[] args){Node head;Node tempNode, tempNode1;int i;head = new Node();Console.WriteLine("输入六项数据:\n");Console.Write("输入第1项数据:");head.Num = Convert.ToInt32(Console.ReadLine());head.Next = null;tempNode = head;for (i = 1; i < 6; i++){tempNode1 = new Node();Console.Write("输入第{0}项数据:",i+1);tempNode1.Num = Convert.ToInt32(Console.ReadLine());/插入项转换为整形数值 tempNode1.Next = null;tempNode.Next = tempNode1;tempNode = tempNode.Next;}Console.WriteLine("线性表:");tempNode = head;for (i = 0; i < 6; i++){Console.Write("{0}", tempNode.Num);if (i < 5){Console.Write("--");}tempNode = tempNode.Next;}Console.ReadKey();}}五、程序运行结果截图程序1程序2程序3六、收获,体会及问题(写得越详细、越个性化、越真实越好,否则我不知道你做这个实验的心路历程,也就无法充分地判断你是否是独立完成的这个实验、你是否在做这个实验时进行了认真仔细地思考、通过这个实验你是否在实践能力上得到了提高)这次试验刚开始做时完全不知道从哪下手,才刚上了几节课,对于线性表、链式表都不是理解的很透彻,不知道用哪个软件编写程序。
数据结构实验一-线性表

数据结构实验⼀-线性表实验⼀线性表⼀、实验⽬的1、深刻理解线性结构的特点,以及在计算机内的两种存储结构。
2、熟练掌握线性表的顺序存储结构和链式存储结构,及其它们的基本操作,重点掌握查找、插⼊和删除等操作。
⼆、实验要求1、认真阅读程序,将未完成的代码补全(红⾊部分)。
2、上机调试,并运⾏程序。
3、保存和截图程序的运⾏结果,并结合程序进⾏分析。
三、实验内容和基本原理1、实验1.1 顺序表的操作利⽤顺序表存储⽅式实现下列功能(见参考程序1):1)通过键盘输⼊数据建⽴⼀个线性表,并输出该线性表。
如,依次输⼊元素25,21,46,90,12,98。
2)根据屏幕菜单的选择,进⾏数据的插⼊、删除和查找,并在插⼊或删除数据后,再输出线性表。
如,在第2个位置上插⼊元素43,然后输出顺序表。
删除顺序表第4个元素,输出改变的顺序表。
3)在屏幕菜单中选择0,结束程序的运⾏。
基本原理:在顺序表的第i个位置上插⼊⼀个元素时,必须先将线性表的第i个元素之后的所有元素依次后移⼀个位置,以便腾空⼀个位置,在把新元素插⼊到该位置。
当要删除第i个元素时,只需将第i个元素之后的所有元素前移⼀个位置。
程序代码(蓝⾊为补充的语句)://* * * * * * * * * * * * * * * * * * * * * * * *//*PROGRAM :顺序结构的线性表 *//*CONTENT :建⽴,插⼊,删除,查找 *//*编程语⾔: Visual c++ 6.0 *//* * * * * * * * * * * * * * * * * * * * * *#include#include#define MAXSIZE 20typedef int ElemType; //数据元素的类型typedef struct{ElemType a[MAXSIZE];int length;}SqList; //顺序存储的结构体类型SqList a,b,c;//函数声明void creat_list(SqList *L);void out_list(SqList L);void insert_sq(SqList *L,int i,ElemType e); ElemType delete_sq(SqList *L,int i);int locat_sq(SqList L,ElemType e);//主函数void main(){int i,k,loc;ElemType e,x;char ch;do {printf("\n\n\n");printf("\n 吴肖遥20151681310131");printf("\n 1.建⽴线性表");printf("\n 2.插⼊元素");printf("\n 3.删除元素");printf("\n 4.查找元素");printf("\n 0.结束程序运⾏");printf("\n =====================");printf("\n 请输⼊要执⾏的操作: ");scanf("%d",&k);switch(k){case 1:{creat_list(&a);out_list(a);}break;case 2:{printf("\n请输⼊插⼊位置: ",a.length+1); scanf("%d",&i);printf("请输⼊要插⼊的元素值: ");scanf("%d",&e);insert_sq(&a,i,e);out_list(a);}break;case 3:{printf("\n请输⼊要删除元素的位置: ",a.length); scanf("%d",&i);x=delete_sq(&a,i);out_list(a);if(x!=-1)printf("\n删除的元素为:%d\n",x);else printf("要删除的元素不存在!");}break;case 4:{printf("\n请输⼊要查找的元素值:");scanf("%d",&e);loc=locat_sq(a,e);if(loc==-1)printf("\n未找到指定元素!");elseprintf("\n已找到,元素的位置是: %d ",loc);}break;}/*switch*/}while(k!=0);printf("\n 按回车键,返回...\n");ch=getchar();}/*main*///建⽴线性表void creat_list(SqList *L){int i;printf("请输⼊线性表的长度: ");scanf("%d",&L->length);for(i=0;ilength;i++){printf("数据 %d =",i);scanf("%d",&(L->a[i]));}}//输出线性表void out_list(SqList L){int i;for(i=0;i<=L.length-1;i++)printf("%10d",L.a[i]);}//在线性表的第i个位置插⼊元素evoid insert_sq(SqList *L,int i,ElemType e){int j;if(L->length==MAXSIZE)printf("线性表已满!\n");else {if(i<1||i>L->length+1)printf("输⼊位置错!\n");else {for(j=L->length-1;j>=i-1;j--)L->a[j+1]=L->a[j];L->a[j+1]=e;/*将未完成的代码补全,提⽰:此处添加⼀条语句,将被删除的元素值赋给e*/ L->length++;}}}//删除第i个元素,返回其值ElemType delete_sq(SqList *L,int i){ElemType x;int j;if(L->length==0)printf("空表!\n");else if(i<1||i>L->length){printf("输⼊位置错!\n");x=-1;}else{x=L->a[i-1];for(j=i;j<=L->length-1;j++)L->a[j-1]=L->a[j];/*将未完成的代码补全,提⽰:此处添加⼀条语句,将被删除元素之后的元素左移。
中南大学数据结构实验报告1(线性表)

实验一线性表的操作算法一、实验目的:1了解线性表的逻辑结构和存储结构,以及定义在逻辑结构上的各种基本运算2分别以数组和链表为存储结构,实现线性表的插入,删除,查找,排序,合并等操作二、实验内容:用C/C++语言编写程序,分别以数组和链表为存储结构,完成以下功能:1输入数据,创建一个线性表2可在线性表的任意位置插入新结点3可删除线性表的任意一个结点4可在线性表中查找结点5将线性表从小至大排序6将两个线性表合并三、详细设计:顺序表#include<iostream>using namespace std;#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;typedef int ElemType;#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct { //结构体ElemType *elem;int length;int listsize;}SqList;SqList Lx;Status InitList_Sq(SqList &L) //分配空间{ L.elem=new ElemType[LIST_INIT_SIZE];if(!L.elem)exit(OVERFLOW);L.length =0;L.listsize=LIST_INIT_SIZE;return OK;}Status ListInsert(SqList &L,int i,ElemType e) //插入新元素{ int *q,*p;ElemType *newbase;if(i<1 || i>L.length+1) return ERROR;if(L.length>=L.listsize){ newbase=new ElemType[L.listsize+LISTINCREMENT];if(!newbase) exit(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 Listlength(SqList L) //长度{ int *p=L.elem; //判断线形表是否存在while(p){ return (L.length); }}Status GetElem(SqList L, int i,ElemType &e) //取元素{ if(i<1 || i>L.length)return ERROR;else{ e=L.elem[i-1];return e;}}void MergeList(SqList La,SqList Lb,SqList &Lc) //合并{ ElemType ai,bj;InitList_Sq(Lc);int i=1,j=1,k=0;int La_len,Lb_len;La_len=Listlength(La);Lb_len=Listlength(Lb);while((i<=La_len)&&(j<=Lb_len)){ GetElem(La,i,ai);GetElem(Lb,j,bj);if(ai<=bj){ ListInsert(Lc,++k,ai);++i; }else{ ListInsert(Lc,++k,bj);++j; }}while(i<=La_len){ GetElem(La,i++,ai);ListInsert(Lc,++k,ai);}while(j<=Lb_len){ GetElem(Lb,j++,bj);ListInsert(Lc,++k,bj);}}void show(SqList L,int i) //显示{ int j;ElemType k;cout<<"顺序表显示如下:"<<endl;for(j=0;j<i-1;j++){ k=L.elem[j];cout<<k<<"->"; }if(j==i-1 && i>0){ k=L.elem[j]; cout<<k; }cout<<endl;}void create(SqList &L,int n) //输入元素{ int e;for(int i=0;i<n;i++){ cin>>e;L.elem[i]=e;L.length=i+1; }}Status ListDelete_Sq(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 Listxiugei(SqList &L,int i,ElemType &e) //修改{ if(i<1 || i>L.length)return ERROR;else{ L.elem[i-1]=e;return OK; }}void shuru(SqList &L1) //顺序表的创建{ int a;InitList_Sq(L1);cout<<"请输入顺序表的长度:";cin>>a;cout<<"请输入顺序表的元素(共"<<a<<"个)"<<endl;create(L1,a);show(L1,a);}void shanchu(SqList &L1) //删除顺序表里的元素{ int a;int j; ElemType e1;a=L1.length;cout<<"请选择所要删除元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>j; }ListDelete_Sq(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a-1);}void charu(SqList &L1) //插入元素到顺序表里{ int a; int j; ElemType e1;a=L1.length;cout<<"请选择所要插入元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>j; }cout<<"要插入的元素:";cin>>e1;ListInsert(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a+1);}void hebing(SqList &L3) //合并两个顺序表{ SqList L1,L2;int a,b;InitList_Sq(L1); InitList_Sq(L2);cout<<"请输入第一个有序表的长度:"; cin>>a;cout<<"请输入第一个有序表的元素(共"<<a<<"个)"<<endl;create(L1,a);show(L1,a);cout<<"请输入第二个有序表的长度:"; cin>>b;cout<<"请输入第二个有序表的元素(共"<<b<<"个)"<<endl;create(L2,b);show(L2,b);MergeList(L1,L2,L3);cout<<"合并后的有序表如下:"; show(L3,a+b);}void main() //主菜单{ int choice;for(;;){ cout<<"顺序表的基本操作"<<endl;cout<<"1.顺序表的创建"<<endl;cout<<"2.顺序表的显示"<<endl;cout<<"3.顺序表的长度"<<endl;cout<<"4.插入元素到顺序表里"<<endl;cout<<"5.删除顺序表里的元素"<<endl;cout<<"6.合并两个顺序表"<<endl;cout<<"7.退出系统"<<endl;cout<<"请选择:";cin>>choice;switch(choice){ case 1: shuru(Lx);break;case 2: show(Lx,Lx.length);break;case 3: cout<<"顺序表的长度:"<<Listlength(Lx)<<endl;break;case 4: charu(Lx);break;case 5: shanchu(Lx);break;case 6: hebing(Lx);break;case 7: cout<<"退出系统!"<<endl;exit(0);break;default : cout<<"输入有误,请重新选择"<<endl;break; }}}链表#include<iostream>using namespace std;#define true 1#define false 0#define ok 1#define error 0#define overflow -2typedef int Status;typedef int ElemType;typedef struct LNode //存储结构{ ElemType data;struct LNode *next;}LNode,*LinkList;void CreateList(LinkList &L,int n) //尾插法创建单链表{ LinkList p;L=new LNode;L->next=NULL; //建立一个带头结点的单链表LinkList q=L; //使q指向表尾for(int i=1;i<=n;i++){ p=new LNode;cin>>p->data;p->next=NULL;q->next=p;q=p; }}Status GetElem(LinkList L,int i,ElemType &e)//取第i个元素{ LinkList p=L->next;int j=1;while(p&&j<i){ p=p->next;++j; }if(!p||j>i) return error; //第i个元素不存在e=p->data;return ok;}Status LinkInsert(LinkList &L,int i,ElemType e) //插入{ LinkList p=L;int j=0;while(p&&j<i-1){ p=p->next;++j; } //寻找第i-1个结点 if(!p||j>i-1)return error; //i小于1或者大于表长加1 LinkList s=new LNode; //生成新结点s->data=e;s->next=p->next; //插入L中p->next=s;return ok;}Status ListDelete(LinkList &L,int i,ElemType &e) // 删除{ LinkList p=L;LinkList q;int j=0;while(p->next&&j<i-1){ //寻找第i个结点,并令p指向其前驱 p=p->next;++j; }if(!(p->next)||j>i-1) return error; //删除位置不合理q=p->next;p->next=q->next; //删除并释放结点e=q->data;delete(q);return ok;}void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc) { //合并两个顺序链表LinkList pa,pc,pb;pa=La->next;pb=Lb->next;Lc=pc=La;while(pa&&pb){ if(pa->data<=pb->data){ pc->next=pa;pc=pa;pa=pa->next; }else{ pc->next=pb;pc=pb;pb=pb->next; }}pc->next=pa?pa:pb;delete(Lb);}void show(LinkList L) //显示{ LinkList p;p=L->next;while(p){ cout<<p->data<<"-->";p=p->next; }cout<<endl;}int Length(LinkList L,int i) //表长{ i=0;LinkList p=L->next;while(p){ ++i;p=p->next; }return i;}void xiugai(LinkList L) //修改{ int i,j=1;ElemType k;ElemType e,m;LinkList p=L->next;cout<<"请输入要修改的元素位置(0<i<length):";cin>>i;GetElem(L,i,e);cout<<"该位置的元素:"<<e<<endl;cout<<"修改后的元素值:";cin>>k;while(p&&j<i){ p=p->next;++j; }m=p->data;p->data=k;cout<<"修改后的单链表显示如下:"<<endl;show(L);}void hebing() //合并两个单链表{ int a,b;LinkList La,Lb,Lc;cout<<"请输入第一个有序链表的长度:"<<endl;cin>>a;cout<<"请输入第一个有序链表的元素共("<<a<<"个):"<<endl;CreateList(La,a);show(La);cout<<"请输入第二个有序链表的长度:"<<endl;cin>>b;cout<<"请输入第二个有序链表的元素共("<<b<<"个):"<<endl;CreateList(Lb,b);show (Lb);MergeList(La,Lb,Lc);cout<<"合并后的有序链表如下:"<<endl;show(Lc);}void main() //主函数{ int select;int x;ElemType y;LinkList list;for(;;){ cout<<"单链表的基本操作"<<endl;cout<<"1.单链表的创建"<<endl;cout<<"2.单链表的显示"<<endl;cout<<"3.单链表的长度"<<endl;cout<<"4.插入元素到单链表里"<<endl;cout<<"5.删除单链表里的元素"<<endl;cout<<"6.合并两个单链表"<<endl;cout<<"7.退出系统"<<endl;cout<<"请选择:";cin>>select;switch(select){ case 1:cout<<"请输入单链表的长度:"<<endl;cin>>x;cout<<"请输入"<<x<<"个元素"<<endl;CreateList(list,x);break;case 2: cout<<"单链表显示如下:"<<endl;show(list);break;case 3: int s;cout<<"单链表的长度为:"<<Length(list,s)<<endl;break;case 4: cout<<"请选择要插入的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>x; }cout<<"要插入的元素值:";cin>>y;LinkInsert( list,x,y);cout<<"插入后单链表显示如下:"<<endl;show(list);break;case 5: cout<<"请选择要删除的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>x; }ListDelete(list,x,y);cout<<"要删除的元素值:"<<y<<endl;cout<<"删除后的单链表显示如下:"<<endl;show(list);break;case 6: hebing();break;case 7: exit(0);break;default : cout<<"输入有误,请重新输入"<<endl;break;}}}四、实验结果:顺序表链表。
数据结构实验一实验报告——线性表

实验报告课程名称:数据结构实验名称:线性表班级:学生姓名:学号:指导教师评定:签名:题目:有两张非递增有序的线性学生表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仍按非递减有序排列。
数据结构实验报告(一)线性表的应用

数据结构实验报告(⼀)线性表的应⽤实验说明数据结构实验⼀ 线性表的实验——线性表的应⽤⼀、实验⽬的通过本实验使学⽣了解线性表的⼀种简单应⽤,熟悉线性表顺序存储与链式存储的特性,特别训练学⽣编程灵活控制链表的能⼒,为今后编程控制更为复杂的数据结构奠定基础。
⼆、实验内容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),因为我们可能需要遍历整个链表。
通过本次实验,我们更加深入地理解了线性表的基本概念和特点,掌握了线性表的基本操作,包括插入、删除、查找等。
数据结构--实验报告_线性表的基本操作备用

实验目的实验内容和要求源代码顺序表的代码单链表的代码测试结果顺序表的测试结果单链表的测试结果五、心得体会实验一线性表的基本操作及其应用一、实验目的1.帮助读者复习C++语言程序设计中的知识。
2.熟悉线性表的逻辑结构。
3.熟悉线性表的基本运算在两种存储结构上的实现。
4.掌握顺序表的存储结构形式及其描述和基本运算的实现。
5.熟练掌握动态链表结构及有关算法的设计二、实验内容题目一: 顺序表的基本操作[问题描述]实现顺序表的建立、求长度, 取元素、修改元素、插入、删除等顺序表的基本操作。
[基本要求](1)依次从键盘读入数据, 建立带头结点的顺序表;(2)输出顺序表中的数据元素(3)求顺序表的长度;(4)根据指定条件能够取元素和修改元素;(5)实现在指定位置插入和删除元素的功能。
(6)根据算法, 将两个有序的顺序表合并成一个有序顺序表。
[测试数据] 由学生任意指定。
题目二: 单链表的基本操作[问题描述]实现带头结点的单链表的建立、求长度, 取元素、修改元素、插入、删除等单链表的基本操作。
[基本要求](1)依次从键盘读入数据, 建立带头结点的单链表;(2)输出单链表中的数据元素(3)求单链表的长度;(4)根据指定条件能够取元素和修改元素;(5)实现在指定位置插入和删除元素的功能。
(6)根据算法, 将两个有序的单链表合并成一个有序单链表。
[测试数据]由学生任意指定。
三、源代码顺序表的基本操作#include<iostream>using namespace std;#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;typedef int ElemType;#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct { //结构体ElemType *elem;int length;int listsize;}SqList;SqList Lx;Status InitList_Sq(SqList &L) //分配空间{ L.elem=new ElemType[LIST_INIT_SIZE];if(!L.elem)exit(OVERFLOW);L.length =0;L.listsize=LIST_INIT_SIZE;return OK;}Status ListInsert(SqList &L,int i,ElemType e) //插入新元素{ int *q,*p;ElemType *newbase;if(i<1 || i>L.length+1) return ERROR;if(L.length>=L.listsize){ newbase=new ElemType[L.listsize+LISTINCREMENT];if(!newbase) exit(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 Listlength(SqList L) //长度{ int *p=L.elem; //判断线形表是否存在while(p){ return (L.length); }}Status GetElem(SqList L, int i,ElemType &e) //取元素{ if(i<1 || i>L.length)return ERROR;else{ e=L.elem[i-1];return e;}}void MergeList(SqList La,SqList Lb,SqList &Lc) //合并{ ElemType ai,bj;InitList_Sq(Lc);int i=1,j=1,k=0;int La_len,Lb_len;La_len=Listlength(La);Lb_len=Listlength(Lb);while((i<=La_len)&&(j<=Lb_len)){ GetElem(La,i,ai);GetElem(Lb,j,bj);if(ai<=bj){ ListInsert(Lc,++k,ai);++i; }else{ ListInsert(Lc,++k,bj);++j; }}while(i<=La_len){ GetElem(La,i++,ai);ListInsert(Lc,++k,ai);}while(j<=Lb_len){ GetElem(Lb,j++,bj);ListInsert(Lc,++k,bj);}}void show(SqList L,int i) //显示{ int j;ElemType k;cout<<"顺序表显示如下:"<<endl;for(j=0;j<i-1;j++){ k=L.elem[j];cout<<k<<"->"; }if(j==i-1 && i>0){ k=L.elem[j]; cout<<k; }cout<<endl;}void create(SqList &L,int n) //输入元素{ int e;for(int i=0;i<n;i++){ cin>>e;L.elem[i]=e;L.length=i+1; }}Status ListDelete_Sq(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 Listxiugei(SqList &L,int i,ElemType &e) //修改{ if(i<1 || i>L.length)return ERROR;else{ L.elem[i-1]=e;return OK; }}void shuru(SqList &L1) //顺序表的创建{ int a;InitList_Sq(L1);cout<<"请输入顺序表的长度: ";cin>>a;cout<<"请输入顺序表的元素(共"<<a<<"个)"<<endl;create(L1,a);show(L1,a);}void chaxun(SqList &L1) //取第i个位置的元素{ int j;ElemType e1;cout<<"请选择所要取出元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要取出元素的位置:";cin>>j; }GetElem(L1,j,e1);cout<<"取出的元素为:"<<e1<<endl; }void xiugai(SqList &L1) //修改第i个位置的元素{ int a;int j; ElemType e1;a=L1.length;cout<<"请选择所要修改元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要修改元素的位置:";cin>>j; }cout<<"要修改成的元素:";cin>>e1;Listxiugei(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a);}void shanchu(SqList &L1) //删除顺序表里的元素{ int a;int j; ElemType e1;a=L1.length;cout<<"请选择所要删除元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>j; }ListDelete_Sq(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a-1);}void charu(SqList &L1) //插入元素到顺序表里{ int a; int j; ElemType e1;a=L1.length;cout<<"请选择所要插入元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>j; }cout<<"要插入的元素:";cin>>e1;ListInsert(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a+1);}void hebing(SqList &L3) //合并两个顺序表{ SqList L1,L2;int a,b;InitList_Sq(L1); InitList_Sq(L2);cout<<"请输入第一个有序表的长度: "; cin>>a;cout<<"请输入第一个有序表的元素(共"<<a<<"个)"<<endl;create(L1,a);show(L1,a);cout<<"请输入第二个有序表的长度: "; cin>>b;cout<<"请输入第二个有序表的元素(共"<<b<<"个)"<<endl;create(L2,b);show(L2,b);MergeList(L1,L2,L3);cout<<"合并后的有序表如下: "; show(L3,a+b);}void main() //主菜单{ int choice;for(;;){ cout<<" 顺序表的基本操作"<<endl;cout<<" 1.顺序表的创建"<<endl;cout<<" 2.顺序表的显示"<<endl;cout<<" 3.顺序表的长度"<<endl;cout<<" 4.取第i个位置的元素"<<endl;cout<<" 5.修改第i个位置的元素"<<endl;cout<<" 6.插入元素到顺序表里"<<endl;cout<<" 7.删除顺序表里的元素"<<endl;cout<<" 8.合并两个顺序表"<<endl;cout<<" 9.退出系统"<<endl;cout<<"请选择: ";cin>>choice;switch(choice){ case 1: shuru(Lx);break;case 2: show(Lx,Lx.length);break;case 3: cout<<"顺序表的长度:"<<Listlength(Lx)<<endl;break;case 4: chaxun(Lx);break;case 5: xiugai(Lx);break;case 6: charu(Lx);break;case 7: shanchu(Lx);break;case 8: hebing(Lx);break;case 9: cout<<"退出系统!"<<endl;exit(0);break;default : cout<<"输入有误, 请重新选择"<<endl;break; } }}单链表的基本操作#include<iostream>using namespace std;#define true 1#define false 0#define ok 1#define error 0#define overflow -2typedef int Status;typedef int ElemType;typedef struct LNode //存储结构{ ElemType data;struct LNode *next;}LNode,*LinkList;void CreateList(LinkList &L,int n) //尾插法创建单链表{ LinkList p;L=new LNode;L->next=NULL; //建立一个带头结点的单链表LinkList q=L; //使q指向表尾for(int i=1;i<=n;i++){ p=new LNode;cin>>p->data;p->next=NULL;q->next=p;q=p; }}Status GetElem(LinkList L,int i,ElemType &e)//取第i个元素{ LinkList p=L->next;int j=1;while(p&&j<i){ p=p->next;++j; }if(!p||j>i) return error; //第i个元素不存在e=p->data;return ok;}Status LinkInsert(LinkList &L,int i,ElemType e) //插入{ LinkList p=L;int j=0;while(p&&j<i-1){ p=p->next;++j; } //寻找第i-1个结点if(!p||j>i-1)return error; //i小于1或者大于表长加1 LinkList s=new LNode; //生成新结点s->data=e;s->next=p->next; //插入L中p->next=s;return ok;}Status ListDelete(LinkList &L,int i,ElemType &e) // 删除{ LinkList p=L;LinkList q;int j=0;while(p->next&&j<i-1){ //寻找第i个结点, 并令p指向其前驱p=p->next;++j; }if(!(p->next)||j>i-1) return error; //删除位置不合理q=p->next;p->next=q->next; //删除并释放结点e=q->data;delete(q);return ok;}void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc){ //合并两个顺序链表LinkList pa,pc,pb;pa=La->next;pb=Lb->next;Lc=pc=La;while(pa&&pb){ if(pa->data<=pb->data){ pc->next=pa;pc=pa;pa=pa->next; }else{ pc->next=pb;pc=pb;pb=pb->next; }}pc->next=pa?pa:pb;delete(Lb);}void show(LinkList L) //显示{ LinkList p;p=L->next;while(p){ cout<<p->data<<"-->";p=p->next; }cout<<endl;}int Length(LinkList L,int i) //表长{ i=0;LinkList p=L->next;while(p){ ++i;p=p->next; }return i;}void xiugai(LinkList L) //修改{ int i,j=1;ElemType k;ElemType e,m;LinkList p=L->next;cout<<"请输入要修改的元素位置(0<i<length):";cin>>i;GetElem(L,i,e);cout<<"该位置的元素:"<<e<<endl;cout<<"修改后的元素值:";cin>>k;while(p&&j<i){ p=p->next;++j; }m=p->data;p->data=k;cout<<"修改后的单链表显示如下:"<<endl;show(L);}void hebing() //合并两个单链表{ int a,b;LinkList La,Lb,Lc;cout<<"请输入第一个有序链表的长度:"<<endl;cin>>a;cout<<"请输入第一个有序链表的元素共("<<a<<"个): "<<endl;CreateList(La,a);show(La);cout<<"请输入第二个有序链表的长度:"<<endl;cin>>b;cout<<"请输入第二个有序链表的元素共("<<b<<"个): "<<endl;CreateList(Lb,b);show (Lb);MergeList(La,Lb,Lc);cout<<"合并后的有序链表如下: "<<endl;show(Lc);}void main() //主函数{ int select;int x;ElemType y;LinkList list;for(;;){ cout<<" 单链表的基本操作"<<endl;cout<<" 1.单链表的创建"<<endl;cout<<" 2.单链表的显示"<<endl;cout<<" 3.单链表的长度"<<endl;cout<<" 4.取第i个位置的元素"<<endl;cout<<" 5.修改第i个位置的元素"<<endl;cout<<" 6.插入元素到单链表里"<<endl;cout<<" 7.删除单链表里的元素"<<endl;cout<<" 8.合并两个单链表"<<endl;cout<<" 9.退出系统"<<endl;cout<<"请选择:";cin>>select;switch(select){ case 1:cout<<"请输入单链表的长度:"<<endl;cin>>x;cout<<"请输入"<<x<<"个元素"<<endl;CreateList(list,x);break;case 2: cout<<"单链表显示如下:"<<endl;show(list);break;case 3: int s;cout<<"单链表的长度为:"<<Length(list,s)<<endl;break;case 4: cout<<"请选择所要取出元素的位置:";cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要取出元素的位置:";cin>>x; }GetElem(list,x,y);cout<<"该位置的元素为:"<<y<<endl;break;case 5: xiugai(list); break;case 6: cout<<"请选择要插入的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>x; }cout<<"要插入的元素值:";cin>>y;LinkInsert( list,x,y);cout<<"插入后单链表显示如下:"<<endl;show(list);break;case 7: cout<<"请选择要删除的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>x; }ListDelete(list,x,y);cout<<"要删除的元素值:"<<y<<endl;cout<<"删除后的单链表显示如下:"<<endl;show(list);break;case 8: hebing();break;case 9: exit(0);break;default : cout<<"输入有误, 请重新输入"<<endl;break;}}}四、测试结果顺序表的测试结果单链表的测试结果五、心得体会当听到老师说写数据结构实验报告时, 我有点惊讶, 才学了不到一个月, 就要写实验报告。
数据结构线性表实验报告五篇

数据结构线性表实验报告五篇第一篇:数据结构线性表实验报告实验报告课程名:数据结构实验名:线性表及其操作姓名:班级:学号:撰写时间: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

数据结构实验报告实验1一、实验目的本次实验的主要目的是通过实际操作和编程实现,深入理解和掌握常见的数据结构,如线性表、栈、队列等,并能够运用所学知识解决实际问题。
二、实验环境本次实验使用的编程环境为Visual Studio 2019,编程语言为C++。
三、实验内容与步骤(一)线性表的实现与操作1、顺序表的实现定义一个固定大小的数组来存储线性表的元素。
实现插入、删除、查找等基本操作。
2、链表的实现定义链表节点结构体,包含数据域和指针域。
实现链表的创建、插入、删除、遍历等操作。
(二)栈的实现与应用1、栈的实现使用数组或链表实现栈的数据结构。
实现入栈、出栈、栈顶元素获取等操作。
2、栈的应用利用栈实现表达式求值。
(三)队列的实现与应用1、队列的实现使用循环数组或链表实现队列。
实现入队、出队、队头元素获取等操作。
2、队列的应用模拟银行排队系统。
四、实验结果与分析(一)线性表1、顺序表插入操作:在指定位置插入元素时,需要移动后续元素,时间复杂度为 O(n)。
删除操作:删除指定位置的元素时,同样需要移动后续元素,时间复杂度为 O(n)。
查找操作:可以直接通过索引访问元素,时间复杂度为 O(1)。
2、链表插入操作:只需修改指针,时间复杂度为 O(1)。
删除操作:同样只需修改指针,时间复杂度为 O(1)。
查找操作:需要遍历链表,时间复杂度为 O(n)。
(二)栈1、表达式求值能够正确计算简单的四则运算表达式,如 2 + 3 4。
对于复杂表达式,如(2 + 3) 4,也能得到正确结果。
(三)队列1、银行排队系统模拟了客户的到达、排队和服务过程,能够反映出队列的先进先出特性。
五、实验中遇到的问题及解决方法(一)线性表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、线性表在做元素寻找的操作的时候,必须从头结点开始寻找。
数据结构实验一(完整版)

数据结构实验一:线性表实验报告#include <string.h>#include <ctype.h>#include <malloc.h> // malloc()等#include <limits.h> // INT_MAX等#include <stdio.h> // EOF(=^Z或F6),NULL#include <stdlib.h> // atoi()#include <io.h> // eof()#include <math.h> // floor(),ceil(),abs()#include <process.h> // exi t()#include <iostream.h> // cout,cin// 函数结果状态代码#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1// #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK等typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSEtypedef int ElemType;#define LIST_INIT_SIZE 10 // 线性表存储空间的初始分配量#define LISTINCREMENT 2 // 线性表存储空间的分配增量struct SqListElemType *elem; // 存储空间基址int length; // 当前长度int listsize; // 当前分配的存储容量(以sizeof(ElemType)为单位)};/**********************************************************/ /* 顺序表示的线性表的基本操作(12个) *//**********************************************************/ Status InitList(SqList &L){ // 操作结果:构造一个空的顺序线性表---------------1L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L.elem)exit(OVERFLOW); // 存储分配失败L.length=0; // 空表长度为0L.listsize=LIST_INIT_SIZE; // 初始存储容量return OK;}Status DestroyList(SqList &L){ // 初始条件:顺序线性表L已存在。
数据结构实验报告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、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
数据结构实验报告
实验名称:实验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,返回n
b 、代码实现
void Linklist::Getlength()Linklist();
cout<<endl;
}
3. 程序运行结果
1.测试主函数流程:
2、运行结果
4. 总结
调试时出现的问题及解决的方法:在设计将x按顺序插入的函数时,没有分清p->next->next->data和 p->next->data的区别,通过认真查阅和理解书本知识解决。
心得体会:了解了单链表的基本的操作函数实现,对链式存储结构有了较好的认识
下一步的改进:增加程序的可读性,注意注释的添加。