太原理工数据结构实验报告 实验一 顺序表

合集下载

数据结构实验一顺序表实验报告

数据结构实验一顺序表实验报告

数据结构实验一顺序表实验报告
数据结构是计算机科学中的一门基础课程,在学习数据结构的过程中,顺序表是我们必须深入了解和掌握的重要数据结构之一。

在实验一中,我们对顺序表进行了一系列的操作,实现了增删改查等基本操作。

我们先来介绍一下顺序表的基本概念。

顺序表是将线性表中的数据存储在一段连续的存储空间中的数据结构,其查找效率高,但插入和删除操作效率较低。

顺序表需要预先分配一定的存储空间,当存储空间不足时需要进行动态扩容,即重新申请更大的存储空间并将原有数据复制到新的存储空间中。

在实验中,我们首先学习了顺序表的实现方式,包括顺序表的结构体定义、创建顺序表、插入元素、删除元素、修改元素以及查询元素等基本操作。

我们通过 C 语言来实现了这些操作,并将其封装成一个顺序表的 API,使其更加易于使用和维护。

在实验过程中,我们还发现顺序表中数据的存储顺序非常重要,因为顺序表中元素的存储顺序与元素的下标是一一对应的,如果存储的顺序错误,可能会导致元素的下标与我们想象中的不一致,从而造成一些意想不到的结果。

总的来说,实验一帮助我们更深入地了解了顺序表的实现方式和基本操作,同时也挖掘出了一些潜在问题,这对于我们今后的学习和实践都起到了很大的帮助。

数据结构实验一_顺序表的基本操作实验报告

数据结构实验一_顺序表的基本操作实验报告

实验一顺序表的基本操作一、实验目的掌握线性表的顺序表基本操作:建立、插入、删除、查找、合并、打印等运算。

二、实验要求包含有头文件和main函数;1.格式正确,语句采用缩进格式;2.设计子函数实现题目要求的功能;3.编译、连接通过,熟练使用命令键;4.运行结果正确,输入输出有提示,格式美观。

三、实验设备、材料和工具1.奔腾2计算机或以上机型2.turboc2,win-tc四、实验内容和步骤1. 建立一个含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。

2. 往该顺序表中第i位置插入一个值为x的数据元素。

3. 从该顺序表中第j位置删除一个数据元素,由y返回。

4. 从该顺序表中查找一个值为e的数据元素,若找到则返回该数据元素的位置,否则返回“没有找到”。

五、程序#include<stdio.h>#include<stdlib.h>#define list_init_size 10#define increment 2typedef struct {int *elem;int length,listsize;}sqlist; //类型定义void initlist_sq(sqlist &L) //初始化顺序表{ }void output(sqlist L) //输出顺序表{ }void insertlist(sqlist &L,int i, int x) //顺序表中插入x{ }void deletelist(sqlist &L,int j, int y) //顺序表中删除y{ }int locateelem(sqlist &L,int e) //顺序表中查找e{ }void main(){ }【运行结果】void initlist_sq(sqlist &L) //初始化顺序表{L.elem=(int*)malloc(LIST_INIT_SIZE*sizeof(int));if(!L.elem) exit (OVERFLOW);L.length=0;L.listsize=LIST_INIT_SIZE;return OK;}void output(sqlist L) //输出顺序表{for(int i=0;i<=L.length-1;i++)printf("%d,",L.elem[i]);return OK;}void insertlist(sqlist &L,int i, int x) //顺序表中插入x{int p,q;if(i<1||i>L.length+1)return ERROR;if(L.length>=L.listsize){newbase=(int*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(int));if(!newbasde)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;*p=x;++L.length;return ok;}void deletelist(sqlist &L,int j, int y) //顺序表中删除y{int p,q;if(i<1||I>L.length+1) return ERROR;p=&(L.elem[i-1]);y=*p;q=L.elem+L.length-1;for(++p;p<=q;++p)*(p-1)=*p;--L.length;return ok;}int locateelem(sqlist &L,int e) //顺序表中查找e { int p;i=1;p=L.elem;while(i<=L.length&&!(*p++,e))++i;if(i<=L.length) return i;else return 0;}void main(){int d,p,a,b;int c;initlist_sq(&L);output( L);insertlist( &L, d, a);deletelist( &L, p, b);locateelem( &L, c);}。

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

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

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

数据结构 实验1顺序表和链表基本操作

数据结构   实验1顺序表和链表基本操作

实验一:线性表运算的实现一、实验预备知识1 复习C++中编写函数的相关内容。

2 复习如何用主函数将多个函数连在一起构成一个C++完整程序。

二、实验目的1 掌握线性表的顺序和链式存储结构2 熟练运用线性表在顺序存储方式下的初始化、创建、输出、插入和删除运算3 熟练运用线性表在链式存储方式下的创建、输出、插入和删除运算三、实验要求1 编写初始化并创建线性表和输出线性表的算法。

2 编写对线性表插入和删除运算算法,要判断位置的合法性和溢出问题。

3 编写一个主函数,将上面函数连在一起,构成一个完整的程序。

4将实验源程序调试并运行,写出输入、输出结果,并对结果进行分析。

四、实验步骤顺序表实验内容:1.给定的线性表为L=(12,25,7,42,19,38),元素由键盘输入。

2.初始化并建立顺序表。

3.编写顺序表输出算法。

(内存中开辟的单元数为8)4.依次插入3,21,15三个数,分别插入在第4,6和2位置,每插入一次都要输出一次顺序表。

5.删除第5,第3和第12个位置上的元素,每删除一个元素都要输出一次顺序表。

单链表实验内容:1.给定的线性表为L=(12,25,7,42,19,38),元素由键盘输入。

2.建立一个带表头结点的单链表(前插入法和尾插入法都可以)。

3.编写单链表输出算法。

4.依次插入3,21,15三个数,分别插入在第4,6和12位置,每插入一次都要输出一次单链表。

5.删除第5,第3和第12个位置上的元素,每删除一个元素都要输出一次单链表。

五、实验程序1..顺序表A.源代码:#include<iostream>const int Maxsize=20;typedef int DataType;typedef struct Seqlist{DataType data[Maxsize];int last;}Seqlist;using namespace std;Seqlist *InitList(){Seqlist *L;L=new Seqlist;if(L){L->last=0;return L;}else{cout<<"申请空间失败!"<<endl;return NULL;}}V oid Input_List(Seqlist *L){for(int i=0;i<6;i++)cin>>L->data[i];L->last+=6;}void Output_List(Seqlist *L){cout<<"当前表中存储数据如下:"<<endl;for(int i=0;i<L->last;i++)cout<<L->data[i]<<" ";cout<<endl;}int Ins_List(Seqlist *L,int i,DataType x){if(L->last==Maxsize-1){cout<<"对不起,当前表中可用空间已满!"<<endl;return -1;}I f(i<1||i>=L->last){cout<<"插入位置错误!"<<endl;return 0;}int j;for(j=L->last;j>=i-1;j--)L->data[j+1]=L->data[j];L->data[i-1]=x;L->last++;return 1;}void delete_List(Seqlist*L,int i){if(i<1||i>=L->last){cout<<"输入位置错误!"<<endl;return ;}else{for(int j=i-1;j<L->last;j++){L->data[j]=L->data[j+1];}L->last--;}}void main(){Seqlist *L;int j;DataType x;L=InitList();cout<<"请输入表中元素:"<<endl;Input_List(L);Output_List(L);cout<<"请输入插入元素的位置及其数值:"<<endl;for(int i=0;i<3;i++){cout<<"插入位置:";cin>>j;cout<<"元素数值:";cin>>x;Ins_List(L,j,x);Output_List(L);}cout<<"请输入要删除元素所在位置:"<<endl;for(i=0;i<3;i++){cout<<"元素位置:";cin>>j;delete_List(L,j);Output_List(L);}delete L;}B.运行结果示意图:2.链表A.源代码:#include<iostream>typedef int DataType;typedef struct LNode{DataType date;LNode *next;}*Linklist;int Lenth_list(LNode*);using namespace std;Linklist Creat_list(){LNode *H;H=NULL;DataType num;Linklist l,r;cout<<"请输入链表L,输入0结束输入:"<<endl;do{cin>>num;l=new LNode;if(l){if(H==NULL){l->date=num;l->next=NULL;H=l;r=l;}else{l->date=num;l->next=NULL;r->next=l;r=l;}}else{cout<<"申请空间失败!"<<endl;return NULL;}}while(num);return H;}void Output_list(LNode *H){cout<<"当前链表中所存储数据如下:"<<endl;LNode *p;p=H;while(p->next!=NULL){cout<<p->date<<" ";p=p->next;}cout<<endl;}void Ins_list(Linklist &H,int i,DataType x){if(i>Lenth_list(H)+1||i<1){cout<<"插入位置错误!"<<endl;return;}else{Linklist p,s;p=H;for(int j=0;j<i-2;j++)p=p->next;s=new LNode;if(s){if(i==1){s->date=x;s->next=H;H=s;}else{s->date=x;s->next=p->next;p->next=s;return;}}else{cout<<"申请失败!"<<endl;return;}}}int Lenth_list(LNode *H){if(H==NULL)return 0;else{Linklist p;int i=1;p=H;while(p->next!=NULL){p=p->next;i++;}return i;}}Linklist Delete_list(Linklist &H,int i){if(i>Lenth_list(H)||i<1){cout<<"位置错误!"<<endl;return NULL;}else{Linklist p,s;p=H;for(int j=0;j<i-2;j++)p=p->next;if(i==1){p=H;H=H->next;return p;}else{s=p->next;p->next=p->next->next;return s;}}}void main(){int i=0;DataType num=0;LNode *H;H=Creat_list();Output_list(H);cout<<"请输入插入元素的位置及其数值:"<<endl;for(int j=0;j<3;j++){cout<<"位置:";cin>>i;cout<<"数值:";cin>>num;Ins_list(H,i,num);Output_list(H);}cout<<"请输入删除元素所在位置:"<<endl;for(j=0;j<3;j++){cout<<"元素位置:";cin>>i;Delete_list(H,i);Output_list(H);}}B.运行结果示意图:六、总结本次实验是数据结构这门课程的第一次上机实验课,由于上课前未能很好地预习,以至于课上不能够完全明白老师所讲内容。

实验报告一 顺序表的操作

实验报告一 顺序表的操作

《数据结构》实验报告一系别:班级:学号:姓名:日期:指导教师:一、上机实验的问题和要求:顺序表的查找、插入与删除。

设计算法,实现线性结构上的顺序表的产生以及元素的查找、插入与删除。

具体实现要求:从键盘输入10个整数,产生顺序表,并输入结点值。

从键盘输入1个整数,在顺序表中查找该结点的位置。

若找到,输出结点的位置;若找不到,则显示“找不到”。

从键盘输入2个整数,一个表示欲插入的位置i,另一个表示欲插入的数值x,将x插入在对应位置上,输出顺序表所有结点值,观察输出结果。

从键盘输入1个整数,表示欲删除结点的位置,输出顺序表所有结点值,观察输出结果。

二、程序设计的基本思想,原理和算法描述:(包括程序的结构,数据结构,输入/输出设计,符号名说明等)三、源程序及注释:#include <stdio.h>/*顺序表的定义:*/#define ListSize 100 /*表空间大小可根据实际需要而定,这里假设为100*/ typedef int DataType; /*DataType可以是任何相应的数据类型如int, float或char*/ typedef struct{ DataType data[ListSize]; /*向量data用于存放表结点*/int length; /*当前的表长度*/}SeqList;/*子函数的声明*/void CreateList(SeqList * L,int n); /*创建顺序表函数*/int LocateList(SeqList L,DataType x); /*查找顺序表*/void InsertList(SeqList * L,DataType x,int i); /*在顺序表中插入结点x*/void DeleteList(SeqList * L,int i);/*在顺序表中删除第i个结点*/void PrintList(SeqList L,int n); /*打印顺序表中前n个结点*/void main(){SeqList L;int n=10,x,i; /*欲建立的顺序表长度*/L.length=0;/*调用创建线性表函数*/printf("create function:\n");CreateList(&L,n); /*建立顺序表*/PrintList(L,n); /*打印顺序表*//*调用查找函数*/printf("search function:\n");printf("input the data you want to search:");scanf("%d",&x);i=LocateList(L,x); /*顺序表查找*/if (i==0)printf("sorry,don't find %d!\n\n",x);elseprintf("i have find the %d,it locate in %d!\n\n",x,i);/*调用插入函数*/printf("Insert function:\n");printf("输入要插入的位置:(input the position:)");scanf("%d",&i);printf("输入要插入的元素:(input the data:)");scanf("%d",&x);InsertList(&L,x,i); /*顺序表插入 */PrintList(L,n); /*打印顺序表 *//*调用删除函数*/printf("delete function:\n");printf("输入要删除的位置:(input the position:)");scanf("%d",&i);DeleteList(&L,i); /*顺序表删除 */PrintList(L,n); /*打印顺序表 */}/*顺序表的建立:*/void CreateList(SeqList *L,int n){ int i;for (i=0;i<n;i++){ printf("\ninput the %d data:",i+1);scanf("%d",&(*L).data[i]);}(*L).length=n;}/*顺序表的查找:*/int LocateList(SeqList L,DataType x){ int i=0;while (i<L.length&&x!=L.data[i])++i;if (i<L.length) return i+1;else return 0;}/*顺序表的插入:*/void InsertList(SeqList *L,DataType x,int i){/*将新结点x插入L所指的顺序表的第i个结点的位置上 */ int j;if (i<0||i>(*L).length){printf("插入位置非法");exit(0);}if ((*L).length>=ListSize){printf("表空间溢出,退出运行");exit(0);}for (j=(*L).length-1;j>=i-1;j--)(*L).data[j+1]=(*L).data[j]; /*顺序表元素从后向前依次后移*/ (*L).data[i-1]=x; /*将x插入第i个结点位置*/(*L).length++; /*表长自增1*/}/*顺序表的删除:*/void DeleteList(SeqList *L,int i){/*从L所指的顺序表中删除第i个结点 */int j;if (i<0 || i>(*L).length){printf("删除位置非法");exit(0);}for (j=i;j<=(*L).length-1;j++)(*L).data[j]=(*L).data[j+1]; /*顺序表自第i个结点开始,依次前移*/ (*L).length--; /*表长自减1*/}/*顺序表的打印:*/void PrintList(SeqList L,int n){ int i;printf("the sequal list data is:");for (i=0;i<n;i++)printf("%d ",L.data[i]);printf("\n\n");}四、运行输出结果:五、调试和运行程序过程中产生的问题及采取的措施:六、对算法的程序的讨论、分析,改进设想,其它经验教训:七、对实验方式、组织、设备、题目的意见和建议:。

实验一顺序表的基本操作实验报告

实验一顺序表的基本操作实验报告

元素之后的所有数据都前移一个位置,最将线性表长减1。

3.顺序表查找操作的基本步骤:要在顺序表中查找一个给定值的数据元素则可以采用顺序查找的方法,从表中第 1 个数据元素开始依次将值与给定值进行比较,若相等则返回该数据元素在顺序表中的位置,否则返回0 值。

线性表的动态分配顺序存储结构—C语言实现#define MaxSize 50//存储空间的分配量Typedef char ElemType;Typedef struct{ElemType data[MaxSize];int length; //表长度(表中有多少个元素)}SqList;动态创建一个空顺序表的算法:void InitList(SqList *&L) //初始化线性表{L=(SqList *)malloc(sizeof(SqList)); //分配存放线性表的空间L->length=0; //置空线性表长度为0}线性表的插入:status Sqlist_insert(Sqlist &L,int i,Elemtype x)/*在顺序表L中第i个元素前插入新元素x*/{ if (i<1||i>L.length+1) return ERROR; /*插入位置不正确则出错*/if (L.length>=MAXLEN)return OVERFLOW;/*顺序表L中已放满元素,再做插入操作则溢出*/for(j=L.length-1;j>=i-1;j--)L.elem[j+1]=L.elem[j]; /*将第i个元素及后续元素位置向后移一位*/L.elem[i-1]=x; /*在第i个元素位置处插入新元素x*/L.length++; /*顺序表L的长度加1*/return OK;}线性表的删除:status Sqlist_delete(Sqlist &L,int i,Elemtype &e)/*在顺序表L中删除第i个元素*{ if (i<1||i>L.length) return ERROR; /*删除位置不正确则出错*/for(j=i;j<=L.length-1;j++)L.elem[j-1]=L.elem[j]; /*将第i+1个元素及后继元素位置向前移一位*/L.length--;/*顺序表L的长度减1*/return OK;}线性表元素的查找:int LocateElem(SqList *L, ElemType e) //按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++; //查找元素eif (i>=L->length) //未找到时返回0return 0;elsereturn i+1; //找到后返回其逻辑序号}输出线性表:void DispList(SqList *L) //输出线性表{int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c ",L->data[i]);printf("\n");}输出线性表第i个元素的值:bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false; //参数错误时返回falsee=L->data[i-1]; //取元素值return true; //成功找到元素时返回true}代码:#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType data[MaxSize];int length;} SqList;void InitList(SqList *&L);void DestroyList(SqList *L);bool ListEmpty(SqList *L);int ListLength(SqList *L);void DispList(SqList *L);bool GetElem(SqList *L,int i,ElemType &e);int LocateElem(SqList *L, ElemType e);bool ListInsert(SqList *&L,int i,ElemType e);bool ListDelete(SqList *&L,int i,ElemType &e);void InitList(SqList *&L)//初始化线性表{L=(SqList *)malloc(sizeof(SqList));//分配存放线性表的空间L->length=0;//置空线性表长度为0 }void DestroyList(SqList *L)//销毁线性表{free(L);}bool ListEmpty(SqList *L)//判线性表是否为空表{return(L->length==0);}int ListLength(SqList *L)//求线性表的长度{return(L->length);}void DispList(SqList *L)//输出线性表{int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c ",L->data[i]);printf("\n");}bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false;//参数错误时返回falsee=L->data[i-1];//取元素值return true;//成功找到元素时返回true}int LocateElem(SqList *L, ElemType e)//按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++;//查找元素eif (i>=L->length)//未找到时返回0return 0;elsereturn i+1;//找到后返回其逻辑序号}bool ListInsert(SqList *&L,int i,ElemType e)//插入数据元素{int j;if (i<1 || i>L->length+1)return false;//参数错误时返回falsei--;//将顺序表逻辑序号转化为物理序号for (j=L->length;j>i;j--)//将data[i]及后面元素后移一个位置L->data[j]=L->data[j-1];L->data[i]=e;//插入元素eL->length++;//顺序表长度增1return true;//成功插入返回true}bool ListDelete(SqList *&L,int i,ElemType &e)//删除数据元素{int j;if (i<1 || i>L->length)//参数错误时返回falsereturn false;i--;//将顺序表逻辑序号转化为物理序号e=L->data[i];for (j=i;j<L->length-1;j++)//将data[i]之后的元素前移一个位置L->data[j]=L->data[j+1];L->length--;//顺序表长度减1return true;//成功删除返回true}void main(){SqList *L;ElemType e;printf("顺序表的基本运算如下:\n");printf(" (1)初始化顺序表L\n");InitList(L);printf(" (2)依次采用尾插法插入a,b,c,d,e元素\n");ListInsert(L,1,'a');ListInsert(L,2,'b');ListInsert(L,3,'c');ListInsert(L,4,'d');ListInsert(L,5,'e');printf(" (3)输出顺序表L:");DispList(L);printf(" (4)顺序表L长度=%d\n",ListLength(L));printf(" (5)顺序表L为%s\n",(ListEmpty(L)?"空":"非空"));GetElem(L,3,e);printf(" (6)顺序表L的第3个元素=%c\n",e);实验结果:心得体会:通过本次实验,实现了数据结构在程序设计上的作用,了解了数据结构语言,加深了对c语言的认识掌并掌握了线性表的顺序存储结构的表示和实现方法,掌握顺序表基本操作的算法实现,同时了解了顺序表的应用。

太原理工数据结构实验报告完整版

太原理工数据结构实验报告完整版

实验名称:线性表一.目的与要求本次实习的主要目的是为了使学生熟练掌握线性表的基本操作在顺序存储结构和链式存储结构上的实现,提高分析和解决问题的能力。

要求仔细阅读并理解下列例题,上机通过,并观察其结果,然后独立完成后面的实习题。

二.例题[问题描述]用链表形式存储一个字符串,插入、删除某个字符,最后按正序、逆序两种方式输出字符串。

[输入]初始字符串,插入位置,插入字符,删除字符。

[输出]已建立链表(字符串),插入字符后链表,删除字符后链表,逆转后链表。

[存储结构]采用链式存储结构[算法的基本思想]建立链表:当读入字符不是结束符时,给结点分配存储空间,写数据域,将新结点插到表尾;插入字符:根据读入的字符在链表中找插入位置,将新结点插入到该位置之前;删除字符:根据读入的删除字符在链表中找到被删结点后,将其从链表中删除;链表逆转:从链表的第一个结点开始对所有结点处理,将每个结点的前驱变为它的后继;打印链表:从链表的第一个结点开始,依次打印各个结点的数据域。

[参考源程序]#define NULL 0typedef struct node{char a;struct node *link;}node,*nodelink;void readlink(nodelink head){nodelink p,q;char c;p=head;printf("Input a linktable(a string):");scanf("%c",&c);if (c=='\n') printf("This string is empty。

");while(c!='\n'){q=(nodelink)malloc(sizeof(node));q->a=c;p->link=q;p=q;scanf("%c",&c);}p->link=NULL;}void writelink(nodelink head){nodelink q;if (head->link==NULL) printf(" This link is empty。

数据结构-顺序表-实验报告

数据结构-顺序表-实验报告

实验报告课程数据结构及算法实验项目 1.顺序表的建立和基本运算成绩专业班级*** 指导教师***姓名*** 学号*** 实验日期***实验一顺序表的建立和基本运算一、实验目的1、掌握顺序表存储结构的定义及C/C++语言实现2、掌握顺序表的各种基本操作及C/C++语言实现3、设计并实现有序表的遍历、插入、删除等常规算法二、实验环境PC微机,Windows,DOS,Turbo C或者Visual C++三、实验内容1、顺序表的建立和基本运算(1)问题描述顺序表时常进行的运算包括:创建顺序表、销毁顺序表、求顺序表的长度、在顺序表中查找某个数据元素、在某个位置插入一个新数据元素、在顺序表中删除某个数据元素等操作。

试编程实现顺序表的这些基本运算。

(2)基本要求实现顺序表的每一个运算要求用一个函数实现。

(3)算法描述参见教材算法2.3、算法2.4、算法2.5等顺序表的常规算法。

(4)算法实现#include<malloc.h> // malloc()等#include<stdio.h> // NULL, printf()等#include<process.h> // exit()// 函数结果状态代码#define OVERFLOW -2#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK等typedef int Boolean; // Boolean是布尔类型,其值是TRUE或者FALSE//-------- 线性表的动态分配顺序存储结构-----------#define LIST_INIT_SIZE 10 // 线性表存储空间的初始分配量#define LIST_INCREMENT 2 // 线性表存储空间的分配增量typedef int ElemType;struct SqList{ElemType *elem; // 存储空间基址int length; // 当前长度int listsize; // 当前分配的存储容量(以sizeof(int)为单位)};void InitList(SqList &L) // 算法2.3{ // 操作结果:构造一个空的顺序线性表LL.elem=new ElemType[LIST_INIT_SIZE];if(!L.elem)exit(OVERFLOW); // 存储分配失败L.length=0; // 空表长度为0L.listsize=LIST_INIT_SIZE; // 初始存储容量}void DestroyList(SqList &L){ // 初始条件:顺序线性表L已存在。

数据结构实验一顺序表实验报告

数据结构实验一顺序表实验报告

数据结构实验一顺序表实验报告一、实验目的本次实验的主要目的是通过实现顺序表的基本操作,深入理解线性表的逻辑结构和存储结构,掌握顺序表的插入、删除、查找等操作的实现方法,提高编程能力和问题解决能力。

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

三、实验原理顺序表是一种线性表的存储结构,它使用一组连续的存储单元依次存储线性表中的元素。

在顺序表中,元素的逻辑顺序与物理顺序是一致的。

顺序表的基本操作包括初始化、插入、删除、查找、遍历等。

在实现这些操作时,需要考虑顺序表的存储空间是否已满、插入和删除元素时元素的移动等问题。

四、实验内容(一)顺序表的定义```cdefine MAXSIZE 100 //定义顺序表的最大长度typedef struct {int dataMAXSIZE; //存储顺序表的元素int length; //顺序表的当前长度} SeqList;```(二)顺序表的初始化```cvoid InitList(SeqList L) {L>length = 0;}```(三)顺序表的插入操作```cint InsertList(SeqList L, int i, int e) {if (L>length == MAXSIZE) {//顺序表已满return 0;}if (i < 1 || i > L>length + 1) {//插入位置不合法return 0;}for (int j = L>length; j >= i; j) {//移动元素L>dataj = L>dataj 1;}L>datai 1 = e; //插入元素L>length++;return 1;}```(四)顺序表的删除操作```cint DeleteList(SeqList L, int i, int e) {if (L>length == 0) {//顺序表为空return 0;}if (i < 1 || i > L>length) {//删除位置不合法}e = L>datai 1; //取出被删除的元素for (int j = i; j < L>length; j++){//移动元素L>dataj 1 = L>dataj;}L>length;return 1;}```(五)顺序表的查找操作```cint SearchList(SeqList L, int e) {for (int i = 0; i < Llength; i++){if (Ldatai == e) {return i + 1;}}}```(六)顺序表的遍历操作```cvoid TraverseList(SeqList L) {for (int i = 0; i < Llength; i++){printf("%d ", Ldatai);}printf("\n");}```五、实验步骤1、打开 Visual Studio 2019,创建一个新的 C 语言项目。

数据结构实验一顺序表问题及实验报告模板 - Copy

数据结构实验一顺序表问题及实验报告模板 - Copy
else if (comp < 0) r = m - 1;
else l = m + 1;
}
return NONE;
}
public static void main(String[] args) {
String[] word1 = {"dog", "cat", "rat", "pig", "fox", "eel"};
for (int t = 0; t < testcases.length; t++) {
String target = testcases[t];
System.out.println(target
+ " " + linearSearch1(word1, left1, right1, target) + " "
}
public static int linearSearch2(Comparable[] a, int left, int right, Comparable val)
{
for (int i = left; i <= right; i++)
{ int comp = pareTo(a[i]);
String target = testcases[t];
System.out.println(target
+ " " + linearSearch1(word1, left1, right1, target) + " "
+ linearSearch2(word2, left2, right2, target)

数据结构实验一顺序表

数据结构实验一顺序表

数据结构实验一顺序表数据结构实验一1、实验目的掌握线性表的逻辑特征掌握线性表顺序存储结构的特点,熟练掌握顺序表的基本运算2、实验内容:建立顺序表,完成顺序表的基本操作:初始化、插入、删除、逆转、输出、销毁, 置空表、求表长、查找元素、判线性表是否为空;1.问题描述:利用顺序表,设计一组输入数据(假定为一组整数),能够对顺序表进行如下操作:创建一个新的顺序表,实现动态空间分配的初始化;根据顺序表结点的位置插入一个新结点(位置插入),也可以根据给定的值进行插入(值插入),形成有序顺序表;根据顺序表结点的位置删除一个结点(位置删除),也可以根据给定的值删除对应的第一个结点,或者删除指定值的所有结点(值删除);利用最少的空间实现顺序表元素的逆转;实现顺序表的各个元素的输出;彻底销毁顺序线性表,回收所分配的空间;对顺序线性表的所有元素删除,置为空表;返回其数据元素个数;按序号查找,根据顺序表的特点,可以随机存取,直接可以定位于第i 个结点,查找该元素的值,对查找结果进行返回;按值查找,根据给定数据元素的值,只能顺序比较,查找该元素的位置,对查找结果进行返回;判断顺序表中是否有元素存在,对判断结果进行返回;.编写主程序,实现对各不同的算法调用。

2.实现要求:“初始化算法”的操作结果:构造一个空的顺序线性表。

对顺序表的空间进行动态管理,实现动态分配、回收和增加存储空间;“位置插入算法”的初始条件:顺序线性表L 已存在,给定的元素位置为i,且1≤i≤ListLength(L)+1 ;操作结果:在L 中第i 个位置之前插入新的数据元素e,L 的长度加1;“位置删除算法”的初始条件:顺序线性表L 已存在,1≤i≤ListLength(L) ;操作结果:删除L 的第i 个数据元素,并用e 返回其值,L 的长度减1 ;“逆转算法”的初始条件:顺序线性表L 已存在;操作结果:依次对L 的每个数据元素进行交换,为了使用最少的额外空间,对顺序表的元素进行交换;“输出算法”的初始条件:顺序线性表L 已存在;操作结果:依次对L 的每个数据元素进行输出;“销毁算法”初始条件:顺序线性表L 已存在;操作结果:销毁顺序线性表L;“置空表算法”初始条件:顺序线性表L 已存在;操作结果:将L 重置为空表;“求表长算法”初始条件:顺序线性表L 已存在;操作结果:返回L 中数据元素个数;“按序号查找算法”初始条件:顺序线性表L 已存在,元素位置为i,且1≤i≤ListLength(L)操作结果:返回L 中第i 个数据元素的值“按值查找算法”初始条件:顺序线性表L 已存在,元素值为e;操作结果:返回L 中数据元素值为e 的元素位置;“判表空算法”初始条件:顺序线性表L 已存在;操作结果:若L 为空表,则返回TRUE,否则返回FALSE;分析: 修改输入数据,预期输出并验证输出的结果,加深对有关算法的理解。

数据结构实验报告顺序表1

数据结构实验报告顺序表1

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

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

三、顺序表的基本概念顺序表是用一组地址连续的存储单元依次存储线性表中的数据元素。

在顺序表中,逻辑上相邻的元素在物理位置上也相邻。

顺序表可以随机访问表中的任意元素,但插入和删除操作可能需要移动大量元素,效率较低。

四、顺序表的存储结构在 C++中,可以使用数组来实现顺序表。

以下是一个简单的顺序表存储结构的定义:```cppconst int MAX_SIZE = 100; //定义顺序表的最大容量class SeqList {private:int dataMAX_SIZE; //存储数据元素的数组int length; //顺序表的当前长度public:SeqList(){ length = 0; }//构造函数,初始化长度为 0//其他操作函数的声明int GetLength();bool IsEmpty();bool IsFull();int GetElement(int position);int LocateElement(int element);void InsertElement(int position, int element);void DeleteElement(int position);void PrintList();};```五、顺序表的基本操作实现1、获取顺序表长度```cppint SeqList::GetLength(){return length;}```2、判断顺序表是否为空```cppbool SeqList::IsEmpty(){return length == 0;}```3、判断顺序表是否已满```cppbool SeqList::IsFull(){return length == MAX_SIZE;}```4、获取指定位置的元素```cppint SeqList::GetElement(int position) {if (position < 1 || position > length) {std::cout <<"位置错误!"<< std::endl; return -1;}return dataposition 1;}```5、查找指定元素在顺序表中的位置```cppint SeqList::LocateElement(int element) {for (int i = 0; i < length; i++){if (datai == element) {return i + 1;}}return -1; //未找到返回-1}```6、在指定位置插入元素```cppvoid SeqList::InsertElement(int position, int element) {if (IsFull()){std::cout <<"顺序表已满,无法插入!"<< std::endl; return;}if (position < 1 || position > length + 1) {std::cout <<"位置错误!"<< std::endl;return;}for (int i = length; i >= position; i) {datai = datai 1;}dataposition 1 = element;length++;}```7、删除指定位置的元素```cppvoid SeqList::DeleteElement(int position) {if (IsEmpty()){std::cout <<"顺序表为空,无法删除!"<< std::endl; return;}if (position < 1 || position > length) {std::cout <<"位置错误!"<< std::endl;return;}for (int i = position; i < length; i++){datai 1 = datai;}length;}```8、打印顺序表中的所有元素```cppvoid SeqList::PrintList(){for (int i = 0; i < length; i++){std::cout << datai <<"";}std::cout << std::endl;}```六、实验结果与分析1、对顺序表进行初始化,创建一个空的顺序表。

数据结构实验报告_太原理工大学软件学院

数据结构实验报告_太原理工大学软件学院
return OK;
}
int InserOrderList(SqList *L,int e){
int i;
if((L->length)>=(L->listsize)){
int *newbase;
newbase=(int *)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(int));
《数据结构》实验报告
专业:软件工程
班级:13XX班
姓名:X X X
2014年12月
太原理工大学学生实验报告
学院名称
软件学院
专业班级
软件13XX班
学号
201300XXXX
实验成绩
学生姓名
XXX
同组人姓名
实验日期
11.12
课程名称
数据结构
实验题目
实验一线性表
实验记录:
1.设顺序表A中的数据元素递增有序,试写一程序,将x插入到顺序表的适当位置上,使该表仍然有序。
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;
L->length++;
return OK;
}
void main(){

数据结构实验报告-实验一顺序表、单链表基本操作的实现

数据结构实验报告-实验一顺序表、单链表基本操作的实现

数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现l 实验⽬的1、顺序表(1)掌握线性表的基本运算。

(2)掌握顺序存储的概念,学会对顺序存储数据结构进⾏操作。

(3)加深对顺序存储数据结构的理解,逐步培养解决实际问题的编程能⼒。

l 实验内容1、顺序表1、编写线性表基本操作函数:(1)InitList(LIST *L,int ms)初始化线性表;(2)InsertList(LIST *L,int item,int rc)向线性表的指定位置插⼊元素;(3)DeleteList1(LIST *L,int item)删除指定元素值的线性表记录;(4)DeleteList2(LIST *L,int rc)删除指定位置的线性表记录;(5)FindList(LIST *L,int item)查找线性表的元素;(6)OutputList(LIST *L)输出线性表元素;2、调⽤上述函数实现下列操作:(1)初始化线性表;(2)调⽤插⼊函数建⽴⼀个线性表;(3)在线性表中寻找指定的元素;(4)在线性表中删除指定值的元素;(5)在线性表中删除指定位置的元素;(6)遍历并输出线性表;l 实验结果1、顺序表(1)流程图(2)程序运⾏主要结果截图(3)程序源代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList/*定义线性表结构*/{int *list; /*存线性表元素*/int size; /*存线性表长度*/int Maxsize; /*存list数组元素的个数*/};typedef struct LinearList LIST;void InitList(LIST *L,int ms)/*初始化线性表*/{if((L->list=(int*)malloc(ms*sizeof(int)))==NULL){printf("内存申请错误");exit(1);}L->size=0;L->Maxsize=ms;}int InsertList(LIST *L,int item,int rc)/*item记录值;rc插⼊位置*/ {int i;if(L->size==L->Maxsize)/*线性表已满*/return -1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)/*将线性表元素后移*/L->list[i+=1]=L->list[i];L->list[rc]=item;L->size++;return0;}void OutputList(LIST *L)/*输出线性表元素*/{int i;printf("%d",L->list[i]);printf("\n");}int FindList(LIST *L,int item)/*查找线性元素,返回值>=0为元素的位置,返回-1为没找到*/ {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item)/*删除指定元素值得线性表记录,返回值为>=0为删除成功*/ {int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;}int DeleteList2(LIST *L,int rc)/*删除指定位置的线性表记录*/{int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return0;}int main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.size,LL.Maxsize);printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.list,LL.Maxsize);while(1){printf("请输⼊元素值,输⼊0结束插⼊操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d",&i);if(i==0)break;printf("请输⼊插⼊位置:");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为:");OutputList(&LL);}while(1){printf("请输⼊查找元素值,输⼊0结束查找操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d ",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没有找到\n");elseprintf("有符合条件的元素,位置为:%d\n",r+1);}while(1){printf("请输⼊删除元素值,输⼊0结束查找操作:");fflush(stdin);/*清楚标准缓存区*/scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(i<0)printf("没有找到\n");else{printf("有符合条件的元素,位置为:%d\n线性表为:",r+1);OutputList(&LL);}while(1){printf("请输⼊删除元素位置,输⼊0结束查找操作:");fflush(stdin);/*清楚标准输⼊缓冲区*/scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为:");OutputList(&LL);}}}链表基本操作l 实验⽬的2、链表(1)掌握链表的概念,学会对链表进⾏操作。

数据结构顺序表操作实验报告

数据结构顺序表操作实验报告

实验1 顺序表的操作一、实验要求1.输入一组整型元素序列,建立顺序表。

2.实现该顺序表的遍历。

3.在该顺序表中进行顺序查找某一元素,查找成功返回1,否则返回0。

4.判断该顺序表中元素是否对称,对称返回1,否则返回0。

5.实现把该表中所有奇数排在偶数之前,即表的前面为奇数,后面为偶数。

6.* 输入整型元素序列利用有序表插入算法建立一个有序表。

7.* 利用算法6建立两个非递减有序表并把它们合并成一个非递减有序表。

8.编写一个主函数,调试上述算法。

二、源代码#include"stdio.h"#include"stdlib.h"#define ElemType int//int类型宏定义#define MAXSIZE 100//顺序结构typedef struct{ElemType elem[MAXSIZE]; //元素数组int length; //当前表长}SqList;//建立顺序表void BuildList(SqList &L){int n;printf("请输入建立顺序表的大小。

n=");scanf("%d",&n);L.length=n;printf("\n开始建立顺序表...\n");for(int i=0;i<L.length;i++)//循环建立顺序表{printf("\n请输入第%d个元素:",i+1);scanf("%d",&L.elem[i]);}printf("\n建立顺序表完毕!...\n");}//遍历顺序表void ShowList(SqList &L){int i;printf("\n开始遍历顺序表...\n");for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);printf("\n遍历结束...\n");}//在顺序表中寻找X元素int FindList(SqList &L,int x){int a=0;for(int i=0;i<L.length;i++){if(L.elem[i]==x)a=1;}if(a==1)printf("1\n");elseprintf("0\n");return 0;}//判断是否对称int Duichen(SqList &L){int j,b=1,n;n=L.length;if(n%2==0){for(j=0;j<n/2;j++){if(L.elem[j]!=L.elem[L.length-j-1])b=0;}}elsefor(j=0;j<(n-1)/2;j++){if(L.elem[j]!=L.elem[L.length-j-1])b=0;}if(b==1)printf("1\n");elseprintf("0\n");return 0;}//前面为奇数,后面为偶数void PaixuList(SqList &L){int i,j,a;for(i=1;i<L.length;i++){if(L.elem[i]%2==1){a=L.elem[i];for(j=i;j>0;j--){L.elem[j]=L.elem[j-1];}L.elem[0]=a;i++;}}for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);printf("\n");}int main(){SqList List;int n;while(1){printf("\n 实验一:顺序表\n");printf("\n******************************************************************");printf("\n 1.创建顺序表");printf("\n 2.遍历顺序表");printf("\n 3.在该顺序表中进行顺序查找某一元素,查找成功返回1,否则返回0");printf("\n 4.判断该顺序表中元素是否对称,对称返回1,否则返回0");printf("\n 5.该表中所有奇数排在偶数之前,即表的前面为奇数,后面为偶数");printf("\n 0.退出");printf("\n******************************************************************\n");printf("\n请输入选择序号:");scanf("%d",&n);switch(n){case 0:return 0;case 1:BuildList(List);break;case 2:ShowList(List);break;case 3:int X;printf("请输入要查找值:X=");scanf("%d",&X);FindList(List,X);break;case 4:Duichen(List);break;case 5:PaixuList(List);break;default:printf(" 请输入数字0-5 \n");}}return 0;}三、运行结果1)程序主界面2)选择1建立顺序表3)选择2遍历顺序表4)选择3查询元素X5)选择4判断是否对称6)选择5奇数在前,偶数在后7)选择0退出。

数据结构顺序表实验报告

数据结构顺序表实验报告

数据结构顺序表实验报告数据结构顺序表实验报告1.实验目的:本实验旨在通过实现顺序表的基本操作,加深对数据结构顺序表的理解,并掌握相关算法的实现方法。

2.实验环境:●操作系统:Windows 10●编程语言:C/C++●开发工具:Visual Studio Code3.实验内容:3.1 初始化顺序表●定义顺序表结构体●实现创建顺序表的函数●实现销毁顺序表的函数3.2 插入元素●实现在指定位置插入元素的函数●实现在表尾插入元素的函数3.3 删除元素●实现删除指定位置元素的函数●实现删除指定值元素的函数3.4 查找元素●实现按值查找元素的函数●实现按位置查找元素的函数3.5 修改元素●实现修改指定位置元素的函数3.6 打印顺序表●实现打印顺序表中所有元素的函数4.实验步骤:4.1 初始化顺序表●定义顺序表结构体,并分配内存空间●初始化顺序表中的数据和长度4.2 插入元素●调用插入元素函数,在指定位置或表尾插入元素4.3 删除元素●调用删除元素函数,删除指定位置或指定值的元素4.4 查找元素●调用查找元素函数,按值或位置查找元素4.5 修改元素●调用修改元素函数,修改指定位置的元素4.6 打印顺序表●调用打印顺序表函数,输出顺序表中的所有元素5.实验结果:经过测试,顺序表的基本操作均能正确执行。

插入元素、删除元素、查找元素、修改元素和打印顺序表等功能都能正常运行。

6.实验总结:本实验通过实现顺序表的基本操作,巩固了对数据结构顺序表的理论知识,并加深了对算法的理解和应用能力。

顺序表是一种简单、易于实现的数据结构,适用于元素数量变化较少的情况下。

7.附件:无8.法律名词及注释:●顺序表:一种基本的线性数据结构,数据元素按照其逻辑位置依次存储在一片连续的存储空间中。

●初始化:为数据结构分配内存空间并进行初始化,使其具备基本的数据存储能力。

●插入元素:将一个新元素插入到已有元素的合适位置,使得数据结构保持有序或符合特定要求。

数据结构实验一顺序表实验报告

数据结构实验一顺序表实验报告

数据结构实验一顺序表实验报告数据结构实验一顺序表实验报告一、实验目的顺序表是一种基本的数据结构,本次实验的目的是通过实现顺序表的基本操作,加深对顺序表的理解,并掌握顺序表的插入、删除、查找等操作的实现方法。

二、实验内容1. 实现顺序表的创建和初始化操作。

2. 实现顺序表的插入操作。

3. 实现顺序表的删除操作。

4. 实现顺序表的查找操作。

5. 实现顺序表的输出操作。

三、实验步骤1. 创建顺序表的数据结构,包括数据存储数组和记录当前元素个数的变量。

2. 初始化顺序表,将当前元素个数置为0。

3. 实现顺序表的插入操作:- 判断顺序表是否已满,若已满则输出错误信息。

- 将插入位置之后的元素依次后移一位。

- 将要插入的元素放入插入位置。

- 当前元素个数加一。

4. 实现顺序表的删除操作:- 判断顺序表是否为空,若为空则输出错误信息。

- 判断要删除的位置是否合法,若不合法则输出错误信息。

- 将删除位置之后的元素依次前移一位。

- 当前元素个数减一。

5. 实现顺序表的查找操作:- 遍历顺序表,逐个比较元素值与目标值是否相等。

- 若找到目标值,则返回该元素的位置。

- 若遍历完整个顺序表仍未找到目标值,则返回错误信息。

6. 实现顺序表的输出操作:- 遍历顺序表,逐个输出元素值。

四、实验结果经过实验,顺序表的各项操作均能正确实现。

在插入操作中,可以正确将元素插入到指定位置,并将插入位置之后的元素依次后移。

在删除操作中,可以正确删除指定位置的元素,并将删除位置之后的元素依次前移。

在查找操作中,可以正确返回目标值的位置。

在输出操作中,可以正确输出顺序表中的所有元素。

五、实验总结通过本次实验,我深入了解了顺序表的原理和基本操作,并通过实际编程实现了顺序表的各项功能。

在实验过程中,我遇到了一些问题,如如何判断顺序表是否已满或为空,如何处理插入和删除位置的合法性等。

通过查阅资料和与同学讨论,我解决了这些问题,并对顺序表的操作有了更深入的理解。

数据结构实验报告顺序表

数据结构实验报告顺序表

数据结构实验报告顺序表数据结构实验报告:顺序表摘要:顺序表是一种基本的数据结构,它通过一组连续的存储单元来存储线性表中的数据元素。

在本次实验中,我们将通过实验来探索顺序表的基本操作和特性,包括插入、删除、查找等操作,以及顺序表的优缺点和应用场景。

一、实验目的1. 理解顺序表的概念和特点;2. 掌握顺序表的基本操作;3. 了解顺序表的优缺点及应用场景。

二、实验内容1. 实现顺序表的初始化操作;2. 实现顺序表的插入操作;3. 实现顺序表的删除操作;4. 实现顺序表的查找操作;5. 对比顺序表和链表的优缺点;6. 分析顺序表的应用场景。

三、实验步骤与结果1. 顺序表的初始化操作在实验中,我们首先定义了顺序表的结构体,并实现了初始化操作,即分配一定大小的存储空间,并将表的长度设为0,表示表中暂时没有元素。

2. 顺序表的插入操作接下来,我们实现了顺序表的插入操作。

通过将插入位置后的元素依次向后移动一位,然后将新元素插入到指定位置,来实现插入操作。

我们测试了在表中插入新元素的情况,并验证了插入操作的正确性。

3. 顺序表的删除操作然后,我们实现了顺序表的删除操作。

通过将删除位置后的元素依次向前移动一位,来实现删除操作。

我们测试了在表中删除元素的情况,并验证了删除操作的正确性。

4. 顺序表的查找操作最后,我们实现了顺序表的查找操作。

通过遍历表中的元素,来查找指定元素的位置。

我们测试了在表中查找元素的情况,并验证了查找操作的正确性。

四、实验总结通过本次实验,我们对顺序表的基本操作有了更深入的了解。

顺序表的插入、删除、查找等操作都是基于数组的操作,因此在插入和删除元素时,需要移动大量的元素,效率较低。

但是顺序表的优点是可以随机访问,查找效率较高。

在实际应用中,顺序表适合于元素数量不变或变化不大的情况,且需要频繁查找元素的场景。

综上所述,顺序表是一种基本的数据结构,我们通过本次实验对其有了更深入的了解,掌握了顺序表的基本操作,并了解了其优缺点及应用场景。

数据结构实验报告-顺序表的创建、遍历及有序合并操作

数据结构实验报告-顺序表的创建、遍历及有序合并操作

二、实验内容与步骤实现次序表的创立、遍历及有序归并操作,基本数据构造定义如下:typedef int ElemType;#define MAXSIZE 100#define FALSE 0#define TRUE 1typedef struct{ElemType data[MAXSIZE];int length;}seqlist;创立次序表,遍历次序表#include<>#include<>#define MAXSIZE 100#define Icreament 20#define FALSE 0#define TRUE 1typedef int ElemType; //用户自定义数据元素种类//次序表构造体的定义typedef struct{ElemType *elem; //次序表的基地点int length; //次序表的目前长度int listsize; //预设空间容量}SqList; //线性表的次序储存构造SqList* InitList() //创立空的次序表{SqList* L = (SqList*)malloc(sizeof(SqList));//定义次序表Lif(!L){printf("空间区分失败,程序退出\n");return NULL;}L->elem=(ElemType*)malloc(MAXSIZE*sizeof(ElemType));if(!L->elem){printf("空间区分失败,程序退出\n");return NULL;}L->length=0;L->listsize=MAXSIZE;return L;}int CreateList(SqList* L) //创立次序表(非空){int number; //次序表中元素的个数int i; //循环变量printf(" 请输入次序表中元素的个数: ");scanf("%d",&number);if(number > MAXSIZE) //必定要判断输入的个数是否大于次序表的最大长度{printf("输入个数大于次序表的长度\n");return 0;}for(i=0;i<number;i++){printf("输入第 %d个数 : ",i+1);scanf("%d",L->elem+i); //L->elem+i:每次的输入都保留在次序表元素中的下一个地点,而不是向来放在元素的首地点}//给次序表中每个数据元素赋值L->length=number; //目前次序表的长度return 1;}void print(SqList* L) //遍历次序表{int i;printf("\n开始遍历次序表 \n");for(i=0;i<L->length;i++){printf("%d",*(L->elem + i)); //L->elem+i:和输入是一个道理}printf("\n遍历结束 \n");printf("\n");}int main(){SqList* L = InitList(); //申请一个指向次序表的指针,并对其初始化if(!L)//判断申请能否成功{printf("初始化线性表失败\n");return 1;}if(!CreateList(L))//判断创立次序表能否成功{printf("创立次序表失败\n");return 1;}print(L);//打印次序表与上边遍历次序表相对应,若没有就不遍历free(L->elem); free(L); ////开释申请的次序表元素的内存开释申请的次序表内存return 0;}表的有序归并#include <>#include <>#define MAXSIZE 100typedef int ElemType;//次序表构造体的定义typedef struct{ElemType data[MAXSIZE] ;int size;}seqlist;//函数申明void init(seqlist *slt) ;void display(seqlist slt) ;void sort(seqlist *s) ;void combine( seqlist *s1 ,seqlist *s2 ,seqlist *s3) ;//次序表的初始化函数void init(seqlist *slt){slt->size=0 ;}//次序表的显示函数void display(seqlist slt){int i;if(!{printf("\n次序表为空 ") ;}else{for(i=0;i<;i++)printf("\n%d\n",[i]) ;}}//次序表排序void sort(seqlist *s){int i ;int j ;int temp ;for(i=0;i<s->size-1;i++){for(j=i+1;j<s->size;j++){if(s->data[i]>=s->data[j]){temp=s->data[i];s->data[i]=s->data[j];s->data[j]=temp;}}}}//两个有序次序表连结函数void combine(seqlist *s1 , seqlist *s2 , seqlist *s3 ) {int i=0 ;int j=0 ;int k=0 ;while( i < s1->size && j < s2->size){if(s1->data[i]<=s2->data[j]){s3->data[k]=s1->data[i];i++;}else{s3->data[k]=s2->data[j];j++;}k++;}if(i==s1->size){while(j<s2->size){s3->data[k]=s2->data[j];k++;j++;}}if(j==s2->size){while(i<s1->size){s3->data[k]=s1->data[i];k++;i++;}}s3->size=k;}//主函数int main(){int i ;int j ;int x ;int n ;seqlist list1 ;seqlist list2 ;seqlist list3 ;init(&list1);printf(" 第一个次序表元素个数:\n"); scanf("%d" ,&n) ;printf(" 第一个次序表输入: \n");for(i=0 ; i<n ; i++){scanf("%d",&[i]) ;++ ;}sort(&list1);//第一个表排序init(&list2);printf(" 第二个次序表元素个数:\n"); scanf("%d" ,&n) ;printf(" 第二个次序表输入: \n");for(i=0 ; i<n ; i++){scanf("%d",&[i]) ;++ ;}sort(&list2);//第二个表排序init(&list3) ;combine(&list1 ,&list2 ,&list3) ;printf(" 表一与表二连结后 :\n") ;display(list3) ;return 0;}。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验报告课程名称:数据结构B实验项目:顺序表实验地点:实验楼110专业班级:计科1301班学号:********** 学生姓名:**指导教师:**2015年1 月1 日一、实验目的和要求本次实习的主要目的是为了使学生熟练掌握线性表的基本操作在顺序存储结构和链式存储结构上的实现,提高分析和解决问题的能力。

要求仔细阅读并理解下列例题,上机调试并编译执行通过,并观察其结果,然后独立完成后面的实验内容,写出完整的实验报告。

编写程序过程中注意养成良好的编程风格与习惯,要求程序结构清晰,程序缩进,适当注释。

二、实验内容和原理1.设顺序表A中的数据元素递增有序,试写一程序,将x插入到顺序表的适当位置上,使该表仍然有序。

2.用单链表ha 存储多项式A(x )=a0+a1x1+a2x2+…+a n x n(其中a I为非零系数),用单链表hb 存储多项式B(x )=b0+b1x1+b2x2+…+b m x m(其中b j为非零系数),要求计算C(x )= A(x )+B(x ),结果存到单链表hc中。

试写出程序。

3.设有n个人围坐在一个圆桌周围,现从第s个人开始报数,数到第m的人出列,然后从出列的下一个人重新开始报数,数到m的人又出列,如此重复,直到所有的人全部出列为止。

Josephus问题是:对于任意给定的n,m,s,求出按出列次序得到的n个人员的顺序表。

三、主要仪器设备1.设备: PC微机;2.实验环境: windows操作系统;VC++6.0,四、实验结果与分析(必填)(1)程序清单:实验1_1:#include "stdio.h"#include "malloc.h"#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define LIST_INIT_SIZE 80#define LISTINCREMENT 10typedef int Status;typedef int ElemType;typedef struct{ElemType *elem;int length;int listsize;}SqList;Status InitList_Sq(SqList *L) //构造一个空的线性表{L->elem=(ElemType*) malloc(LIST_INIT_SIZE*sizeof(ElemType));if (!L->elem)return(OVERFLOW);L->length=0;L->listsize=LIST_INIT_SIZE;return OK;}Status ListInsert_Sq(SqList *L,int i,ElemType e) //插入x{ElemType *q,*p,*newbase;if (i<1 || i>L->length+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; //插入e++L->length; //表长加一return OK;}//将x插入到顺序表(递增有序)的适当位置上Status InsertOrderList_Sq(SqList *L,ElemType x){int i=1;ElemType *q,*p;for(i=L->length; i<=0; i++){printf("%d",i);if(x >= L->elem[i-1]){q=&(L->elem[i-1]);break;}}for(p=&(L->elem[L->length-1]);p>=q;--p)*(p+1)=*p; //插入位置之后的元素后移一位if(i >= L->length) q=&(L->elem[i]);*q=x; //插入x++L->length; //表长加一return OK;}Status CreatList_sq(SqList &Lst){int i,n;printf("请输入你要创建的顺序表的长度");scanf("%d",&n);if (InitList_Sq(&Lst)==OK){for(i=n;i>=0;i--) //循环输入一个顺序数组{if(ListInsert_Sq(&Lst,1,i)!=OK)break;}printf("\n顺序表已建立:");for (i=0;i<Lst.length;i++)printf("%d ",Lst.elem[i]);}return 0;}Status InsertOrderList_Sq_1(SqList &Lst){int i,n;printf("\n请输入你要插入的元素");scanf("%d",&n);InsertOrderList_Sq(&Lst,n);printf("\n插入后的顺序表为");for (i=0;i<Lst.length;i++)printf("%d ",Lst.elem[i]);return OK;}Status menu_select(){int sn;for(;;){printf("\n请输入您要进行的功能选项");scanf("%d",&sn);if(sn<1||sn>3)printf("\n\t输入错误,请重新输入\n");elsebreak;}return sn;}void main(){SqList Lst;int i;printf("1.建立一个顺序表;\n2.输入你要插入的元素\n3.结束\n");while(1){switch(menu_select()){case 1:CreatList_sq(Lst);printf("\n");break;case 2:InsertOrderList_Sq_1(Lst);printf("\n");break;case 3:printf("end\n");return;}}}实验1_2:#include<stdio.h>#include<malloc.h>#define Ture 1#define False 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define LIST_INIT_SIZE 80#define LISTINCREMENT 10typedef int Status;typedef int ElemType;typedef struct Lnode{ElemType data;struct Lnode *next;}Lnode,*LinkList;Status InitList_L(LinkList &L){L = (Lnode *)malloc(sizeof(Lnode));if (L){L->next = NULL;return OK;}elsereturn ERROR;}Status ListInsert_Link(LinkList &L, int i, ElemType e) {LinkList p,q;int j=0;p = L;while( p && j<i-1){p = p->next;j++;//printf("****");// printf("%d",j);}q = (Lnode *)malloc(sizeof(Lnode));if(!q)return OVERFLOW;q->data = e;q->next = p->next;p->next = q;//printf("%d",q->data);return OK;}Status InputFormula(LinkList &L){int b=0,n=0,i;LinkList p,q;p = L;q = L;printf("您要输入_____项式");printf("\n");scanf("%d",&n);if(n <= 0){printf("请输入正确的内容");printf("/n");}printf("Input a figure according your formula:");printf("\n");for(i=1;i<=n;i++){scanf("%d",&b);//printf("%d",b);ListInsert_Link(p,i,b);}printf("您输入的二项式系数如下,请确认\n");for(i;i>1;i--){q = q->next;printf("%d",q->data);printf(",");}printf("\n");return OK;}Status AdditionA_BToClink(LinkList &A, LinkList &B, LinkList &C)//要求计算C(x )= A(x )+B(x ),结果存到单链表hc中。

相关文档
最新文档