数据结构实验2.1顺序表
数据结构实验报告-线性表(顺序表实现)
![数据结构实验报告-线性表(顺序表实现)](https://img.taocdn.com/s3/m/74aa3976f11dc281e53a580216fc700abb6852cb.png)
实验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.归并顺序表(销毁或清空操作前)七、思考讨论题或体会或对改进实验的建议通过本次实验,我掌握了定义线性表的顺序存储类型,加深了对顺序存储结构的理解,进一步巩固和理解了顺序表的基本操作,如建立、查找、插入和删除等。
实验报告一 顺序表的操作
![实验报告一 顺序表的操作](https://img.taocdn.com/s3/m/48e13bccb14e852458fb574e.png)
《数据结构》实验报告一系别:班级:学号:姓名:日期:指导教师:一、上机实验的问题和要求:顺序表的查找、插入与删除。
设计算法,实现线性结构上的顺序表的产生以及元素的查找、插入与删除。
具体实现要求:从键盘输入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");}四、运行输出结果:五、调试和运行程序过程中产生的问题及采取的措施:六、对算法的程序的讨论、分析,改进设想,其它经验教训:七、对实验方式、组织、设备、题目的意见和建议:。
《数据结构》实验指导书
![《数据结构》实验指导书](https://img.taocdn.com/s3/m/d9e2b21d14791711cc7917fe.png)
1.单链表的类型定义
#include <stdio.h>
typedef int ElemType;//单链表结点类型
typedef struct LNode
{ElemType data;
struct LNode *next;
2.明确栈、队列均是特殊的线性表。
3.栈、队列的算法是后续实验的基础(广义表、树、图、查找、排序等)。
六、实验报告
根据实验情况和结果撰写并递交实验报告。
实验四 串
一、预备知识
1.字符串的基本概念
2.字符串的模式匹配算法
二、实验目的
1.理解字符串的模式匹配算法(包括KMP算法)
typedef struct
{ElemType *base;
int front,rear;
} SqQueue;
4.单链队列的类型定义
typedef struct QNode
{QElemType data;
typedef struct list
{ElemType elem[MAXSIZE];//静态线性表
int length; //顺序表的实际长度
} SqList;//顺序表的类型名
五、注意问题
1.插入、删除时元素的移动原因、方向及先后顺序。
4.三元组表是线性表的一种应用,通过它可以更好地理解线性表的存储结构。同时矩阵又是图的重要的存储方式,所以这个实验对更好地掌握线性表对将来对图的理解都有极大的帮助。
六、实验报告
根据实验情况和结果撰写并递交实验报告。
实验六 树和二叉树
一、预备知识
1.二叉树的二叉链表存储结构
数据结构上机实验
![数据结构上机实验](https://img.taocdn.com/s3/m/82cc242c590216fc700abb68a98271fe910eaf35.png)
数据结构上机实验本课程实验中已知的预定义常量和类型如下:#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;实验一顺序表(一)一、 实验目的掌握顺序表的定义、存储结构及其基本操作。
二、 实验内容已知:线性表的动态分配顺序存储结构为#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct{int *elem;int length;int listsize;}SqList;在主程序中调用如下函数实现构造线性表,在线性表中插入数值,最后输出线性表。
1. 编写函数,Status InitList(SqList *L) 实现构造一个空的线性表,若构造成功则返回OK,否则返回ERROR。
2. 编写函数,Status ListInsert(SqList *L , int i , int e) 实现在线性表L中第i个位置之前插入新的数据元素e,L的长度加1。
若插入成功返回OK,否则返回ERROR。
(提示:i的合法值为:i>=1&&i<=L—>length+1)3. 编写函数,void ListPrint(SqList *L)实现将线性表中的元素依次输出到屏幕上。
4.编写函数,int Menu(),输出菜单项请选择你要进行的操作(请输入1-4中的任一个数字):输入1:InitList2:ListInsert3:ListPrint4:Exit实验二顺序表(二)一、 实验目的掌握顺序表的定义、存储结构及其基本操作。
二、 实验内容在实验一的基础上,继续完成如下实验内容。
1.编写函数,Status ListDelete(Splist *L ,int i ,int *e),实现删除L的第i个数据元素,并用e返回其值,L的长度减1。
数据结构实验(使用版)
![数据结构实验(使用版)](https://img.taocdn.com/s3/m/d56bc31ca1c7aa00b52acbed.png)
实验一顺序表的应用一.实验目的1、掌握线性表的顺序存储结构的基本操作的实现。
2、设计并实现顺序表的应用程序,提高编程能力。
二.实验内容编写程序实现:1、在原来的顺序表中将顺序表实现逆置。
2、要求顺序表的内容由用户输入,并分别显示出逆置前和逆置后的顺序表。
三.实验设备及实验环境实验设备:微机一台实验环境:C语言运行环境实验二单链表的应用三.实验目的1、掌握线性表的链式存储结构的基本操作的实现。
2、设计并实现单链表的应用程序,提高编程能力。
四.实验内容编写程序实现:1、在原有的单链表中,将单链表实现逆置。
(即不增加新的结点)2、程序要求单链表的内容由用户输入,并分别显示出逆置前和逆置后的单链表。
三.实验设备及实验环境实验设备:微机一台实验环境:C语言运行环境实验三栈和队列的应用一.实验目的1、掌握栈和队列的基本操作的实现。
2、利用栈和队列的特点解决实际问题,提高编程能力。
二.实验内容(1是必做题目,2和3可选其一)编写两个程序分别实现:1、进制之间的转换:如将10进制转换为2进制,10进制数n和要转换的进制d通过键盘输入。
2、利用栈解决火车调度问题,将本来杂乱无章的车厢排成软席(S)在前,硬席(H)在后。
车厢序列通过键盘输入,如HSHSHSSSH,输出SSSSSHHHH。
3、利用队列模拟医院排队系统。
三.实验设备及实验环境实验设备:微机一台实验环境:C语言运行环境实验四二叉树的操作(一)一、实验目的1、熟悉二叉树的概念和存储结构。
2、掌握二叉树的基本操作和实现方法。
二.实验内容1、利用栈并且采用非递归先序算法建立二叉树。
2、要求通过键盘输入二叉树的先序遍历顺序从而建立一棵二叉树。
三.实验设备及实验环境实验设备:微机一台实验环境:C语言运行环境实验五二叉树的基本操作(二)一、实验目的1.熟悉二叉树的遍历方法。
2.掌握非递归中序遍历、先序遍历和后序遍历算法的实现。
二.实验内容(中序非递归遍历必做、先序和后序可选其一)1、在前一实验的基础上,利用栈实现一棵二叉树的非递归遍历。
数据结构实验报告(C语言)顺序表__排序
![数据结构实验报告(C语言)顺序表__排序](https://img.taocdn.com/s3/m/bfa15faec77da26925c5b072.png)
int i,j,n,x,change; n=L->length; change=1; for(i=1;i<=n-1 && change;++i){
change=0; for(j=1;j<=n-i-1;++j)
if(L->r[j] > L->r[j+1]){ x=L->r[j]; L->r[j]=L->r[j+1]; L->r[j+1]=x; change=1;
void QuickSort(SqeList *L,int low,int high){ int mid; if(low<high){ mid=Partition(L,low,high); QuickSort(L,low,mid-1); QuickSort(L,mid+1,high); }
}
//直接选择排序
printf("\n7-直接选择排序结果为:\n"); SelectSort(&l); PrintList(&l); printf("\n"); printf("\n8-二路归并结果为:\n"); MergeSort(&l);
PrintList(&l); printf("\n"); } else printf("请输入大于 0 的值: "); return 0; }
} else{
MR->r[k]=R->r[j]; ++j; } ++k; } while(i<=mid) MR->r[k++]=R->r[i++]; while(j<=high) MR->r[k++]=R->r[j++]; }
数据结构实验报告—顺序表
![数据结构实验报告—顺序表](https://img.taocdn.com/s3/m/a94a03c7941ea76e58fa04f7.png)
《算法与数据结构》课程实验报告一、实验目的1、实现线性表的顺序存储结构。
2、熟悉C++程序的基本结构,掌握程序中的头文件、实现文件和主文件之间的相互关系及各自的作用。
3、熟悉顺序表的基本操作方式,掌握顺序表相关操作的具体实现。
二、实验内容及要求对顺序存储的线性表进行一些基本操作。
主要包括:(1)插入:操作方式为在指定元素前插入、在指定元素之后插入、在指定位置完成插入。
(2)删除:操作方式可分为删除指定元素、删除指定位置的元素等,尝试实现逻辑删除操作。
(3)显示数据。
(4)查找:查询指定的元素(可根据某个数据成员完成查询操作)。
(5)定位操作:定位指定元素的序号。
(6)更新:修改指定元素的数据。
(7)数据文件的读写操作等。
其它操作可根据具体需要自行补充。
要求线性表采用类的定义,数据对象的类型自行定义。
三、系统分析(1)数据方面:能够实现多种数据类型顺序表的创建,并进行操作,不同的数据类型数据使用不同的文本文件保存。
(2)功能方面:能够实现线性表的一些基本操作,主要包括:1.计算表最大可以容纳表项个数以及当前表的当前长度。
2.能够进行添加操作,在已有的数据文件中进行数据的添加。
3.能够进行搜索操作,返回搜索项在表中表项序号4.能够进行定位操作,定位到表中合理位置。
5.能够进行取值操作,根据用户需求取出表中某项的值。
6.能够进行修改操作,在用户选择修改项后将重新输入内容修改到对应位置。
7.能够进行插入操作,在用户选择合理位置并输入插入内容后即可。
8.能够进行删除操作,用户根据选择表中项数删除对应数据。
9.能够进行判断表空或表满。
四、系统设计(1)设计的主要思路根据实验要求,首先将顺序表模板类完成,并将需要实现的功能代码完善,在写实现各个功能的菜单并将模板类实例化为简单数据类型最后进行调试,由于还需使得顺序表能够存储自定义的学生类类型数据,故根据要求写出Student类,并将之前所写得模板类用学生类数据类型实例化,再进行调试。
数据结构实验顺序表的基本操作
![数据结构实验顺序表的基本操作](https://img.taocdn.com/s3/m/969ef368bc64783e0912a21614791711cc79792f.png)
数据结构实验-顺序表的基本操作顺序表是一种线性数据结构,它的元素在内存中是连续存储的。
顺序表具有随机访问的特点,可以通过下标直接访问元素,因此在访问元素时具有较高的效率。
顺序表的基本操作包括插入、删除、查找等,下面将对这些基本操作进行详细介绍。
1. 初始化:初始化顺序表需要为其分配一定的内存空间,以存储元素。
可以使用静态分配或动态分配两种方式来初始化顺序表。
静态分配是在编译时为顺序表分配固定大小的内存空间,而动态分配是在运行时根据需要动态地为顺序表分配内存空间。
2. 插入操作:插入操作是将一个元素插入到顺序表的指定位置上。
在插入元素之前,需要判断顺序表是否已满,如果已满则需要进行扩容操作。
插入元素时,需要将插入位置以及其后的元素向后移动一位,为插入元素腾出位置。
插入操作的时间复杂度为O(n),其中n为顺序表的长度。
3. 删除操作:删除操作是将顺序表中的一个元素删除。
在删除元素之前,需要判断顺序表是否为空,如果为空则无法进行删除操作。
删除元素时,需要将删除位置后面的元素向前移动一位,覆盖删除位置上的元素。
删除操作的时间复杂度为O(n),其中n为顺序表的长度。
4. 查找操作:查找操作是根据给定的关键字,在顺序表中查找满足条件的元素。
可以使用顺序查找或二分查找两种方式进行查找。
顺序查找是从顺序表的第一个元素开始,逐个比较关键字,直到找到满足条件的元素或遍历完整个顺序表。
二分查找是在有序顺序表中进行查找,每次将待查找区间缩小一半,直到找到满足条件的元素或待查找区间为空。
查找操作的时间复杂度为O(n),其中n为顺序表的长度。
5. 修改操作:修改操作是将顺序表中的一个元素修改为新的值。
修改操作需要先进行查找操作,找到待修改的元素,然后将其值修改为新的值。
修改操作的时间复杂度为O(n),其中n为顺序表的长度。
6. 遍历操作:遍历操作是依次访问顺序表中的每个元素。
可以使用for循环或while循环进行遍历,从第一个元素开始,依次访问每个元素,直到遍历完整个顺序表。
数据结构实验报告顺序表1
![数据结构实验报告顺序表1](https://img.taocdn.com/s3/m/6dc34276ec630b1c59eef8c75fbfc77da26997d5.png)
数据结构实验报告顺序表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、对顺序表进行初始化,创建一个空的顺序表。
数据结构实验报告-实验一顺序表、单链表基本操作的实现
![数据结构实验报告-实验一顺序表、单链表基本操作的实现](https://img.taocdn.com/s3/m/88647a8d70fe910ef12d2af90242a8956becaa4d.png)
数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现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)掌握链表的概念,学会对链表进⾏操作。
数据结构-顺序表的基本操作的实现-课程设计-实验报告
![数据结构-顺序表的基本操作的实现-课程设计-实验报告](https://img.taocdn.com/s3/m/e395393ab6360b4c2e3f5727a5e9856a561226d7.png)
数据结构-顺序表的基本操作的实现-课程设计-实验报告顺序表的基本操作的实现一、实验目的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、认真阅读和掌握本实验的程序。
数据结构实验报告顺序表
![数据结构实验报告顺序表](https://img.taocdn.com/s3/m/0628e0c070fe910ef12d2af90242a8956becaad2.png)
数据结构实验报告顺序表数据结构实验报告:顺序表一、引言数据结构是计算机科学的重要基础,它研究数据的组织方式和操作方法。
顺序表是一种常见的数据结构,它以数组的形式存储数据元素,具有随机访问和插入删除方便的特点。
本实验旨在深入理解顺序表的实现原理和操作方法,并通过实验验证其性能。
二、实验目的1. 掌握顺序表的基本概念和实现原理;2. 熟悉顺序表的插入、删除、查找等操作;3. 分析顺序表的时间复杂度,并进行性能测试。
三、实验过程1. 顺序表的定义和初始化顺序表是一种线性表,它以一组连续的存储单元来存储数据元素。
在实验中,我们使用数组来实现顺序表。
首先,定义一个结构体来表示顺序表,包括数据元素和当前长度等信息。
然后,通过动态分配内存来初始化顺序表。
2. 插入元素顺序表的插入操作是将一个新元素插入到指定位置,同时移动后面的元素。
在实验中,我们可以通过循环将后面的元素依次向后移动,然后将新元素放入指定位置。
3. 删除元素顺序表的删除操作是将指定位置的元素删除,并将后面的元素依次向前移动。
在实验中,我们可以通过循环将后面的元素依次向前移动,然后将最后一个元素置为空。
4. 查找元素顺序表的查找操作是根据指定的值查找元素所在的位置。
在实验中,我们可以通过循环遍历顺序表,逐个比较元素的值,找到匹配的位置。
五、实验结果与分析在实验中,我们通过插入、删除、查找等操作对顺序表进行了测试,并记录了操作所需的时间。
通过分析实验结果,我们可以得出以下结论:1. 顺序表的插入操作的时间复杂度为O(n),其中n为元素的个数。
因为插入操作需要移动后面的元素,所以时间复杂度与元素个数成正比。
2. 顺序表的删除操作的时间复杂度也为O(n),与插入操作相同,需要移动后面的元素。
3. 顺序表的查找操作的时间复杂度为O(n),需要逐个比较元素的值。
六、结论通过本次实验,我们深入理解了顺序表的实现原理和操作方法。
顺序表以数组的形式存储数据,具有随机访问和插入删除方便的特点。
数据结构顺序表实验报告
![数据结构顺序表实验报告](https://img.taocdn.com/s3/m/925c7de8370cba1aa8114431b90d6c85ec3a883b.png)
数据结构顺序表实验报告数据结构顺序表实验报告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.法律名词及注释:●顺序表:一种基本的线性数据结构,数据元素按照其逻辑位置依次存储在一片连续的存储空间中。
●初始化:为数据结构分配内存空间并进行初始化,使其具备基本的数据存储能力。
●插入元素:将一个新元素插入到已有元素的合适位置,使得数据结构保持有序或符合特定要求。
数据结构实验一顺序表实验报告
![数据结构实验一顺序表实验报告](https://img.taocdn.com/s3/m/8d5c09703868011ca300a6c30c2259010202f3fe.png)
数据结构实验一顺序表实验报告数据结构实验一顺序表实验报告一、实验目的顺序表是一种基本的数据结构,本次实验的目的是通过实现顺序表的基本操作,加深对顺序表的理解,并掌握顺序表的插入、删除、查找等操作的实现方法。
二、实验内容1. 实现顺序表的创建和初始化操作。
2. 实现顺序表的插入操作。
3. 实现顺序表的删除操作。
4. 实现顺序表的查找操作。
5. 实现顺序表的输出操作。
三、实验步骤1. 创建顺序表的数据结构,包括数据存储数组和记录当前元素个数的变量。
2. 初始化顺序表,将当前元素个数置为0。
3. 实现顺序表的插入操作:- 判断顺序表是否已满,若已满则输出错误信息。
- 将插入位置之后的元素依次后移一位。
- 将要插入的元素放入插入位置。
- 当前元素个数加一。
4. 实现顺序表的删除操作:- 判断顺序表是否为空,若为空则输出错误信息。
- 判断要删除的位置是否合法,若不合法则输出错误信息。
- 将删除位置之后的元素依次前移一位。
- 当前元素个数减一。
5. 实现顺序表的查找操作:- 遍历顺序表,逐个比较元素值与目标值是否相等。
- 若找到目标值,则返回该元素的位置。
- 若遍历完整个顺序表仍未找到目标值,则返回错误信息。
6. 实现顺序表的输出操作:- 遍历顺序表,逐个输出元素值。
四、实验结果经过实验,顺序表的各项操作均能正确实现。
在插入操作中,可以正确将元素插入到指定位置,并将插入位置之后的元素依次后移。
在删除操作中,可以正确删除指定位置的元素,并将删除位置之后的元素依次前移。
在查找操作中,可以正确返回目标值的位置。
在输出操作中,可以正确输出顺序表中的所有元素。
五、实验总结通过本次实验,我深入了解了顺序表的原理和基本操作,并通过实际编程实现了顺序表的各项功能。
在实验过程中,我遇到了一些问题,如如何判断顺序表是否已满或为空,如何处理插入和删除位置的合法性等。
通过查阅资料和与同学讨论,我解决了这些问题,并对顺序表的操作有了更深入的理解。
数据结构实验报告顺序表
![数据结构实验报告顺序表](https://img.taocdn.com/s3/m/ea6ac5bb0342a8956bec0975f46527d3240ca6db.png)
数据结构实验报告顺序表数据结构实验报告:顺序表摘要:顺序表是一种基本的数据结构,它通过一组连续的存储单元来存储线性表中的数据元素。
在本次实验中,我们将通过实验来探索顺序表的基本操作和特性,包括插入、删除、查找等操作,以及顺序表的优缺点和应用场景。
一、实验目的1. 理解顺序表的概念和特点;2. 掌握顺序表的基本操作;3. 了解顺序表的优缺点及应用场景。
二、实验内容1. 实现顺序表的初始化操作;2. 实现顺序表的插入操作;3. 实现顺序表的删除操作;4. 实现顺序表的查找操作;5. 对比顺序表和链表的优缺点;6. 分析顺序表的应用场景。
三、实验步骤与结果1. 顺序表的初始化操作在实验中,我们首先定义了顺序表的结构体,并实现了初始化操作,即分配一定大小的存储空间,并将表的长度设为0,表示表中暂时没有元素。
2. 顺序表的插入操作接下来,我们实现了顺序表的插入操作。
通过将插入位置后的元素依次向后移动一位,然后将新元素插入到指定位置,来实现插入操作。
我们测试了在表中插入新元素的情况,并验证了插入操作的正确性。
3. 顺序表的删除操作然后,我们实现了顺序表的删除操作。
通过将删除位置后的元素依次向前移动一位,来实现删除操作。
我们测试了在表中删除元素的情况,并验证了删除操作的正确性。
4. 顺序表的查找操作最后,我们实现了顺序表的查找操作。
通过遍历表中的元素,来查找指定元素的位置。
我们测试了在表中查找元素的情况,并验证了查找操作的正确性。
四、实验总结通过本次实验,我们对顺序表的基本操作有了更深入的了解。
顺序表的插入、删除、查找等操作都是基于数组的操作,因此在插入和删除元素时,需要移动大量的元素,效率较低。
但是顺序表的优点是可以随机访问,查找效率较高。
在实际应用中,顺序表适合于元素数量不变或变化不大的情况,且需要频繁查找元素的场景。
综上所述,顺序表是一种基本的数据结构,我们通过本次实验对其有了更深入的了解,掌握了顺序表的基本操作,并了解了其优缺点及应用场景。
数据结构实验报告 顺序表基本操作
![数据结构实验报告 顺序表基本操作](https://img.taocdn.com/s3/m/00a8f3573c1ec5da50e270a1.png)
四、实验步骤
一 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))//撤销线性表
数据结构顺序表实验报告
![数据结构顺序表实验报告](https://img.taocdn.com/s3/m/cef0d6eac9d376eeaeaad1f34693daef5ef7138d.png)
《数据结构》课程实验报告实验名称顺序表实验序号 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");}注:空间不够,可以增加页码。
数据结构顺序表实验报告
![数据结构顺序表实验报告](https://img.taocdn.com/s3/m/95fde9d65122aaea998fcc22bcd126fff7055d06.png)
}SeqList;
3.模块划分
(1)创建顺序表输入函数:void Input(SeqList *L,int n);
(2)创建顺序表输出函数:void Output(SeqList*L);
(3)创建顺序表的内容查找函数:int Locate(SeqList L,ElemType e);
{printf("插入位置不合法\n”);
return(ERROR);
}
if(L-〉last>= MAXSIZE—1)
{printf(”表已满无法插入");
return(ERROR);
}
for(k=L-〉last;k>=i—1;k--)//为插入元素而移动位置
L-〉elem[k+1]=L—>elem[k];
scanf(”%d”,&m);
DelList(la,m,&num);
printf(”删除成功,删除的元素为%d”,num);
printf(”\n”);
Output(la);
}
5。测试数据及结果
实验总结:
经过调试与测试,实验结果与测试预期一致.顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。
洛阳理工学院实验报告
系别
计算机
班级
学号
姓名
课程名称
数据结构
实验日期
10/23
实验名称
顺序表的基本操作
成绩
Байду номын сангаас实验目的:
熟悉掌握线性表顺序存储结构,掌握与应用顺序表的查找、插入、删除等基本操作算法,训练和提高结构化程序设计能力及程序调试能力.
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
附页(实验2-1代码):
头文件“DEFINE2-1.h”:
#define MaxSize 10
typedef struct
{
char data[MaxSize];
int length;
}SqList;
#include<stdio.h>
#include<stdlib.h>
#include"DEFINE2-1.h"
void InitList(SqList * &L) //初始化线性表
{
L = (SqList*)malloc(sizeof(SqList)); //分配存放线性表的空间L->length = 0; //置空线性表长度为0
}
bool ListInsert(SqList *&L, int i, char e) //插入数据元素
{
int j;
if (i<1 || i>L->length + 1)
return false; //参数错误是返回false I--; //将顺序表逻辑序号转换为物理序号for (j = L->length; j>i; j--) //将data[i]及后面元素后移一个位置L->data[j] = L->data[j - 1];
L->data[i] = e; //插入元素e
L->length++; //顺序表长度+1
return true; //成功插入返回true
}
void DispList(SqList *L) //输出线性表L
{
int i;
for (i = 0; i<L->length; i++) //扫描顺序表输出各元素值printf("%3c", L->data[i]);
printf("\n\n");
}
int ListLength(SqList *L) //求线性表L的长度
{
return (L->length);
}
bool ListEmpty(SqList*L) //判断线性表是否为空表
{
return(L->length == 0); //若L为空,则返回true,否则返回false
}
bool GetElem(SqList *L, int i, char &e) //求顺序表L中某个数据元素值{
if (i<1 || i>L->length)
return false; //参数错误时返回false
e = L->data[i - 1]; //取元素值
return true; //成功找到元素时返回true
}
int LocateElem(SqList *L, char e) //按元素值查找
{
int i = 0;
while (i<L->length&&L->data[i] != e)
i++; //查找元素e
if (i >= L->length)
return 0; //未找到时返回0
else
return i + 1; //找到时返回其逻辑序号
}
bool ListDelete(SqList *&L, int i, char &e) //删除数据元素
{
int j;
if (i<1 || i>L->length)
return false; //参数错误时返回false i--; //将顺序表逻辑序号转化为物理序号
e = L->data[i];
for (j = i; j<L->length - 1; j++)
L->data[j] = L->data[j + 1]; //将data[i]之后的元素迁移一个位置L->length--; //顺序表的长度-1
return true; //成功删除返回true
}
void DestroyList(SqList * &L) //销毁线性表
{
free(L);
} //释放线性表L所占空间
int main() //主函数
{
SqList *L;
char e;
int i;
InitList(L);
printf("\n创建一个空的线性表\n使用尾插法插入a,b,c,d,e \n");
printf(" 输出顺序表L: \n");
ListInsert(L, 1, 'a');
ListInsert(L, 2, 'b');
ListInsert(L, 3, 'c');
ListInsert(L, 4, 'd');
ListInsert(L, 5, 'e');
DispList(L);
ListLength(L);
printf("顺序表的长度为:%d\n\n", L->length);
if (ListEmpty(L) == 1)
printf("顺序表为空!\n\n");
else
printf("顺序表不为空!\n\n");
GetElem(L, 3, e);
printf("顺序表的第三个元素为:%3c\n\n", e);
i = LocateElem(L, 'a');
printf("顺序表中a的位置是:%3d\n\n", i);
ListInsert(L, 4, 'f');
printf("在第四个元素位置上插入元素'f' \n");
printf(" 插入后顺序表L为:\n");
DispList(L);
printf("删除L中第三个元素\n");
ListDelete(L, 3, e);
printf(" 删除后顺序表L为:\n");
DispList(L);
printf("顺序表L已释放\n");
DestroyList(L);
printf("\n");
return 0;
}
实验结果:。