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

竭诚为您提供优质文档/双击可除顺序表的基本操作实验报告篇一:顺序表的基本操作--实验报告实验报告附:源程序:#include#definemaxsize100#defineerror0#defineok1typedefstruct{intelem[maxsize];intlast;}seqList;intInsList(seqList*L,inta,inti);intLocate(seqListL,inte);intDel(seqList*L,inti);voidmain(){inti,e,a;intlist1,list2;if(L.elem[st]==-1)seqListL;st=0;for(i=0;i list1=InsList(if(list1){}elseprintf("插入失败!");printf("要查找的元素为\n");scanf("%d",printf("插入后的顺序表为:\n");for(i=0;i list2=Locate(L,e);if(!list2)printf("该元素不存在\n");}printf("该元素所在位置的序号为:%d\n",list2);/*删除元素*/printf("是否要删除该元素?\n");intm;scanf("%d",if(m){Del(printf("删除后的顺序表为:\n");for(i=0;iintInsList(seqList*L,inta,inti)//i位置,下标i-1{for(p=L->last;p>=i-1;p--)L->elem[p+1]=L->elem[p];in tp;if(L->last>=maxsize-1){}printf("表已满,无法插入");return(error);L->elem[i-1]=a;L->last++;return(ok );intLocate(seqListL,inte){}intDel(seqList*L,inti){}for(k=i;klast;k++)L->elem[k-1]=L->elem[k];intk ;inti=0;while((ilast--;returnok;篇二:线性表的基本操作实验报告实验一:线性表的基本操作【实验目的】学习掌握线性表的顺序存储结构、链式存储结构的设计与操作。
数据结构实验一_顺序表的基本操作实验报告

实验一顺序表的基本操作一、实验目的掌握线性表的顺序表基本操作:建立、插入、删除、查找、合并、打印等运算。
二、实验要求包含有头文件和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语言的上机环境,掌握C语言的基本结构<2>会定义线性表的顺序存储结构<3>熟悉对顺序表的一些基本操作<4>熟悉与线性表相关的函数的定义和使用【实验内容】[实验任务一]顺序表的基本操作1.顺序表的插入操作【操作步骤】<1>启动辅助教学软件<2>选择“C语言”<3>选择“顺序表”<4>选择“顺序表插入”<5>输入建立表的数据<6>输入插入数据元素<7>输入插入位置<8>选择单步执行2.顺序表的删除操作【操作步骤】<1>启动辅助教学软件<2>选择“C语言”<3>选择“顺序表”<4>选择“顺序表插入”<5>输入建立表的数据<6>输入删除位置<7>选择单步执行[实验任务二]编写C语言程序1. 编程实现顺序表的插入操作。
2.编程实现顺序表的删除操作。
实验2 链表的基本操作【实验目的】<1>学会定义单链表的结点类型<2>熟悉单链表的一些基本操作,依据这些操作函数定义<3>掌握线性表的链式存储结构的特点<4>掌握循环链表和双向链表的定义、构造方法等。
【实验内容】[实验任务一]验证单链表的基本操作<1>单链表的插入操作<2>单链表的删除操作[实验任务二]编写C语言程序<1>用C语言实现构造单链表<2>用C语言实现输出单链表实验3 二叉树的基本操作【实验目的】<1>熟悉二叉树的结点结构<2>熟悉二叉树的基本操作<3>学会利用递归方法编写二叉树的遍历算法【实验内容】[实验任务一]二叉树的遍历<1>先序遍历<2>中序遍历<3>后续遍历[实验任务二]编写算法<1>根据二叉树的任一遍历算法,编写求二叉树中结点个数的算法。
数据结构_实验2_顺序表的基本操作

实验报告
实验课程数据结构
实验项目实验二、顺序表的基本操作实验地点
指导教师
班级
学生姓名
学号
教师评分
日期
一、实验目的
1、掌握线性表的顺序存储结构;
2、掌握顺序表及其基本操作的实现;
3、掌握数据结构及算法的程序实现的基本方法。
二、实验设备
1.安装有WinXP的PC一台;
2.安装有软件VC6或者Visual Studio2005。
三、实验内容
1、建立含有若干个元素的顺序表;
2、对已建立的顺序表实现插入、删除、查找等基本操作;
3、对两个顺序表进行合并操作。
四、实验步骤
1.根据下面的表格,定义一个表示数据元素的结构体。
2.根据教材的内容,定义顺序表的结构体。
3.根据教材的内容,编写代码,实现顺序表的下列函数。
4.定义数据元素输入函数如下。
请完善代码。
5.定义顺序表的创建函数如下,请完善代码。
6.定义数据元素的输出函数如下,请完善代码。
7.定义main函数,要求完成如下功能。
A.定义三个顺序表分别为list1, list2,list3;
B.初始化两个顺序表list1和list2;
C.输入顺序表list1;
D.输入list2;
E.合并list1和list2到list3中;
F.删除list3中的第三个元素;
G.输出list3中的内容。
五、实验总结
请写出本实验的心得体会。
实验报告一 顺序表的操作

《数据结构》实验报告一系别:班级:学号:姓名:日期:指导教师:一、上机实验的问题和要求:顺序表的查找、插入与删除。
设计算法,实现线性结构上的顺序表的产生以及元素的查找、插入与删除。
具体实现要求:从键盘输入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 顺序表基本操作实验目的1.熟悉C语言的上机环境,掌握C语言的基本结构。
2.会定义线性表的顺序存储结构。
3.熟悉对顺序表的一些基本操作和具体的函数定义。
注意事项在做第一次“数据结构”课程实验之前,要在硬盘上建立好自己的工作目录,专门来存储你所做的实验程序及相关信息,以后每次做实验都采用这个目录。
实验内容该程序的功能是对元素类型为整型的顺序表进行一些操作。
该程序包括顺序表结构类型的定义以及对顺序表操作的具体的函数定义和主函数。
/* 定义ElemType为int类型*/typedef int ElemType;/*顺序表存储空间的总分配量*/#define MAXSIZE 100/* 顺序存储类型*/typedef struct{ElemType data[MAXSIZE]; /*存放线性表的数组*/int length; /* length是顺序表的长度*/}SeqList;/* 初始化顺序表*/SeqList Seq ListInit( )/* 清空顺序表*/SeqList ListClear(SeqList L)/* 求顺序表长度*/int ListLength(SeqList L)/* 检查顺序表是否为空*/int ListEmpty(SeqList L)/*检查顺序表是否为满*/int ListFull(SeqList L)/* 遍历顺序表*/void ListTraverse(SeqList L)/* 从顺序表中查找元素*/ElemType ListGet(SeqList L ,int i)/* 从顺序表中查找与给定元素值相同的元素在顺序表中的位置*/ int ListLocate(SeqList L, ElemType x)/* 向顺序表中插入元素*/SeqList ListInsert(SeqList L,int i,ElemType x)/* 从顺序表中删除元素*/SeqList ListDelete(SeqList L,int i)/*求顺序表中元素的前驱*/ElemType ListPrior (SeqList L,ElemType e)/*求顺序表中元素的后继*/ElemType ListNext(SeqList L,ElemType e)====================================================================== ===部分参考程序===================================================================== ==============/* 定义ElemType为int类型*/typedef int ElemType;/*顺序表存储空间的总分配量*/#define MAXSIZE 100#define FALSE 0#define TRUE 1/* 顺序存储类型*/typedef struct{ElemType data[MAXSIZE]; /*存放线性表的数组*/int length;/* length是顺序表的长度*/}SeqList;/* 初始化顺序表*/SeqList SeqListInit( ){SeqList L;L.length=0;return L;}/* 清空顺序表*/SeqList ListClear(SeqList L){L.length=0;return L;}/* 求顺序表长度*/int ListLength(SeqList L){return(L.length);}/* 检查顺序表是否为空*/int ListEmpty(SeqList L){if(L.length) return(FALSE);else return(TRUE);}/*检查顺序表是否为满*/int ListFull(SeqList L){if(L.length==MAXSIZE) return(TRUE);else return(FALSE);}/* 遍历顺序表*/void ListTraverse(SeqList L){int i;if(L.length<=0) printf("顺序表为空\n");else {printf("当前顺序表中的元素为:\n");for(i=1;i<=L.length;i++) printf("%5d ",L.data[i-1]); printf("\n");}}/* 从顺序表中查找元素*/ElemType ListGet(SeqList L ,int i){ElemType e;e=L.data[i-1];return(e);}/* 从顺序表中查找与给定元素值相同的元素在顺序表中的位置*/int ListLocate(SeqList L, ElemType x){int i=0;while(i<L.length&&L.data[i]!=x)i++;if (i<L.length) return (i+1);else return 0;}/* 向顺序表中插入元素*/SeqList ListInsert(SeqList L,int i,ElemType x){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.data[j+1]=L.data[j];L.data[i-1]=x; /*插入x*/L.length++; /*表长增1*/}return L;}/* 从顺序表中删除元素*/SeqList ListDelete(SeqList L,int i){int j;ElemType x;if (i<1||i>L.length)printf("删除位置不正确\n");else {x=L.data[i-1];for(j=i;j<=L.length-1;j++) /*元素依次向前移动*/L.data[j-1]=L.data[j];L.length--; /*表长减1*/printf("%d已被删除\n",x);}return L;}/*求顺序表中元素的前驱*/ElemType SeqListPrior(SeqList L,ElemType e){int i=0;while(i<L.length&&L.data[i]!=e) /*在顺序表中查找值为e的元素*/i++;if(i==0) {printf("第一个元素没有前驱\n");return 0;}else if(i<=L.length-1) return(L.data[i-1]);else {printf("不存在值为%d的元素\n",e);return 0;}}/*求顺序表中元素的后继*/ElemType SeqListNext(SeqList L,ElemType e){int i=0;while(i<L.length&&L.data[i]!=e) /*在顺序表中查找值为e的元素*/i++;if(i==L.length-1) {printf("最后一个元素没有后继\n");return0;}else if(i<L.length-1) return(L.data[i+1]);else {printf("不存在值为%d的元素\n",e);return 0;}}。
顺序表的操作实验报告

顺序表的操作实验报告顺序表的操作实验报告一、引言顺序表是一种常见的数据结构,它在计算机科学中被广泛应用。
本实验旨在通过实际操作顺序表,探索其基本操作和性能。
二、实验目的1. 理解顺序表的基本原理和数据结构;2. 掌握顺序表的插入、删除、查找等操作;3. 分析顺序表操作的时间复杂度。
三、实验过程1. 初始化顺序表:首先,我们创建一个空的顺序表,并设定其初始长度为10。
2. 插入元素:在顺序表中插入若干个元素,观察插入操作的效果。
我们可以通过在表尾插入元素,或者在表中间插入元素来测试插入操作的性能。
3. 删除元素:从顺序表中删除指定位置的元素,并观察删除操作的效果。
我们可以选择删除表尾元素或者表中间元素来测试删除操作的性能。
4. 查找元素:在顺序表中查找指定元素,并返回其位置。
我们可以选择查找表头元素、表尾元素或者表中间元素来测试查找操作的性能。
5. 扩容操作:当顺序表的长度不足以容纳更多元素时,我们需要进行扩容操作。
在实验中,我们可以在插入元素时观察到扩容操作的效果。
四、实验结果与分析1. 初始化顺序表:成功创建了一个长度为10的空顺序表。
2. 插入元素:通过在表尾插入10个元素,我们观察到插入操作的时间复杂度为O(1)。
然而,当我们在表中间插入元素时,需要将插入位置之后的所有元素后移,时间复杂度为O(n)。
3. 删除元素:从表尾删除元素的时间复杂度为O(1),而从表中间删除元素需要将删除位置之后的所有元素前移,时间复杂度为O(n)。
4. 查找元素:在顺序表中查找元素的时间复杂度为O(n),因为需要逐个比较每个元素。
5. 扩容操作:当顺序表的长度不足以容纳更多元素时,我们需要进行扩容操作。
在实验中,我们观察到扩容操作的时间复杂度为O(n),因为需要将原有元素复制到新的更大的空间中。
五、实验总结通过本次实验,我们深入了解了顺序表的基本操作和性能。
顺序表的插入、删除和查找操作的时间复杂度与操作位置有关,需要注意选择合适的操作位置以提高效率。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
课程 数据结构 实验名称 顺序表基本操作
专业 计算机科学与技术 年 9 班级_ 月 8日 _ 学号_ _ 实验日期: 2010
第
姓名
页
评分
一、实验目的
1.学会定义线性表的顺序存储类型,实现 C 程序的基本结构,对线性表的一 些基本操作和具体的函数定义。 2.掌握顺序表的基本操作,实现顺序表的插入、删除、查找以及求并集等运 算。
二、实验要求
1.预习 C 语言中结构体的定义与基本操作方法。 2.对顺序表的每个基本操作用单独的函数实现。 3.编写完整程序完成下面的实验内容并上机运行。 4.整理并上交实验报告。
三、实验内容
1.编写程序实现顺序表的下列基本操作: (1)初始化顺序表 La。 (2)将 La 置为空表。 (3)销毁 La。 (4)在 La 中插入一个新的元素。 (5)删除 La 中的某一元素。 (6)在 La 中查找某元素, 若找到, 则返回它在 La 中第一次出现的位置, 否则返回 0。 (7)打印输出 La 中的元素值。 2.编写程序完成下面的操作: (1)构造两个顺序线性表 La 和 Lb,其元素都按值非递减顺序排列。 (2)实现归并 La 和 Lb 得到新的顺序表 Lc, Lc 的元素也按值非递减顺 序排列。 (3)假设两个顺序线性表 La 和 Lb 分别表示两个集合 A 和 B,利用 union_Sq 操作实现 A=A∪ B。
-6-
-3-
while (i <= L.length && !(*compare)(*p++, e)) ++i; if (i <= L.length) return i; else return 0; } void PrintList_Sq(SqList L) { int i; for(i=0;i<L.length;i++) printf("%d ",L.elem[i]); printf("\n"); } int main() { SqList La; int i,n,e; printf("请输入元素个数: \n"); scanf("%d",&n); if(InitList_Sq(La)) { for(i=1;i<=n;i++) { scanf("%d",&e); ListInsert_Sq(La,i,e); } printf("-------------------------------------\n 你输入的元素分别为:\n"); PrintList_Sq(La); printf("-------------------------------------\n"); } else { printf("初始化线性表出错! \n"); printf("-------------------------------------\n"); } printf("请输入你要插入的元素及插入的位置:\n");//插入元素 scanf("%d%d",&e,&i); if(ListInsert_Sq(La,i,e)) { printf("插入元素后线性表为:\n"); PrintList_Sq(La); printf("-------------------------------------\n"); }
四、实验步骤
一 1. 编 写 头 文 件 。 定 义 数 据 类 型 。 分 别 写 各 个 函 数 如 ListInsern_Sq , ListDelete_Sq,LocateElem 等函数。 2.编写主函数。 在主函数里构造空的线性表, 然后利用 ListInsert 函数使用户 初始化线性表。然后调用函数操作,操作结果用 PrintList_Sq 打印出线性表的内 容 3.运行程序,完整代码见下:
-2-
return OK; } Status ClearList_Sq(SqList &L) {//清空线性表 L.length=0;//memset(L,0,sizeof(L)); return OK; } Status ListInsert_Sq(SqList &L, int i, ElemType e) {// 在顺序线性表 L 的第 i 个元素之前插入新的元素 e ElemType *p; if (i < 1 || i > L.length+1) return ERROR; if (L.length >= L.listsize) { ElemType *newbase = *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof (ElemType)); if (!newbase) return ERROR; L.elem = newbase; L.listsize += LISTINCREMENT; } ElemType *q = &(L.elem[i-1]); for (p = &(L.elem[L.length-1]); p>=q; --p) *(p+1) = *p; *q = e; ++L.length; return OK;
-5-
{ printf("线性表已撤销。 \n"); printf("--------------------------------------\n"); } else { printf("线性表清空出错。\n"); printf("--------------------------------------\n"); } return 0; } 二 1.编写头文件。定义数据类型。分别写需要用到的函数。在 Union_Sq 里需要 用的函数有 ListInsert_Sq 和 ListDelete_Sq 和 LocateElem_Sq 函数, 所以这三个函 数需要编写。同样设有 PrintList_Sq 函数来打印操作结果。 2.编写主函数分别使用户输入 La 与 Lb 的各个元素值,操作后用 PrintList_Sq 输出操作结果。 3.运行程序,完整代码见下。 //data struct 实验一 线性表基本操作 2 #include<stdio.h> #include<stdlib.h> #define TRUE 1 #define FALSE 0 #define YES 1 #define NO 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 typedef int Status; typedef int ElemType ; #define LIST_INIT_SIZE 100 #define LISTINCERMENT 10 typedef struct { ElemType *elem; int length; int listsize; }SqList; Status InitList_Sq(SqList &L) {//构造空的顺序表 La L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(Ele mType)); if(!L.elem)exit(OVERFLOelete_Sq(SqList &L, int i, ElemType &e) { // 在顺序线性表 L 中删除第 i 个元素,并用 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; } // ListDelete_Sq Status LocateElem_Sq(SqList L, ElemType e,Status (*compare)(ElemType, ElemType)) { // 在顺序线性表 L 中查找第 1 个值与 e 满足 compare()的元素的位序 int i; ElemType *p; i = 1; p = L.elem;
-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))//撤销线性表