数据结构实验一顺序表的实现

合集下载

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

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

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

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

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

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

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

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

我们通过 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);}。

数据结构与算法分析实验报告

数据结构与算法分析实验报告

数据结构与算法分析实验报告一、实验目的本次实验旨在通过实际操作和分析,深入理解数据结构和算法的基本概念、原理和应用,提高解决实际问题的能力,培养逻辑思维和编程技巧。

二、实验环境本次实验使用的编程语言为 Python,使用的开发工具为 PyCharm。

操作系统为 Windows 10。

三、实验内容(一)线性表的实现与操作1、顺序表的实现使用数组实现顺序表,包括插入、删除、查找等基本操作。

通过实验,理解了顺序表在内存中的存储方式以及其操作的时间复杂度。

2、链表的实现实现了单向链表和双向链表,对链表的节点插入、删除和遍历进行了实践。

体会到链表在动态内存管理和灵活操作方面的优势。

(二)栈和队列的应用1、栈的实现与应用用数组和链表分别实现栈,并通过表达式求值的例子,展示了栈在计算中的作用。

2、队列的实现与应用实现了顺序队列和循环队列,通过模拟银行排队的场景,理解了队列的先进先出特性。

(三)树和二叉树1、二叉树的遍历实现了先序、中序和后序遍历算法,并对不同遍历方式的结果进行了分析和比较。

2、二叉搜索树的操作构建了二叉搜索树,实现了插入、删除和查找操作,了解了其在数据快速查找和排序中的应用。

(四)图的表示与遍历1、邻接矩阵和邻接表表示图分别用邻接矩阵和邻接表来表示图,并比较了它们在存储空间和操作效率上的差异。

2、图的深度优先遍历和广度优先遍历实现了两种遍历算法,并通过对实际图结构的遍历,理解了它们的应用场景和特点。

(五)排序算法的性能比较1、常见排序算法的实现实现了冒泡排序、插入排序、选择排序、快速排序和归并排序等常见的排序算法。

2、算法性能分析通过对不同规模的数据进行排序实验,比较了各种排序算法的时间复杂度和空间复杂度。

四、实验过程及结果(一)线性表1、顺序表在顺序表的插入操作中,如果在表头插入元素,需要将后面的元素依次向后移动一位,时间复杂度为 O(n)。

删除操作同理,在表头删除元素时,时间复杂度也为 O(n)。

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

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

实验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.运行结果示意图:六、总结本次实验是数据结构这门课程的第一次上机实验课,由于上课前未能很好地预习,以至于课上不能够完全明白老师所讲内容。

顺序表的实现实验报告

顺序表的实现实验报告

顺序表的实现实验报告顺序表的实现实验报告1. 引言顺序表是一种常见的数据结构,它可以用于存储一组有序的元素。

在本实验中,我们将探索顺序表的实现方式,并通过实验验证其性能和效果。

2. 实验目的本实验的主要目的是掌握顺序表的实现原理和基本操作,并通过实验对比不同操作的时间复杂度。

3. 实验方法3.1 数据结构设计我们选择使用静态数组作为顺序表的底层存储结构。

通过定义一个固定大小的数组,我们可以实现顺序表的基本操作。

3.2 基本操作实现在顺序表的实现中,我们需要实现以下基本操作:- 初始化操作:创建一个空的顺序表。

- 插入操作:向顺序表中插入一个元素。

- 删除操作:从顺序表中删除一个元素。

- 查找操作:在顺序表中查找指定元素。

- 获取长度:获取顺序表中元素的个数。

4. 实验步骤4.1 初始化操作首先,我们需要创建一个空的顺序表。

这可以通过定义一个数组和一个变量来实现,数组用于存储元素,变量用于记录当前顺序表的长度。

4.2 插入操作在顺序表中插入一个元素的过程如下:- 首先,判断顺序表是否已满,如果已满则进行扩容操作。

- 然后,将要插入的元素放入数组的末尾,并更新长度。

4.3 删除操作从顺序表中删除一个元素的过程如下:- 首先,判断顺序表是否为空,如果为空则返回错误信息。

- 然后,将数组中最后一个元素删除,并更新长度。

4.4 查找操作在顺序表中查找指定元素的过程如下:- 首先,遍历整个数组,逐个比较元素与目标元素是否相等。

- 如果找到相等的元素,则返回其位置;如果遍历完仍未找到,则返回错误信息。

4.5 获取长度获取顺序表中元素个数的过程如下:- 直接返回记录长度的变量即可。

5. 实验结果与分析在实验中,我们通过对大量数据进行插入、删除、查找等操作,记录了每个操作的耗时。

通过对比不同操作的时间复杂度,我们可以得出以下结论:- 初始化操作的时间复杂度为O(1),因为只需要创建一个空的顺序表。

- 插入和删除操作的时间复杂度为O(n),因为需要遍历整个数组进行元素的移动。

数据结构实验一顺序表的实现

数据结构实验一顺序表的实现

数据结构实验⼀顺序表的实现数据结构实验⼀顺序表的实现数据结构实验⼀顺序表的实现班级学号姓名分数⼀、实验⽬的:1. 熟悉线性表的基本运算在两种存储结构(顺序结构和链式结构)上的实现;2. 以线性表的各种操作的实现为重点;3. 通过本次学习帮助学⽣加深C语⾔的使⽤,掌握算法分析⽅法并对已经设计出的算法进⾏分析,给出相应的结果。

⼆、实验要求:编写实验程序,上机运⾏本程序,保存程序的运⾏结果,结合程序进⾏分析并写出实验报告。

三、实验内容及分析:1.顺序表的建⽴建⽴⼀个含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。

程序如下:头⽂件SqList.h的内容如下:#include#include#define LIST_INIT_SIZE 100#define LISTINCREMENT 10#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int ElemType;typedef int Status;typedef struct{ElemType *elem;int length;int listsize;}SqList;L->length=0;L->listsize=LIST_INIT_SIZE;return OK;}Status CreatList_Sq(SqList *L,int n)1{int i;printf("输⼊%d个整数:\n",n);for(i=0;iscanf("\n%d",&L->elem[i]);return OK;}//以下是整个源程序:#include#include"SqList.h"int main(){int i,n;SqList a;SqList *l = &aif(InitList_Sq(l)==-2) printf("分配失败");printf("\n输⼊要建⽴的线性表l的长度n:");//输⼊线性表得长度scanf("%d",&n); l->length=n;printf("线性表的长度是:%d\n",l->length);CreatList_Sq(l,n);//⽣成线性表printf("输出线性表l中的元素值:");//输出线性表中的元素for(i=0;ilength;i++)printf("%7d",l->elem[i]);getchar();}程序的运⾏结果:利⽤前⾯的实验先建⽴⼀个顺序表L,然后再第i个位置插⼊元素,通过对⽐插⼊元素前后的线性表发⽣的变化,判断插⼊操作是否正确。

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

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

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

数据结构实验一顺序表的实现

数据结构实验一顺序表的实现

算法分析实验一顺序表的实现班级学号姓名分数一、实验目的:1.掌握线性表的顺序存储结构2.能熟练地利用顺序存储结构实现线性表的基本操作3.能熟练地掌握顺序存储结构中算法的实现二、实验要求熟悉线形表的基本操作,对线形表能够进行插入、删除、修改、查找等操作。

三、实验内容及分析:建立含有若干个元素的顺序表,并将结果在屏幕上输出。

对刚建立的顺序表实现插入、删除、修改、查找,并将结果在屏幕上输出。

内容分析:先建立一个顺序表,定义表的最大长度为100,程序可以实现输出、查找、插入、删除操作。

先定义一个整型变量i,用于初始线性表的长度,再输入所有元素,选择菜单里的选项实现功能。

插入:选择需插入元素的位置,插入位置及后面的元素后移一位,再插入元素;删除:选择要删除元素的位置,将要删除的元素移出顺序表,删除位置后的元素前移一位;查找:输入要查找的元素,按顺序查找,当查找到顺序表的第一个与要查找的元素相同时,输出结果。

四、程序的调试及运行结果五、程序代码#include <iostream>using namespace std;const int Max=100; <<endl;cout <<endl;initial(s); 示所有元素. " <<endl;cout <<" 2.插入一个元素." <<endl;cout <<" 3.删除一个元素." <<endl;cout <<" 4.查找一个元素." <<endl;cout <<" 5.结束程序." <<endl;cout <<"---------------------------" <<endl;cout <<"请选择:" ;cin >>j;switch(j){case '1':print(s);break; 2 a <<endl;else if(temp==true)print(s);break;}case '3':{cout <<"请输入要删除元素的位置: ";cin >>loc; //输入要删除的元素的位置temp=del(s,loc,ch); //删除检查if(temp==true)cout <<"删除了一个元素: " <<ch <<endl;elsecout <<"该元素不存在!" <<endl;print(s);break;}case '4':{cout <<"请输入要查找的元素: " ;cin >>ch; //输入要查找的元素loc=locate(s,ch); //寻找元素的位置if(loc!=-1){cout <<"该元素所在位置: " ;cout <<(loc+1) <<endl;}elsecout <<"该元素不存在!" <<endl;break;}default:flag=0;cout <<"程序结束,按任意键退出!" <<endl;}}}//初始化线性表void initial(seqlist &v){int i;cout <<"请输入初始线性表长度:n=";cin >>;c out <<"请输入各元素/字符[中间用空格隔开](例如:a b c d): ";for(i=0;i<;i++)cin >>&[i];}//插入一个元素,成功返回True,失败返回Falsebool insert (seqlist &v,int loc,char ch){int i;i f((loc<1)||(loc>+1)){cout <<"插入位置不合理!" <<endl; //位置错误return false;}else if>=Max){cout <<"超出线性表最大容量!" <<endl; //溢满return false;}else{for(i=;i>=loc-1;i--)[i+1]=[i]; //插入位置后的元素后移[loc-1]=ch; //插入元素++; //表长度加1return true;}}//删除一个元素,成功返回True,并用ch返回该元素值,失败返回False bool del(seqlist &v,int loc,char &ch){int j;if(loc<1||loc>{cout <<"删除位置不合理!" <<endl;return false;}else{ch=[loc-1]; //将删除位置的元素赋给chfor(j=loc-1;j<;j++)[j]=[j+1]; //删除位置后元素前移; //表长度减1return true;}}//在线性表中查找ch的位置,成功返回其位置,失败返回-1 int locate(seqlist v,char ch){int i=0;w hile(i<&&[i]!=ch)i++;if[i]==ch)return i;else return (-1);}//显示线性表的所有元素void print(seqlist v){int i;for(i=0;i<;i++)cout <<[i] <<' ';cout <<endl;}。

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

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

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

二、实验环境本次实验使用的编程语言为 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 语言项目。

实验1-顺序表的实现

实验1-顺序表的实现

程序代码编写的要求
• 请首先建立project • 然后创建一个头文件×××.h,其中有你的程 序中要用的数据类型,以及实现各种操作的函 数的声明(不包括函数体)。 • 再创建一个×××.cpp,其中有各个函数的函 数体(具体实现)。 • 最后创建主函数(程序入口) ×××.cpp ,其 中有用于输入、输出的语句,和一些必要的测 试数据。它来调用上述的函数。
实验(1)顺序表的实现
实验目的
•熟悉使用C编写代码实现算法。 • 掌握结构体的使用。 • 熟悉在顺序表上进行的各种操作。
实验要求
• 编写C(C++)应用程序,实现顺序表 上的各自操作:初始化,销毁,插入, 删除,定位,求表长、“判空”以及 “存取第 i 个数据元素”。
实验报告的书写要求
• • • • • 实验目的 实验要求 实验环境 程序代码 程序的调试与分析

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

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

数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现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、掌握使用VC++上机调试顺序表的基本方法;2、掌握顺序表的基本操作:建立、插入、删除等运算。

二、实验仪器安装VC++软件的计算机。

三、实验原理利用线性表的特性以及顺序存储结构特点对线性表进行相关的基本操作四、实验内容程序中演示了顺序表的创建、插入和删除。

程序如下:#include#include/*顺序表的定义:*/#define ListSize 100typedef struct{ int data[ListSize]; /*向量data用于存放表结点*/i nt length; /*当前的表长度*/}SeqList;void main(){ void CreateList(SeqList *L,int n);v oid PrintList(SeqList *L,int n);i nt LocateList(SeqList *L,int x);v oid InsertList(SeqList *L,int x,int i);v oid DeleteList(SeqList *L,int i);SeqList L;i nt i,x;i nt n=10;L.length=0;c lrscr();C reateList(&L,n); /*建立顺序表*/P rintList(&L,n); /*打印建立后的顺序表*/p rintf("INPUT THE RESEARCH ELEMENT");s canf("%d",&x);i=LocateList(&L,x);p rintf("the research position is %d\n",i); /*顺序表查找*/ p rintf("input the position of insert:\n");s canf("%d",&i);p rintf("input the value of insert\n");s canf("%d",&x);I nsertList(&L,x,i); /*顺序表插入*/P rintList(&L,n); /*打印插入后的顺序表*/p rintf("input the position of delete\n");s canf("%d",&i);D eleteList(&L,i); /*顺序表删除*/P rintList(&L,n); /*打印删除后的顺序表*/g etchar();}/*顺序表的建立:*/void CreateList(SeqList *L,int n){int i;printf("please input n numbers\n");for(i=1;i<=n;i++)scanf("%d",&L->data[i]);L->length=n;}/*顺序表的打印:*/void PrintList(SeqList *L,int n){int i;printf("the sqlist is\n");for(i=1;i<=n;i++)printf("%d ",L->data[i]);}/*顺序表的查找:*/int LocateList(SeqList *L,int x){int i;for(i=1;i<=10;i++)if((L->data[i])==x) return(i);else return(0);}/*顺序表的插入:*/void InsertList(SeqList *L,int x,int i){int j;for(j=L->length;j>=i;j--)L->data[j+1]=L->data[j];L->data[i]=x;L->length++;}void DeleteList(SeqList *L,int i) /*顺序表的删除:*/ { int j;for(j=i;j<=(L->length)-1;j++)L->data[j]=L->data[j+1];}五、实验步骤1、认真阅读和掌握本实验的程序。

数据结构实验一 顺序表的实现

数据结构实验一    顺序表的实现

cout <<v.elem[i] <<' '; cout <<endl; }
} default: flag=0; cout <<"程序结束,按任意键退出!" <<endl; } } } //初始化线性表 void initial(seqlist &v) { int i; cout <<"请输入初始线性表长度:n="; cin >>st; cout <<"请输入各元素/字符[中间用空格隔开](例如:a b c d): "; for(i=0;i<st;i++) cin >>&v.elem[i]; } //插入一个元素,成功返回True,失败返回False bool insert (seqlist &v,int loc,char ch) { int i; if((loc<1)||(loc>st+1)) { cout <<"插入位置不合理!" <<endl; //位置错误 return false; } else if(st>=Max) { cout <<"超出线性表最大容量!" <<endl; //溢满 return false; } else { for(i=st-1;i>=loc-1;i--) v.elem[i+1]=v.elem[i]; //插入位置后的元素后移 v.elem[loc-1]=ch; //插入元素 st++; //表长度加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退出。

《数据结构》实验指导书(C语言版)(浦江学院)

《数据结构》实验指导书(C语言版)(浦江学院)

实验1: 顺序表的操作实验一、实验名称和性质二、实验目的1.掌握线性表的顺序存储结构的表示和实现方法。

2.掌握顺序表基本操作的算法实现。

3.了解顺序表的应用。

三、实验内容1.建立顺序表。

2.在顺序表上实现插入、删除和查找操作(验证性内容)。

3.删除有序顺序表中的重复元素(设计性内容)。

四、实验的软硬件环境要求硬件环境要求:PC机(单机)使用的软件名称、版本号:Windows环境下的VC++6.0五、知识准备前期要求熟练掌握了C语言的编程规则、方法和顺序表的基本操作算法。

六、验证性实验1.实验要求编程实现如下功能:(1)根据输入顺序表的长度n和各个数据元素值建立一个顺序表,并输出顺序表中各元素值,观察输入的内容与输出的内容是否一致。

(2)在顺序表的第i个元素之前插入一个值为x的元素,并输出插入后的顺序表中各元素值。

(3)删除顺序表中第i个元素,并输出删除后的顺序表中各元素值。

(4)在顺序表中查找值为e的数据元素,如果查找成功,则显示“查找成功”和该元素在顺序表中的位置,否则显示“查找失败”。

2. 实验相关原理线性表的顺序存储结构称为顺序表,顺序表的存储结构描述为:#define MAXLEN 30 /*线性表的最大长度*/typedef struct{Elemtype elem[MAXLEN]; /*顺序表中存放元素的数组,其中elemtype为抽象数据类型,在程序具体实现时可以用任意类型代替*/int length; /*顺序表的长度,即元素个数*/}Sqlist; /*顺序表的类型*/【核心算法提示】(1)顺序表插入操作的基本步骤:要在顺序表中的第i个数据元素之前插入一个数据元素x,首先要判断插入位置i是否合法,假设线性表的表长为n,则i的合法值范围:1≤i ≤n+1,若是合法位置,就再判断顺序表是否满,如果满,则增加空间或结束操作,如果不满,则将第i个数据元素及其之后的所有数据元素都后移一个位置,此时第i个位置已经腾空,再将待插入的数据元素x插入到该位置上,最后将线性表的表长增加1。

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

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

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

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

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

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

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

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

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

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

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

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

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

- 当前元素个数加一。

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

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

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

- 当前元素个数减一。

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

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

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

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

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

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

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

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

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

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

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

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

实验一 顺序表的实现和应用

实验一  顺序表的实现和应用

实验一顺序表的实现和应用一、实验目的⑴熟悉线性表的定义和基本操作;⑵掌握线性表的顺序存储结构设计与基本操作的实现;二、实验内容与要求⑴定义线性表的顺序存储表示;⑵基于所设计的存储结构实现线性表的基本操作;⑶编写一个主程序对所实现的线性表进行测试;⑷线性表的应用:使用菜单方式实现顺序表的各种操作,例如:创建、插入、删除、显示等等。

二、数据结构设计在主函数中实现函数的调用,从而实现线性表的创建(CREATE),插入(INSERT),删除(DELETE),显示(DISPLAY).等操作。

利用一个switch函数实现线性表的各种操作。

三、测试结果刚开始测试的时候,有很多报错和警告,有些是语法问题,有些是没定义就使用变量,有些地方是少了括号。

然后慢慢地改,错误越来越少,后来就嫩成功地运行了。

然后根据操作顺序一步步实现了线性表的各种操作。

四、心得体会在写程序时首先要分析怎样来实现目标,设计可行的算法,进行测试。

不要怕报错,只要一步一步地改,就能把所有的错改正过来。

跟重要的是要上机敲代码,不能只看别人写,自己不动手,另外,别人的意见也是非常重要的。

非常感谢指导我的大四学长,对于一个不善于写程序的人来说,耐心的指导是在是非常难得,她告诉我怎样设计整个程序的框架。

MAIN.C 方丽平信计1203班1130112321 修改时间2014/3/24#include<stdio.h>#include<stdlib.h>#define maxsize 1024typedef int datatype;typedef struct{int data[maxsize];int last;}SqList;void main(){int CREATE(SqList *L);int INSERT(SqList *L,int i, int x);int DELETE(SqList *L,int i);int DISPLAY(SqList *L);int i,value,x;SqList List;SqList *p;p = &List;while(1){printf("the program \n");printf("can realize to create,insert,delete,display,etc\n"); printf("1:create the ranked list\n");printf("2:insert a data\n");printf("3:delete a data\n");printf("4:display all the data\n");printf("5:return,end of the program\n");printf("selection of operation\n");scanf("%d",&i);while ( i < 1 || i > 5 ){printf("error,please input again\n");scanf("%d",&i);}switch(i){case 1:CREATE(p);break;case 2:/*INSERT(p);*/printf("error,please input insert place\n");scanf("%d",&value);printf("error,please input insert value\n");scanf("%d",&x);INSERT(p, value, x);break;case 3:printf("error,please input delete value\n");scanf("%d",&value);DELETE(p, value);break;case 4:DISPLAY(p);break;case 5:exit(0);break;}}}int CREATE(SqList *L){int i,n;do{printf("input the data of the number");scanf("%d",&n);if(n<1||n>maxsize)printf("error,please input again");}while(n<1||n>maxsize);(*L).last=n;for(i=0;i<n;i++)(*L).data[i]=1+rand()%100;for(i=0;i<n;i++){printf("%5d",(*L).data[i]);if((i+1)%10==0) printf("\n");}return 0;}int INSERT(SqList *L,int i, int x){int j;if(((*L).last) >= maxsize-1){printf("overflow");return -1;}elseif(i < 1 || i >(*L).last + 2){printf("ERROR");return -1;}else{for( j = (*L).last; j >= i-1; j-- )(*L).data[j+1] = (*L).data[j];(*L).data[i-1] = x;(*L).last = (*L).last+1;}return(1);}int DELETE(SqList *L,int i){int j;if((*L).last<0){printf("Empty");return -1;}elseif(i < 1 || i>(*L).last + 1){printf("ERROR");return -1;}else{for(j=i; j <= (*L).last; j++)(*L).data[j-1] = (*L).data[j];(*L).last --;}return(1);}int DISPLAY(SqList *L){int i;if((*L).last<1)printf("empty??please create the ranked list ");else{for(i=0; i< (*L).last; i++){printf("%5d",(*L).data[i]);if((i+1)%10==0)printf("\n");}}return 0;}。

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

数据结构实验一顺序表的实现班级学号分数一、实验目的:1.熟悉线性表的基本运算在两种存储结构(顺序结构和链式结构)上的实现;2.以线性表的各种操作的实现为重点;3.通过本次学习帮助学生加深C语言的使用,掌握算法分析方法并对已经设计出的算法进行分析,给出相应的结果。

二、实验要求:编写实验程序,上机运行本程序,保存程序的运行结果,结合程序进行分析并写出实验报告。

三、实验容及分析:1.顺序表的建立建立一个含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。

程序如下:头文件SqList.h的容如下:#include<stdio.h>#include<malloc.h>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int ElemType;typedef int Status;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 CreatList_Sq(SqList *L,int n){int i;printf("输入%d个整数:\n",n);for(i=0;i<n;i++)scanf("\n%d",&L->elem[i]);return OK;}//以下是整个源程序:#include<stdio.h>#include"SqList.h"int main(){int i,n;SqList a;SqList *l = &a;if(InitList_Sq(l)==-2) printf("分配失败");printf("\n输入要建立的线性表l的长度n:");//输入线性表得长度scanf("%d",&n);l->length=n;printf("线性表的长度是:%d\n",l->length);CreatList_Sq(l,n);//生成线性表printf("输出线性表l中的元素值:");//输出线性表中的元素for(i=0;i<l->length;i++)printf("%7d",l->elem[i]);getchar();}程序的运行结果:2.顺序表的插入利用前面的实验先建立一个顺序表L,然后再第i个位置插入元素,通过对比插入元素前后的线性表发生的变化,判断插入操作是否正确。

参考程序:#include<stdio.h>#include<malloc.h>#include"SqList.h"Status ListInsert_Sq(SqList *L,int i,ElemType e){//在线性表L中的第i个位置前插入一个值为e的元素//i的取值围:1<=i<=ListLength_Sq(L)ElemType *newbase,*q,*p;if(i<1||i>L->length+1) return ERROR;//i值不合法if(L->length>=L->listsize){ //当前存储空间已满,增加分配量newbase=(ElemType*)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(ElemType));if(!newbase) return (OVERFLOW); //存储分配失败L->elem=newbase; //新基址L->length=+LISTINCREMENT; //增加存储容量}//ifq=&(L->elem[i-1]); //q为插入位置for(p=&(L->elem[L->length-1]);p>=q;--p) *(p+1)=*p;//插入位置及以后的元素右移*q=e; //插入e++L->length; //表长增1return OK;}//ListInsert_Sqint main(){int n,i,x;SqList *L,a;L=&a;InitList_Sq(L);printf("\n输入要建立的线性表L得长度:");scanf("%d",&n);L->length=n;CreatList_Sq(L,n);printf("\n插入元素之前线性表L的长度是:%d",L->length);printf("\n插入元素之前线性表L中的元素是:");for(i=0;i<L->length;i++)printf("%5d",L->elem[i]);printf("\n输入要插入元素的位置:");scanf("%d",&i);printf("\n输入要插入的元素的值:");scanf("\n %d",&x);if(ListInsert_Sq(L,i,x)>0){printf("\n插入元素之后线性表L的长度是: %d ",L->length);printf("\n插入元素之后线性表L的元素是:\n");for(i=0;i<L->length;i++)printf("%5d", L->elem[i]);}//ifelseprintf("不能插入这个元素!\n");getchar();}运行结果:4.单链表的实现新建链表,生成一个有一定结点的链表,并且顺序输出。

程序代码:#include"stdio.h"#include"stdlib.h"#include"string.h"#define null 0#define MAX 100 //最多元素个数#define LENGTH sizeof(struct Node)typedef int Elem ; //数据元素类型//单链表实现线性表struct Node{Elem data; //数据域struct Node *next; //指针域};typedef struct Node NODE;typedef struct Node *LINKLIST;//初始化链表,产生一个空链表LINKLIST InitList()//返回空链表的头指针{LINKLIST head;head=null;return head;}//新建链表,生成一个有一定结点的链表LINKLIST CreateList()//返回新链表的首地址(指针){LINKLIST head=null,p,q;int n,i;Elem temp;do{printf("请输入要建的结点数:");scanf("%d",&n);if(n<1 || n>MAX)printf("对不起!请输入的数在1-%d之间,请重新输入。

\n",MAX);}while(n<1 || n>MAX);for(i=0;i<n;i++){p=(LINKLIST)malloc(LENGTH); //开辟新结点空间printf("请输入第%d结点数据:",i+1);scanf("%d",&temp); //输入结点数据p->data=temp;if(head==null) //如果head指向空,则p结点为第一个结点{head=q=p;p->next=null;}else //不是第一个结点,则结点放到结尾并且,尾指针后移{p->next=null;q->next=p;q=p;}}return head; //返回新链表的首地址(指针)}//遍历打印链表int printList(LINKLIST h)//返回打印结果,0表示无数据,1表示成功打印完成{LINKLIST pt=h;if(pt==null) //没有数据直接返回{printf("对不起,没有数据!");return 0;}while(pt) //结点不为空就打印结点容{printf("%d ",pt->data);pt=pt->next;}printf("\n");return 1;}//求的链表的长度int ListLength(LINKLIST h)//求的链表长度,返回链表长度,若链表为空则返回0{LINKLIST pt=h;int len=0; //初始化计数器为0while(pt){len++;pt=pt->next;}return len; //返回链表长度}/*//向链表链表尾部添加结点,无输入LINKLIST AddNode(LINKLIST h,Elem e){LINKLIST head,pt,p;pt=head=h; //指向起始结点p=(LINKLIST)malloc(LENGTH); //开辟结点空间p->data=e; //向结点数据赋值p->next=null; //结点后继指向空if(pt==null) //若链表为空,直接作为第一个结点head=p;else //若不为空,将结点插在最后{while(pt->next){pt=pt->next;}pt->next=p;}return head; //返回头结点指针}*//*//向链表链表尾部添加结点,有输入LINKLIST AddNode(LINKLIST h){LINKLIST head,pt,p;pt=head=h; //指向起始结点p=(LINKLIST)malloc(LENGTH); //开辟结点空间printf("请输入要添加的数据:");scanf("%d",&p->data);p->next=null; //结点后继指向空if(pt==null) //若链表为空,直接作为第一个结点head=p;else //若不为空,将结点插在最后{while(pt->next){pt=pt->next;}pt->next=p;}return head; //返回头结点指针}*///将结点插入到链表的指定位置LINKLIST AddNode(LINKLIST h,int i,Elem e)//插入位置i,0<i,若i大于链表长度,则直接插在链表最后{LINKLIST head,pt,p;int j;pt=head=h;if(i<1) //插入位置错误(i<1),输出信息并结束程序{printf("程序出错,请检查参数!");exit(1);}if(pt && i>ListLength(h)) //链表不为空,且位置大于链表长度时{while(pt->next){pt=pt->next;}p=(LINKLIST)malloc(LENGTH); //开辟结点空间p->data=e; //向结点数据赋值p->next=null; //结点后继指向空pt->next=p;}else if(pt==null) //链表为空时{p=(LINKLIST)malloc(LENGTH); //开辟结点空间p->data=e; //向结点数据赋值p->next=null; //结点后继指向空head=p;}else //参数正确且链表不为空时{if(i==1) //插入点为第1个位置{p=(LINKLIST)malloc(LENGTH); //开辟结点空间p->data=e; //向结点数据赋值p->next=pt; //结点后继指向空head=p;}else //插入在链表中间位置时{p=(LINKLIST)malloc(LENGTH); //开辟结点空间p->data=e; //向结点数据赋值for(j=1;j<i-1;j++){pt=pt->next;}p->next=pt->next;pt->next=p;}}return head; //返回头结点指针}//删除链表中的某位置结点LINKLIST ListDelete(LINKLIST h,int i)//i在1到ListLength(h)之间{LINKLIST head,pt;int j=1;pt=head=h;if(h==null) //空表{printf("对不起,没有容!");return null;}if(i<1 || i>ListLength(h)) //检查i的围{printf("程序出错,请检查参数!");exit(1);}else //i合法,{if(i==1) //删除首结点{head=pt->next;free(pt);}else //删除中间节点或尾结点{while(j<i-1){pt=pt->next;j++;}pt->next=pt->next->next;}}return head; //返回头结点指针}//链表是否为空int ListEmpty(LINKLIST h)//返回0表示空,1表示链表不空{if(h==null)return 0;return 1;}//取得指定位置的元素的值Elem GetElem(LINKLIST h,int i)//返回结点的元素值{LINKLIST pt=h;int j=1;if(i>ListLength(h) || i<1) //检查参数{printf("程序出错,请检查参数!");exit(1);}while(j<i) //找到第i个结点{pt=pt->next;j++;}return (pt->data); //返回结点值}//链表的逆置LINKLIST Invert(LINKLIST h){LINKLIST head,middle,trail; //定义三个指针指向三个相邻的结点middle=null;while(h){ //循环交换相邻两个的指针指向trail=middle;middle=h;h=h->next;middle->next=trail;}head=middle; //将最后的结点变为链表头return head; //返回链表表头}//将两个链表合并为一个链表LINKLIST Union(LINKLIST La,LINKLIST Lb)//将La和Lb连接在一块,返回连接后的链表头指针{LINKLIST head,pa;if(La==null)head=Lb;else{head=pa=La;while(pa->next){pa=pa->next;}pa->next=Lb; //将Lb表头连接在链表La的结尾}return head; //返回链表表头}//将链表按非递减排序LINKLIST ToUpSort(LINKLIST h)//返回排好序后的头指针{LINKLIST p=h,q,temp;temp=(LINKLIST)malloc(LENGTH); //开辟临时交换结点while(p){q=p->next;while(q){if(q->data<p->data) //比较大小交换数据{temp->data=p->data;p->data=q->data;q->data=temp->data;}q=q->next;}p=p->next;}free(temp); //释放临时空间return h; //返回头结点}//将链表按非递增排序LINKLIST ToDownSort(LINKLIST h)//返回排好序后的头指针{LINKLIST p=h,q,temp;temp=(LINKLIST)malloc(LENGTH); //开辟临时交换结点while(p){q=p->next;while(q){if(q->data>p->data) //比较大小交换数据{temp->data=p->data;p->data=q->data;q->data=temp->data;}q=q->next;}p=p->next;}free(temp); //释放临时空间return h; //返回头结点}//比较结点大小int compare(NODE e1,NODE e2)//若e1>e2返回1,若e1=e2返回0,若e1<e2返回-1{return 0;}int main(){LINKLIST p,q;Elem n=8,i;p=CreateList();p=ToUpSort(p);printList(p);return 0;}运行结果:。

相关文档
最新文档