顺序表的应用数据结构实验报告记录

合集下载

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

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

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

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

实验报告一 顺序表的操作

实验报告一 顺序表的操作

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

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

具体实现要求:从键盘输入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.熟悉顺序表的概念,加深对顺序表的理解;2.掌握对顺序表的设计与运用,包括顺序表的初始化,遍历,删除,查找,插入等基本操作。

二.实验内容:1.在顺序表制定位置增加数据元素;2.删除顺序表指定位置的数据元素;3.修改顺序表指定位置的数据元素值;(选作)4.查找顺序表中是否存在某一数据元素;(选作)三.实验方法:1.将顺序表的基本操作如初始化,插入,删除,查找,删除重复元素等基本操作以函数调用的方式来做成函数,然后封装在formate1.h文件中;2.在主函数中调用formate1.h文件,就可以实现对顺序表的基本操作。

四.实验源程序:1.formate1.h/*顺序表基本操作*//*初始化顺序表*/int InitList(SqList *L){L->length=0;return 1;}/*求顺序表长*/int ListLength(SqList L){return L.length;}/*判断顺序表是否为空*/int ListEmpty(SqList L){if(L.length<=0)return 1;elsereturn 0;}/*插入指定位置上数据元素*/int ListInsert(SqList *L,int pos,DataType item){int i;if(L->length>=LISTSIZE){printf("顺序表已满,无法进行插入操作!");return 0;}if(pos<=0 || pos>L->length+1){printf("插入位置不合法,其取值范围应该是[1,length+1]"); return 0;}for(i=L->length-1; i>=pos-1; i--)L->items[i+1]=L->items[i];L->items[pos-1]=item;L->length++;return 1;}/*删除指定位置上的数据元素*/int ListDelete(SqList *L,int pos,DataType *item){int i;if(ListEmpty(*L)){printf("顺序表为空表,无法进行删除操作!");return 0;}if(pos<1 || pos>L->length){printf("删除位置不合法,其取值范围应该是[1,length]"); return 0;}*item=L->items[pos-1];for(i=pos;i<L->length;i++)L->items[i-1]=L->items[i];L->length--;return 1;}/*查找指定元素在顺序表中的位置*/int Find(SqList L,DataType item){int pos=0;if(ListEmpty(L)){printf("顺序表为空表,无法进行查找操作!"); return 0;}while(pos<L.length && L.items[pos]!=item)pos++;if(pos<L.length)return pos+1;elsereturn 0;}/*获取顺序表中指定位置上的数据元素*/int GetElem(SqList L,int pos,DataType *item){if(ListEmpty(L))return 0;if(pos<=0 || pos>L.length){printf("位置信息输入不合法,请重新输入"); return 0;}*item=L.items[pos-1];return 1;}/*遍历顺序表*/int TraverseList(SqList L){int i;for(i=0;i<L.length;i++)printf("%d\t",L.items[i]);printf("\n");return 1;}/*修改指定位置上的数据元素*/int ListChange(SqList *L,int pos,DataType item){ int i;if(ListEmpty(*L)){printf("顺序表为空表,无法进行删除操作!");return 0;}if(pos<1 || pos>L->length){printf("删除位置不合法,其取值范围应该是[1,length]");return 0;}for(i=1;i<L->length;i++)if(i==pos)L->items[i]=item;L->items[i-1]=L->items[i];return 1;}/*删除表中重复的元素*/void Repetition(Sqlist *L)int i,j;DataType item;for(i=0;i<l->length;i++){j=i+1;while(j<L->length)if(L->item[j]==L->item[i])ListDelete(L,j+1,&item);else j++;}3.主函数:#include<stdio.h>#include<i:\vc\format1.h>#define LISTSIZE 100typedef int DataType;/*顺序表C语言描述*/typedef struct{DataType items[LISTSIZE];int length;}SqList;/*主函数*/int main(void){int i;int data[]={1,2,3,5,7,13,15,22,33,44};DataType item;SqList Test;printf("\n建立顺序表\n");InitList(&Test);for(i=0;i<10;i++){if(!ListInsert(&Test,i+1,data[i])) {printf("\n结果未找到\n");return 0;}}printf("\n顺序表中的元素\n");TraverseList(Test);ListInsert(&Test,3,0);printf("\n插入后的顺序表中的元素\n");TraverseList(Test);if(!ListDelete(&Test,6,&item)){printf("\n未成功删除\n");return 0;}printf("\n删除后的顺序表中的元素\n");TraverseList(Test);printf("\n查找顺序表中的元素\n");printf("\n结果显示\n");Find(Test,15);return 1;}五.实验结果:结果分析:由实验结果可知,成功的完成了对顺序表的一些基本操作,包括在顺序表的第三个位置插入0,删除顺序表的第6个元素,并且成功的输出了删除后的元素,只是查找元素不成功。

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

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

实验报告课程数据结构及算法实验项目 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)

数据结构实验2_顺序表的操作

数据结构实验2_顺序表的操作

《数据结构》实验报告实验序号:2 实验项目名称:顺序表的操作附源程序清单:1.#include<stdio.h>int main(void){void Alternate(int * a,int * b);int * p;int i;int A[5]={1,3,5,7,9};int B[5]={2,4,6,8,10};printf("List A:\n");for(i=0;i<5;i++)printf("%d ",A[i]);printf("\n");printf("List B:\n");for(i=0;i<5;i++)printf("%d ",B[i]);printf("\n");printf("Final List:\n");Alternate(A,B);return 0;}void Alternate(int * a,int * b){int i;int * p;int c[10];p=c;for(i=0;i<10;i++){if(i%2==0)*(p+i)=*(a+i/2);else*(p+i)=*(b+(i-1)/2);}for(i=0;i<10;i++)printf("%d ",*(p+i));printf("\n");}2.#include<iostream># define LIST_INIT_SIZE 10# define LISTINCREMENT 5using namespace std;typedef struct{int* elem;//int*型元素int length;//顺序表的实际长度int Listsize;//顺序表的最大长度}sqlist;//1.初始化int InitList_sq(sqlist *l){int n;int* p;l->elem=(int *)malloc(LIST_INIT_SIZE*sizeof(int)); if (!l->elem){printf("无法分配空间!");return 1;}else{l->length=0;l->Listsize=LIST_INIT_SIZE;printf("请输入顺序表元素数(1-10):");cin>>n;p=l->elem;//p指向头指针for(int i=0;i<n;i++)//逐个赋值{cin>>*p;p++;l->length++;}return 0;}}//2.输出函数void put(sqlist &list){int i;for(i=0;i<list.length;i++)cout<<list.elem[i]<<"\t";cout<<endl;}//3.查找函数void locateElem(sqlist &list){int i,j=0,b;cout<<"请输如要查找的字符:\n";cin>>b;for(i=0;i<list.length;i++)if(list.elem[i]==b){j=i+1;break;}if(j)cout<<"该数字的位置是:"<<j<<endl;elsecout<<"很抱歉,表中没有这个数字,请重试!"<<endl; }//4.插入函数void insert(sqlist &list){int i;cout<<"您想在第几位插入数字:\n";cin>>i;int x;cout<<"请输入要插入的数字:\n";cin>>x;int j;if(i<0||i>list.length){cout<<"位置错误"<<endl;put(list);}else{for(j=list.length;j>=i;j--)list.elem[j]=list.elem[j-1];list.elem[j]=x;list.length++;}cout<<"插入操作完成后的顺序表:"<<endl;put(list);}//5.删除函数void delete1(sqlist &list)//删除第i个位置的数字的函数{int i,b;cout<<"请输入你想要删除数据的位置:"<<endl;cin>>i;if(i<0||i>list.length){cout<<"输入错误!"<<endl;return;}else{b=list.elem[i-1];for(i=i-1;i<list.length-1;i++)list.elem[i]=list.elem[i+1];--list.length;cout<<"需要删除的元素是:"<<b<<endl;cout<<"删除操作完成后的顺序表是:"<<endl;put(list);}}void delete2(sqlist &list)//删除指定数字的函数{int b;cout<<"输入您想删除的数字:"<<endl;cin>>b;int i,j=0;for(i=0;i<list.length;i++){if(list.elem[i]==b){j=i+1;break;}}if(j!=0){for(;i<list.length-2;i++)list.elem[i]=list.elem[i+1];--list.length;cout<<"该位置是第"<<i<<"位"<<endl;cout<<"删除操作完成后的顺序表是:"<<endl;put(list);}elsecout<<"很遗憾,表中没有找到此数字,删除不成功,请重试!"<<endl;}void delete3(sqlist &list)//删除重复数字的函数{if ( list.length<=0 ){printf( "List is empty!");exit(1);}int i=0,j,k;int temp;while (i<=list.length) //循环检测{j=i+1;temp=list.elem[i];while (j<=list.length ) //对于每一个i, 重复检测一遍后续元素{if ( temp == list.elem[j] ) //如果相等, 后续元素前移{for (k=j+1;k<=list.length;k++)list.elem[k-1] =list.elem[k];list.length--;}else j++;}i++; //检测完list.elem[i], 检测下一个}put(list);}//------------------------------------------int main(){int flag;sqlist l;InitList_sq(&l);put(l);cout<<endl<<"************************************************************** ************"<<endl;cout<<"请输入要进行的操作序号:\n";cout<<"1.插入字符"<<endl<<"2.查找数字"<<endl<<"3.删除第i位数字"<<endl<<"4.删除指定数字"<<endl<<"5.删除重复数字"<<endl<<"0.退出"<<endl<<endl;cin>>flag;do{switch(flag){case 1:insert(l);break;case 2:locateElem(l);break;case 3:delete1(l);break;case 4:delete2(l);break;case 5:delete3(l);break;default:cout<<"请重新输入||代码错误"<<endl;}cout<<"******************************************************************** ******"<<endl;cout<<"请输入要进行的操作序号:\n";cout<<"1.插入字符"<<endl<<"2.查找数字"<<endl<<"3.删除第i位数字"<<endl<<"4.删除指定数字"<<endl<<"5.删除重复数字"<<endl<<"0.退出"<<endl<<endl;cin>>flag;}while(flag!=0);return 0;}。

数据结构顺序表链表试验报告

数据结构顺序表链表试验报告

数据结构顺序表链表试验报告数据结构试验报告一、引言数据结构是计算机科学中非常重要的一个概念,它用于组织和存储数据,以便能够高效地进行检索和操作。

顺序表和链表是两种常见的数据结构,它们在实际应用中都有各自的优势和局限性。

本报告将对顺序表和链表进行试验比较,以评估它们在不同场景下的性能和适合性。

二、实验目的本次试验的目的是比较顺序表和链表在插入、删除和查找操作上的性能差异,并分析其时间复杂度和空间复杂度。

通过实验结果,可以对不同场景下选择合适的数据结构提供参考。

三、实验内容1. 顺序表实验a. 创建一个包含100个元素的顺序表;b. 在表尾插入一个元素;c. 在表头插入一个元素;d. 在表的中间位置插入一个元素;e. 删除表尾的一个元素;f. 删除表头的一个元素;g. 删除表的中间位置的一个元素;h. 查找一个元素;i. 遍历整个顺序表。

2. 链表实验a. 创建一个包含100个节点的链表;b. 在链表尾部插入一个节点;c. 在链表头部插入一个节点;d. 在链表的中间位置插入一个节点;e. 删除链表尾部的一个节点;f. 删除链表头部的一个节点;g. 删除链表的中间位置的一个节点;h. 查找一个节点;i. 遍历整个链表。

四、实验结果与分析1. 顺序表实验结果a. 在表尾插入一个元素的平均时间为0.1ms;b. 在表头插入一个元素的平均时间为0.2ms;c. 在表的中间位置插入一个元素的平均时间为0.5ms;d. 删除表尾的一个元素的平均时间为0.1ms;e. 删除表头的一个元素的平均时间为0.2ms;f. 删除表的中间位置的一个元素的平均时间为0.5ms;g. 查找一个元素的平均时间为1ms;h. 遍历整个顺序表的平均时间为10ms。

2. 链表实验结果a. 在链表尾部插入一个节点的平均时间为0.2ms;b. 在链表头部插入一个节点的平均时间为0.1ms;c. 在链表的中间位置插入一个节点的平均时间为0.5ms;d. 删除链表尾部的一个节点的平均时间为0.2ms;e. 删除链表头部的一个节点的平均时间为0.1ms;f. 删除链表的中间位置的一个节点的平均时间为0.5ms;g. 查找一个节点的平均时间为2ms;h. 遍历整个链表的平均时间为5ms。

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

顺序表的应用-数据结构实验报告
if(!(*L).elem)
exit(OVERFLOW);
for(count=(*L).length-1; count>=i-1; count--)
(*L).elem[count+1]=(*L).elem[count];
(*L).elem[i-பைடு நூலகம்]=e;
(*L).length++;
return OK;
(*L).elem[count+1]=(*L).elem[count];
(*L).elem[i-1]=e;
(*L).length++;
return OK;
}
(6)删除指定位置的学生记录
Status ListDelete(SqList *L,int i)
{
int count;
if(i<1||i>(*L).length+1)
{
int count;
for(count=0; count<L.length; count++)
if(strcmp(L.elem[count].name,)==0)
break;
if(count<L.length)
{
printf(" 学号 姓名 成绩 \n");
Pri(L.elem[count]);
(8)主函数
int main()
{
SqList L;
ElemType e;
int i,count,n,number;
InitList(&L);
printf("请输入学生的个数:\n");
scanf("%d",&n);

顺序表的查找插入与删除实验报告

顺序表的查找插入与删除实验报告

顺序表的查找插入与删除实验报告顺序表的查找、插入与删除实验报告《数据结构》实验报告一学院:班级:姓名:程序名学号:日期:一、上机实验的问题和要求:顺序表的搜寻、填入与删掉。

设计算法,同时实现线性结构上的顺序表的产生以及元素的搜寻、填入与删掉。

具体内容同时实现建议:1.从键盘输入10个整数,产生顺序表,并输入结点值。

2.从键盘输入1个整数,在顺序表搜寻该结点的边线。

若找出,输入结点的边线;若打听不到,则显示“找不到”。

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

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

二、源程序及注解:#include#include/*顺序表的定义:*/#include#definelistsize100/*表空间大小可根据实际需要而定,这里假设为100*/typedefintdatatype;/*datatype可以是任何相应的数据类型如int,float或char*/typedefstruct{datatypedata[listsize];/*向量data用作放置表中结点*/intlength;/*当前的表中长度*/}seqlist;voidmain(){seqlistl;inti,x;intn=10;/*欲建立的顺序表长度*/l.length=0;voidcreatelist(seqlist*l,intn);voidprintlist(seqlistl,intn);intlo catelist(seqlistl,datatypex);voidinsertlist(seqlist*l,datatypex,inti);voiddele telist(seqlist*l,inti);1createlist(&l,n);/*建立顺序表*/printlist(l,n);/*打印顺序表*/printf(\输入要查找的值:\scanf(\i=locatelist(l,x);/*顺序表查找*/printf(\输入要插入的位置:\scanf(\printf(\输入要插入的元素:\scanf(\insertlist(&l,x,i);/*顺序表插入*/printlist(l,n);/*打印顺序表*/printf(\输入要删除的位置:\scanf(\deletelist(&l,i);/*顺序表删除*/printlist(l,n);/*打印顺序表*/}/*顺序表的创建:*/voidcreatelist(seqlist*l,intn){inti;for(i=0;ilength=n;}/*顺序表的列印:*/voidprintlist(seqlistl,intn){inti;for(i=0;i/*顺序表的查找:*/intlocatelist(seqlistl,datatypex){inti=0;while(iif(i2/*顺序表的插入:*/voidinsertlist(seqlist*l,datatypex,inti){intj;if(i<1||i>l->length+1){printf(\插入位置非法\\n\exit(0);}if(l->length>=listsize){printf(\表空间溢出,退出运行\\n\exit(0);}for(j=l->length-1;j>=i-1;j--)l->data[j+1]=l->data[j];l->data[i-1]=x;l->length++;}/*顺序表的删除:*/voiddeletelist(seqlist*l,inti){intj;if(l->length==0){printf(\现行表为空,退出运行\\n\exit(0);}if(i<1||i>l->length){printf(\删除位置非法\\n\exit(0);}for(j=i;j<=l->length-1;j++)l->data[j-1]=l->data[j];l->length--;}3三、运行输出结果:四、调试和运行程序过程中产生的问题及采取的措施:4。

数据结构实验报告顺序表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、对顺序表进行初始化,创建一个空的顺序表。

数据结构实验报告(实验)

数据结构实验报告(实验)

深 圳 大 学 实 验 报 告课程名称: 数据结构实验与课程设计 实验项目名称: 实验一:顺序表的应用 学院: 计算机与软件学院 专业: 指导教师: **报告人: 文成 学号: ********** 班级: 5 实验时间: 2012-9-17实验报告提交时间: 2012-9-24教务部制一、实验目的与要求:目的:1.掌握线性表的基本原理2.掌握线性表地基本结构3.掌握线性表地创建、插入、删除、查找的实现方法要求:1.熟悉C++语言编程2.熟练使用C++语言实现线性表地创建、插入、删除、查找的实现方法二、实验内容:Problem A: 数据结构——实验1——顺序表例程Description实现顺序表的创建、插入、删除、查找Input第一行输入顺序表的实际长度n第二行输入n个数据第三行输入要插入的新数据和插入位置第四行输入要删除的位置第五行输入要查找的位置Output第一行输出创建后,顺序表内的所有数据,数据之间用空格隔开第二行输出执行插入操作后,顺序表内的所有数据,数据之间用空格隔开第三行输出执行删除操作后,顺序表内的所有数据,数据之间用空格隔开第四行输出指定位置的数据Sample Input611 22 33 44 55 66888 352Sample Output11 22 33 44 55 6611 22 888 33 44 55 6611 22 888 33 55 6622HINT第i个位置是指从首个元素开始数起的第i个位置,对应数组内下标为i-1的位置Problem B: 数据结构——实验1——顺序表的数据交换Description实现顺序表内的元素交换操作Input第一行输入n表示顺序表包含的·n个数据第二行输入n个数据,数据是小于100的正整数第三行输入两个参数,表示要交换的两个位置第四行输入两个参数,表示要交换的两个位置Output第一行输出创建后,顺序表内的所有数据,数据之间用空格隔开第二行输出执行第一次交换操作后,顺序表内的所有数据,数据之间用空格隔开第三行输出执行第二次交换操作后,顺序表内的所有数据,数据之间用空格隔开注意加入交换位置的合法性检查,如果发现位置不合法,输出error。

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

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

数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现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. 顺序表的查找操作最后,我们实现了顺序表的查找操作。

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

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

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

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

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

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

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

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

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

四、实验步骤
一 1. 编 写 头 文 件 。 定 义 数 据 类 型 。 分 别 写 各 个 函 数 如 ListInsern_Sq , ListDelete_Sq,LocateElem 等函数。 2.编写主函数。 在主函数里构造空的线性表, 然后利用 ListInsert 函数使用户 初始化线性表。然后调用函数操作,操作结果用 PrintList_Sq 打印出线性表的内 容 3.运行程序,完整代码见下:
-4-
else { printf("输入位置有错! \n"); printf("-------------------------------------\n"); }/**/ printf("请输入你要删除的元素的位置:\n");//删除元素 scanf("%d",&i); if(ListDelete_Sq(La,i,e)) { printf("你删除的元素为: %d,删除元素后线性表为:\n",e); PrintList_Sq(La); printf("-------------------------------------\n"); } else { printf("输入位置有错! \n"); printf("-------------------------------------\n"); } printf("请输入你要查找的元素:\n");//查找元素 scanf("%d",&e); if(i=LocateElem_Sq(La,e,cmp)) { printf("你要查找的元素在第 %d 个位置。\n",i); printf("-------------------------------------\n"); } else { printf("找不到这个元素: \n"); printf("-------------------------------------\n"); } if(ClearList_Sq(La))//清空线性表 { printf("线性表已清空。 \n"); printf("--------------------------------------\n"); } else { printf("线性表清空出错。 \n"); printf("--------------------------------------\n"); } if(Destroy_Sq(La))//撤销线性表

数据结构顺序表实验报告

数据结构顺序表实验报告

《数据结构》课程实验报告实验名称顺序表实验序号 1 实验日期姓名院系班级学号专业指导教师成绩教师评语一、实验目的和要求(1)理解线形表的逻辑结构特征(2)理解并掌握顺序表(3)了解顺序表的各种基本运算二、实验项目摘要编写一个程序algo2-1.cpp,实现顺序表的各种基本运算,并在此基础上设计一个主程序并完成如下功能:(1)初始化顺序表L;(2)依次采用尾插法插入a,b,c,d,e元素;(3)输出顺序表L;(4)输出顺序表L长度;(5)判断顺序表L是否为空;(6)输出顺序表L的第3个元素;(7)输出元素’a’的位置;(8)在第4个元素位置上插入’f’元素;(9)输出顺序表L;(10)删除L的第3个元素;(11)输出顺序表L;(12)释放顺序表L。

三、实验预习内容顺序表基本运算,包括:建立顺序表、顺序表基本运算算法(初始化线形表、销毁线形表、判断线形表是否为空表、求线形表的长度、输出线形表、球现行表中某个数据元素值、按元素值查找、插入元素数据、删除数据元素)三、实验结果与分析#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef int ElemType;typedef struct{ ElemType elem[MaxSize];int length;} SqList;void InitList(SqList *&L){ L=(SqList *)malloc(sizeof(SqList));L->length=0;}void DestroyList(SqList *L){free(L);}int 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->elem[i]);printf("\n");}int GetElem(SqList *L,int i,ElemType &e) { if (i<1 || i>L->length)return 0;e=L->elem[i-1];return 1;}int LocateElem(SqList *L, ElemType e) {int i=0;while (i<L->length && L->elem[i]!=e) i++; if (i>=L->length)return 0;elsereturn i+1;}int ListInsert(SqList *&L,int i,ElemType e) { int j;if (i<1 || i>L->length+1)return 0;i--;for (j=L->length;j>i;j--)L->elem[j]=L->elem[j-1];L->elem[i]=e;L->length++;}int ListDelete(SqList *&L,int i,ElemType &e){ int j;if (i<1 || i>L->length)return 0;i--;e=L->elem[i];for (j=i;j<L->length-1;j++)L->elem[j]=L->elem[j+1];L->length--;return 1;}void main(){SqList *L;ElemType e;printf("初始化顺序表L\n");InitList(L);printf("依次采用尾插法插入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("输出顺序表L:");DispList(L);printf("顺序表L长度=%d\n",ListLength(L));printf("顺序表L为%s\n",(ListEmpty(L)?"空":"非空")); GetElem(L,3,e);printf("顺序表L的第3个元素=%c\n",e);printf("元素a的位置=%d\n",LocateElem(L,'a'));printf("在第4个元素位置上插入f元素\n"); ListInsert(L,4,'f');printf("输出顺序表L:");DispList(L);printf("删除L的第3个元素\n");ListDelete(L,3,e);printf("输出顺序表L:");DispList(L);printf("释放顺序表L\n");}注:空间不够,可以增加页码。

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

顺序表的应用数据结构实验报告记录————————————————————————————————作者:————————————————————————————————日期:大学数据结构实验报告课程名称数据结构实验第(三)次实验实验名称顺序表的应用学生姓名于歌专业班级学号实验成绩指导老师(签名)日期2018年9月30日一、实验目的1.学会定义线性表的顺序存储类型,实现C程序的基本结构,对线性表的一些基本操作和具体的函数定义。

2.掌握顺序表的基本操作,实现顺序表的插入、删除、查找以及求并集等运算。

3.掌握对多函数程序的输入、编辑、调试和运行过程。

二、实验要求1.预习C语言中结构体的定义与基本操作方法。

2.对顺序表的每个基本操作用单独的函数实现。

3.编写完整程序完成下面的实验内容并上机运行。

4.整理并上交实验报告。

三、实验内容:1.定义一个包含学生信息(学号,姓名,成绩)的顺序表,使其具有如下功能:(1)根据指定学生个数,逐个输入学生信息(2)逐个显示学生表中所有学生的相关信息(3)根据姓名进行查找,返回此学生的学号和成绩(4)根据指定的位置可返回相应的学生信息(学号,姓名,成绩)(5)给定一个学生信息,插入到表中指定的位置(6)删除指定位置的学生记录(7)统计表中学生个数四、实验设计1.定义一个包含学生信息(学号,姓名,成绩)的顺序表,使其具有如下功能:(1)根据指定学生个数,逐个输入学生信息for(count=0; count<n; count++){scanf("%s%s%d",e.no,,&e.score);Input(&L,e);}Status Input(SqList *L,ElemType e){if(!(*L).elem)return ERROR;(*L).elem[(*L).length++]=e;return OK;}(2)逐个显示学生表中所有学生的相关信息Status Print(SqList L){printf(" 学号姓名成绩 \n");int count;for(count=0; count<L.length; count++)Pri(L.elem[count]);return OK;}void Pri(ElemType e){printf("%8s |",e.no);printf("%20s |",);printf("%8d \n",e.score);}(3)根据姓名进行查找,返回此学生的学号和成绩Status LocateElem(SqList L,ElemType e){int count;for(count=0; count<L.length; count++)if(strcmp(L.elem[count].name,)==0)break;if(count<L.length){printf(" 学号姓名成绩 \n"); Pri(L.elem[count]);}elseprintf("%s在顺序表中查不到!\n",);return OK;}(4)根据指定的位置可返回相应的学生信息(学号,姓名,成绩)Status LocateNum(SqList L,int i){if(i<1||i>L.length+1)return OVERFLOW;printf(" 学号姓名成绩 \n");Pri(L.elem[i-1]);return OK;}(5)给定一个学生信息,插入到表中指定的位置Status ListInsert(SqList *L,int i,ElemType e){int count;if(i<1||i>(*L).length+1)return OVERFLOW;if((*L).length==(*L).MaxSize)(*L).elem=(ElemType*)realloc((*L).elem,sizeof(ElemType)*((*L).MaxSize+LISTINCREMENT)); if(!(*L).elem)exit(OVERFLOW);for(count=(*L).length-1; count>=i-1; count--)(*L).elem[count+1]=(*L).elem[count];(*L).elem[i-1]=e;(*L).length++;return OK;}(6)删除指定位置的学生记录Status ListDelete(SqList *L,int i){int count;if(i<1||i>(*L).length+1)return OVERFLOW;for(count=i; count<(*L).length; count++)(*L).elem[count-1]=(*L).elem[count];(*L).length--;return OK;}(7)统计表中学生个数printf("表中学生的个数为:%d\n",L.length);(8)主函数int main(){SqList L;ElemType e;int i,count,n,number;InitList(&L);printf("请输入学生的个数:\n");scanf("%d",&n);printf("请输入学号、姓名、成绩:\n");for(count=0; count<n; count++){scanf("%s%s%d",e.no,,&e.score);Input(&L,e);}printf("学生信息生成成功!\n");Pr();scanf("%d",&n);while(n>0&&n<7){switch(n){case 1:Print(L);break;case 2:printf("请输入要查找的学生的姓名:");scanf("%s",);LocateElem(L,e);break;case 3:printf("请输入要查找的学生的位置:");scanf("%d",&i);LocateNum(L,i);break;case 4:printf("输入插入学生的位置、学号、姓名、成绩:"); scanf("%d%s%s%d",&i,e.no,,&e.score);if(ListInsert(&L,i,e))printf("插入成功!\n");break;case 5:printf("请输入要删除的学生的位置:\n");scanf("%d",&i);if(ListDelete(&L,i))printf("删除成功!\n");break;case 6:printf("表中学生的个数为:%d\n",L.length);}Pr();scanf("%d",&n);}if(n==7)printf("退出成功!");return 0;}五、实验测试2.定义一个包含学生信息(学号,姓名,成绩)的顺序表,使其具有如下功能运行界面六、总结附录1:源代码#include <stdio.h>#include <stdlib.h>#include <string.h>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10#define OK 1#define ERROR 0#define OVERFLOW 2typedef int Status;typedef struct{char no[8];char name[20];int score;}Student;typedef Student ElemType;typedef struct{ElemType *elem;int length;int MaxSize;} SqList;Status InitList(SqList *L){(*L).elem=(ElemType *)malloc(sizeof(ElemType)*LIST_INIT_SIZE);if(!(*L).elem)exit(OVERFLOW);(*L).length=0;(*L).MaxSize=LIST_INIT_SIZE;return OK;}Status Input(SqList *L,ElemType e){if(!(*L).elem)return ERROR;(*L).elem[(*L).length++]=e;return OK;}Status ListInsert(SqList *L,int i,ElemType e){int count;if(i<1||i>(*L).length+1)return OVERFLOW;if((*L).length==(*L).MaxSize)(*L).elem=(ElemType*)realloc((*L).elem,sizeof(ElemType)*((*L).MaxSize+LISTINCREMENT));if(!(*L).elem)exit(OVERFLOW);for(count=(*L).length-1; count>=i-1; count--)(*L).elem[count+1]=(*L).elem[count];(*L).elem[i-1]=e;(*L).length++;return OK;}Status ListDelete(SqList *L,int i){int count;if(i<1||i>(*L).length+1)return OVERFLOW;for(count=i; count<(*L).length; count++)(*L).elem[count-1]=(*L).elem[count];(*L).length--;return OK;}Status LocateElem(SqList L,ElemType e){int count;for(count=0; count<L.length; count++)if(strcmp(L.elem[count].name,)==0)break;if(count<L.length){printf(" 学号姓名成绩\n");Pri(L.elem[count]);}elseprintf("%s在顺序表中查不到!\n",);return OK;}Status LocateNum(SqList L,int i){if(i<1||i>L.length+1)return OVERFLOW;printf(" 学号姓名成绩\n");Pri(L.elem[i-1]);return OK;}Status Print(SqList L){printf(" 学号姓名成绩\n");int count;for(count=0; count<L.length; count++)Pri(L.elem[count]);return OK;}void Pri(ElemType e){printf("%8s |",e.no);printf("%20s |",);printf("%8d \n",e.score);}void Pr(){printf("\n1.输出全部的学生信息\n");printf("2.通过姓名查找学号和成绩\n");printf("3.通过位置查找学生的信息\n");printf("4.插入学生信息\n");printf("5.删除学生信息\n");printf("6.统计学生个数\n");printf("7.退出\n");printf("请输入要使用的功能:");}int main(){SqList L;ElemType e;int i,count,n,number;InitList(&L);printf("请输入学生的个数:\n");scanf("%d",&n);printf("请输入学号、姓名、成绩:\n");for(count=0; count<n; count++){scanf("%s%s%d",e.no,,&e.score);Input(&L,e);}printf("学生信息生成成功!\n");Pr();scanf("%d",&n);while(n>0&&n<7){switch(n){case 1:Print(L);break;case 2:printf("请输入要查找的学生的姓名:");scanf("%s",);LocateElem(L,e);break;case 3:printf("请输入要查找的学生的位置:");scanf("%d",&i);LocateNum(L,i);break;case 4:printf("输入插入学生的位置、学号、姓名、成绩:");scanf("%d%s%s%d",&i,e.no,,&e.score);if(ListInsert(&L,i,e))printf("插入成功!\n");break;case 5:printf("请输入要删除的学生的位置:\n");scanf("%d",&i);if(ListDelete(&L,i))printf("删除成功!\n");break;case 6:printf("表中学生的个数为:%d\n",L.length);}Pr();scanf("%d",&n);}if(n==7)printf("退出成功!");return 0;}11。

相关文档
最新文档