数据结构实验C语言实现线性表

数据结构经典题目及c语言代码一、线性表1. 顺序表顺序表是一种利用连续存储空间存储元素的线性表。

以下是一个顺序表的经典题目及C语言代码实现：```c#define MaxSize 50typedef struct {int data[MaxSize]; // 存储元素的数组int length; // 顺序表的当前长度} SeqList;// 初始化顺序表void initList(SeqList *L) {L->length = 0;}// 插入元素到指定位置void insert(SeqList *L, int pos, int elem) {if (pos < 1 || pos > L->length + 1) {printf("插入位置无效\n");return;}if (L->length == MaxSize) {printf("顺序表已满，无法插入\n"); return;}for (int i = L->length; i >= pos; i--) { L->data[i] = L->data[i - 1];}L->data[pos - 1] = elem;L->length++;}// 删除指定位置的元素void delete(SeqList *L, int pos) {if (pos < 1 || pos > L->length) {printf("删除位置无效\n");return;}for (int i = pos - 1; i < L->length - 1; i++) {L->data[i] = L->data[i + 1];}L->length--;}// 获取指定位置的元素值int getElement(SeqList *L, int pos) {if (pos < 1 || pos > L->length) {printf("位置无效\n");return -1;}return L->data[pos - 1];}```2. 链表链表是一种利用非连续存储空间存储元素的线性表。

实验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、熟练掌握线性表的基本操作在两种存储结构上的实现，其中以熟悉各种链表的操作为重点。

2、巩固高级语言程序设计方法与技术，会用线性链表解决简单的实际问题。

二、实验内容√ 1、单链表的表示与操作实现 ( * )2、约瑟夫环问题3、Dr.Kong的艺术品三、实验要求1、按照数据结构实验任务书，提前做好实验预习与准备工作。

2、加“*”题目必做，其他题目任选；多选者并且保质保量完成适当加分。

3、严格按照数据结构实验报告模板和规范，及时完成实验报告。

四、实验步骤（说明：依据实验内容分别说明实验程序中用到的数据类型的定义、主程序的流程以及每个操作（成员函数）的伪码算法、函数实现、程序编码、调试与分析、总结、附流程图与主要代码）㈠、数据结构与核心算法的设计描述（程序中每个模块或函数应加注释，说明函数功能、入口及出口参数）1、单链表的结点类型定义/* 定义DataType为int类型 */typedef int DataType;/* 单链表的结点类型 */typedef struct LNode{ DataType data;struct LNode *next;}LNode,*LinkedList;2、初始化单链表LinkedList LinkedListInit( ){ // 每个模块或函数应加注释，说明函数功能、入口及出口参数 }3、清空单链表void LinkedListClear(LinkedList L){// 每个模块或函数应加注释，说明函数功能、入口及出口参数}4、检查单链表是否为空int LinkedListEmpty(LinkedList L){ …. }5、遍历单链表void LinkedListTraverse(LinkedList L){….}6、求单链表的长度int LinkedListLength(LinkedList L){ …. }7、从单链表表中查找元素LinkedList LinkedListGet(LinkedList L,int i){ //L是带头结点的链表的头指针，返回第 i 个元素 }8、从单链表表中查找与给定元素值相同的元素在链表中的位置LinkedList LinkedListLocate(LinkedList L, DataType x){ …… }9、向单链表中插入元素void LinkedListInsert(LinkedList L,int i,DataType x) { // L 为带头结点的单链表的头指针，本算法// 在链表中第i 个结点之前插入新的元素 x}10、从单链表中删除元素void LinkedListDel(LinkedList L,DataType x){ // 删除以 L 为头指针的单链表中第 i 个结点 }11、用尾插法建立单链表LinkedList LinkedListCreat( ){ …… }㈡、函数调用及主函数设计（可用函数的调用关系图说明）㈢程序调试及运行结果分析㈣实验总结五、主要算法流程图及程序清单1、主要算法流程图：2、程序清单（程序过长，可附主要部分）说明：以后每次实验报告均按此格式书写。

数据结构线性表试验报告（最终定稿）第一篇：数据结构线性表试验报告线性表上机实习1、实验目的（1）熟悉将算法转换为程序代码的过程。

（2）了解顺序表的逻辑结构特性，熟练掌握顺序表存储结构的C 语言描述方法。

（3）熟练掌握顺序表的基本运算：查找、插入、删除等，掌握顺序表的随机存取特性。

（4）了解线性表的链式存储结构，熟练掌握线性表的链式存储结构的C语言描述方法。

（5）熟练掌握线性链表（单链表）的基本运算：查找、插入、删除等，能在实际应用中灵活选择适当的链表结构。

2、实验要求（1）熟悉顺序表的插入、删除和查找。

（2）熟悉单链表的插入、删除和查找。

3、实验内容: ① 顺序表（1）抽象数据类型定义typedef struct {TypeData data[maxsize];//容量为maxsize的静态顺手表int n;//顺序表中的实际元素个数}SeqList;//静态顺序表的定义在本次实验中，首先建立一个空的静态顺序表，然后键盘输入数据存入表中，然后进入菜单选择界面，通过不同的数字输入，实现对顺序表，删除，插入，查找，显示等操作。

（2）存储结构定义及算法思想在顺序表结构体的定义中，typedef int TypeData 为整型，存储结构如下：for(n=0;ncout<<“请输入线性表数据”<cin>>L.data[n];//顺序将数据存入顺序表}//其他存储与此类似，都是直接赋值与数组的某一位插入版块子函数：void insert(SeqList &L)//插入数据 {int a,b,c,k;cout<<“请输入插入的数及其插入的位置”<cin>>a>>b;if(b<=0||b>(L.n+1)){cout<<“不能在该位置插入”<k=L.data[b-1];L.data[b-1]=a;c=L.n;L.n=L.n+1;while(c>b){L.data[c]=L.data[c-1];c--;//通过循环，实现插入位置后的数据挨个往后移动一位}L.data[b]=k;} 顺序表的插入与删除操作类似，在插入与删除后，都要循环调整后面数组的每一位元素，同时记录数据元素的长度的标示符也要跟着改变。

#include 〈stdio.h>＃include <malloc。

h>＃include 〈stdlib.h>/＊数据结构C语言版线性表的单链表存储结构表示和实现P28—31编译环境：Dev-C++ 4。

9。

9。

2日期：2011年2月10日＊/typedef int ElemType;// 线性表的单链表存储结构typedef struct LNode{ElemType data; //数据域struct LNode *next；//指针域}LNode, ＊LinkList；// typedef struct LNode *LinkList；// 另一种定义LinkList的方法// 构造一个空的线性表Lint InitList（LinkList ＊L){/＊产生头结点L，并使L指向此头结点,头节点的数据域为空，不放数据的。

void ＊malloc(size_t)这里对返回值进行强制类型转换了,返回值是指向空类型的指针类型.＊/（＊L）= (LinkList）malloc（sizeof（struct LNode) ）;if( ！(＊L）)exit（0）；// 存储分配失败(＊L)-〉next = NULL；// 指针域为空return 1；}// 销毁线性表L,将包括头结点在内的所有元素释放其存储空间。

int DestroyList（LinkList ＊L）｛LinkList q;// 由于单链表的每一个元素是单独分配的，所以要一个一个的进行释放while（＊L )｛q = (*L)—〉next;free（＊L ）；//释放*L = q;}return 1；｝/*将L重置为空表,即将链表中除头结点外的所有元素释放其存储空间，但是将头结点指针域置空，这和销毁有区别哦。

不改变L，所以不需要用指针。

*/int ClearList( LinkList L )｛LinkList p，q；p = L—〉next；// p指向第一个结点while( p ) // 没到表尾则继续循环｛q = p—>next;free( p )；//释放空间p = q；}L—>next = NULL; // 头结点指针域为空,链表成了一个空表return 1;}// 若L为空表（根据头结点L—〉next来判断，为空则是空表)，则返回1，// 否则返回0.int ListEmpty(LinkList L）{if（L—>next ) // 非空return 0;elsereturn 1；｝// 返回L中数据元素个数。

数据结构实验报告线性表数据结构实验报告：线性表引言：数据结构是计算机科学中的重要概念，它涉及到如何组织和存储数据，以及如何有效地操作和管理这些数据。

线性表是数据结构中最基本的一种，它是一种有序的数据元素集合，其中的元素之间存在着一对一的关系。

一、线性表的定义和特点线性表是由n个数据元素组成的有限序列，其中n为表的长度。

这些数据元素可以是相同类型的，也可以是不同类型的。

线性表中的数据元素按照一定的顺序排列，并且每个数据元素都有唯一的前驱和后继。

线性表的特点有以下几个方面：1. 数据元素之间是一对一的关系，即每个数据元素只有一个直接前驱和一个直接后继。

2. 线性表中的元素是有序的，每个元素都有一个确定的位置。

3. 线性表的长度是有限的，它的长度可以是0，也可以是任意正整数。

二、线性表的实现方式线性表可以使用不同的数据结构来实现，常见的实现方式有数组和链表。

1. 数组实现线性表：数组是一种连续存储的数据结构，它可以用来存储线性表中的元素。

数组的优点是可以快速访问任意位置的元素，但是插入和删除操作需要移动其他元素，效率较低。

2. 链表实现线性表：链表是一种非连续存储的数据结构，它通过指针将线性表中的元素链接起来。

链表的优点是插入和删除操作简单高效，但是访问任意位置的元素需要遍历链表，效率较低。

三、线性表的基本操作线性表的基本操作包括插入、删除、查找和修改等。

1. 插入操作：插入操作用于向线性表中插入一个新元素。

具体步骤是先将插入位置后面的元素依次后移，然后将新元素插入到指定位置。

2. 删除操作：删除操作用于从线性表中删除一个元素。

具体步骤是先将删除位置后面的元素依次前移，然后将最后一个元素删除。

3. 查找操作：查找操作用于在线性表中查找指定元素。

具体步骤是从线性表的第一个元素开始逐个比较，直到找到匹配的元素或者到达线性表的末尾。

4. 修改操作：修改操作用于修改线性表中的某个元素的值。

具体步骤是先查找到要修改的元素，然后将其值更新为新值。

严蔚敏数据结构C语⾔版——线性表（初始化、插⼊、删除、遍历）1 #include<stdio.h>2 #include<malloc.h>3 #include<stdlib.h>45#define TRUE 16#define FALSE 07#define OK 18#define ERROR 09#define INFEASIBLE -110#define OVERFLOW -21112#define LIST_INIT_SIZE 100 //存储空间初始分配量13#define LISTINCREMENT 10 //存储空间不够时，动态增加的分配量1415 typedef int ElemType;16 typedef int Status;1718 typedef struct {19 ElemType *elem; //存储空间基地址20int length; //当前长度21int listsize; //当前分配的存储容量，即有多少个ElemType空间22 }SqList;2324 Status InitList_Sq(SqList *L); //初始化线性表25 Status ListInsert_Sq(SqList *L,int i,ElemType e); //插⼊操作26 Status ListDelete_Sq(SqList *L,int i,ElemType *e); //删除操作27void TraverseList_Sq(SqList L); //遍历线性表2829int main()30 {31 SqList L;32 ElemType e;33int i,n = 10;34 InitList_Sq(&L);35for(i= 1; i <= n; i++)36 {37 ListInsert_Sq(&L,i,i); //插⼊10个元素,1,2,3,...,1038 }39 TraverseList_Sq(L);4041 printf("输⼊要删除的位置：");42 scanf("%d",&i);43 ListDelete_Sq(&L,i,&e);44 TraverseList_Sq(L);45 printf("e=%d\n",e);4647 printf("输⼊要插⼊的位置和数值：");48 scanf("%d %d",&i,&e);49 ListInsert_Sq(&L,i,e);50 TraverseList_Sq(L);51return0;52 }5354 Status InitList_Sq(SqList *L)55 {56//分配存储空间100*sizeof(ElmeType),并把存储空间基地址返回给L->elem57 L->elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));58if(!L->elem) exit(OVERFLOW);59 L->length = 0;60//初始化存储空间容量为10061 L->listsize = LIST_INIT_SIZE;62return OK;63 }6465//在第i个位置前，插⼊新元素，i是从1开始变化的66 Status ListInsert_Sq(SqList *L,int i,ElemType e)67 {68//插⼊位置不合理69if(i < 1 || i> L->length+1) return ERROR;70//存储空间不⾜，增加分配71if(L->length >= L->listsize )72 {73 ElemType *newbase = (ElemType *) realloc (L->elem,74 (L->listsize + LISTINCREMENT)*sizeof(ElemType)); 75if(!newbase) exit(OVERFLOW);76 L->elem = newbase;77 L->listsize += LISTINCREMENT;78 }79 ElemType *q = &(L->elem[i-1]);80 ElemType *p;81for(p = &(L->elem[L->length-1]); p >= q; --p)82 {83 *(p+1)=*p;84 }85 *q = e;86 (L->length)++;87return OK;88 }8990 Status ListDelete_Sq(SqList *L,int i,ElemType *e)91 {92//删除位置不合理93if(i < 1 || i > L->length) return ERROR;94 ElemType *p = &(L->elem[i-1]);95 *e = *p;96 ElemType *q = &(L->elem[L->length-1]);97for(++p; p <= q; p++)98 {99 *(p-1) = *p;100 }101 (L->length)--;102return OK;103 }104105void TraverseList_Sq(SqList L)106 {107int i;108 printf("线性表元素为：");109for(i = 0; i <= L.length-1; i++)110 {111 printf("%d,",L.elem[i]);112 }113 printf("\n");114 }。

数据结构C语言版实验报告《数据结构 C 语言版实验报告》一、实验目的本次实验旨在通过使用 C 语言实现常见的数据结构，加深对数据结构基本概念和操作的理解，提高编程能力和问题解决能力。

二、实验环境操作系统：Windows 10编程环境：Visual Studio 2019三、实验内容1、线性表顺序表的实现链表的实现（包括单向链表、双向链表）2、栈和队列栈的实现（顺序栈、链栈）队列的实现（顺序队列、循环队列、链队列）3、数组和字符串数组的基本操作字符串的操作（字符串的存储、字符串的比较、字符串的连接等）4、树和二叉树二叉树的遍历（前序、中序、后序）二叉树的创建和基本操作5、图图的存储（邻接矩阵、邻接表）图的遍历（深度优先遍历、广度优先遍历）四、实验步骤1、线性表顺序表的实现定义顺序表的数据结构，包括数组和表的长度等。

实现顺序表的初始化、插入、删除、查找等操作。

编写测试程序，对顺序表的各种操作进行测试。

链表的实现定义单向链表和双向链表的数据结构，包括节点结构体。

实现链表的创建、插入、删除、查找等操作。

编写测试程序，验证链表操作的正确性。

栈的实现定义顺序栈和链栈的数据结构。

实现栈的入栈、出栈、栈顶元素获取等操作。

进行栈的操作测试。

队列的实现定义顺序队列、循环队列和链队列的数据结构。

实现队列的入队、出队、队头队尾元素获取等操作。

对队列的操作进行测试。

3、数组和字符串数组的操作实现数组的初始化、元素访问、数组元素的修改等。

测试数组的基本操作。

字符串的操作定义字符串的存储方式。

实现字符串的比较、连接、复制等操作。

编写测试用例，验证字符串操作的准确性。

二叉树的遍历采用递归方式实现二叉树的前序、中序、后序遍历。

输出遍历结果进行验证。

二叉树的创建和基本操作构建二叉树的数据结构。

实现二叉树的节点插入、删除等操作。

5、图图的存储分别用邻接矩阵和邻接表来存储图。

实现图的初始化操作。

图的遍历用深度优先遍历和广度优先遍历算法对图进行遍历。

数据结构实验报告（⼀）线性表的应⽤实验说明数据结构实验⼀ 线性表的实验——线性表的应⽤⼀、实验⽬的通过本实验使学⽣了解线性表的⼀种简单应⽤，熟悉线性表顺序存储与链式存储的特性，特别训练学⽣编程灵活控制链表的能⼒，为今后编程控制更为复杂的数据结构奠定基础。

⼆、实验内容1.⽤顺序表和链表分别分别编程实现教材中例⼦2-1与2-2。

要求：（1）只能⽤C语⾔编程实现；（2）完全保持书中算法2.1与算法2.2形式，不允许有任何变化，除⾮语法上不允许;所调⽤各函数参照书中19页的功能描述，其中函数名、参数个数及性质、函数功能必须与书中完全⼀致，不能有变化。

2.利⽤线性表表⽰⼀元多项式完成多项式的加、减、乘、求导、求值运算。

要求：（1）输⼊的⼀元多项式可以采⽤只输⼊各项的系数与指数这种简化的⽅式。

如对于多项式2x2+6x5，输⼊可为： 2,2 6,5 这样的简单形式。

（2）遇到有消项时应当处理，如2x2+6x5与3x2-6x5进⾏相加时，结果为5*x^2。

（3）当给定x的值时，能计算表达式相加或相减的结果。

（4）操作的结果放⼊⼀个新线性表中，原来的两个表达式存储表⽰不变，也可以不是产⽣新的线性表，⽽是将两上线性表合并为⼀个。

（5）要求程序功能模块划分合理（每个函数功能单⼀、可重⽤性好），使⽤空间尽可能少，算法尽可能⾼效。

实验报告1.实现功能描述使⽤线性表表⽰⼀元多项式完成多项式的加、减，乘，求导、求值运算。

2.⽅案⽐较与选择（1）因为使⽤的是线性表，所以主要⽅案有数组法和链表法。

（2）从时间复杂度来说，使⽤数组法更优；从空间复杂度来说，链表法更优。

因为数组法是指定好空间的，若式⼦⼤⼩超出设置⼤⼩，那程序必然出错；若式⼦⼤⼩⼩于设置⼤⼩，那就意味着有多余的空间被浪费了。

综合来讲，若计算式⼦较为庞⼤，使⽤链表法更佳；相反，若计算式⼦较⼩，数组法更佳。

3.设计算法描述（1）单个项式的数据存储使⽤了结构体，数组法是在⼀个结构体中定义两个⼀维数组；链表法是通过⼀个结构体作为⼀个节点，通过next指针连接起来。

实验一线性表一、实验目的1.掌握实现线性表的基本操作方法；2.掌握线性表的基本操作:建表、插入、删除、输出等运算在顺序存储结构和链式存储结构上的实现；3.通过本次实习加深对高级语言C语言的使用(特别是函数参数、指针类型、链表的使用)。

熟悉线性表的基本运算在两种存储结构(顺序结构和链式结构)上的实现。

二、实验环境装有VisualC++6.0的普通PC机三、源程序#include"string.h"#include "stdio.h"#include "stdlib.h"#include "conio.h"#define MaxLine 100 /*顺序存储的最大个数*/ typedef int ElemType;typedef struct SqList{ElemType data[MaxLine];/*存放顺序表的数组*/ int length;/*顺序表的长度*/} L;/*初始化顺序表*/void InitList(SqList&L){L.length = 0;//L.length =0;}/*得到顺序表的长度*/int GetLength(SqList &L){return L.length;}/*得到顺序表中的第i个元素*/ElemType GetElem(SqList &L,int i){if(i < 1 || i > L.length) 开始{printf("error");exit(1);}return L.data[i-1];}void ListInsert(SqList &L,int i,ElemType x)/*添加线性表中第i个位置上的元素,i从1开始*/{int j;if(i < 1 || i > L.length+1) /*检查添加位置的合法性*/{printf("error");exit(1);}if(L.length >= MaxLine){printf("overflow!");exit(1);}j = L.length;while(j>=i)/*此处语句相对参考语句有较大改变*/{L.data[j]=L.data[j-1];j--;}L.data[i-1] = x;L.length++;}void ListDelete(SqList &L,int i) /* 删除线性表中第i个位置上的元素*/ {int j;if(i<1 || i>L.length) /* 检查空表及删除位置的合法性*/ {printf ("不存在第i个元素");exit(0);}for(j=i;j<=L.length-1;j++)L.data[j-1]=L.data[j]; /* 向前移动元素*/L.length--;}int main(){FILE *fp;struct SqList A;InitList(A);/*初始化顺序表*/int Judge2=0;printf(" ***线性表操作实验***\n \n\n请输入0对长度为8的线性表输入数据或者其他任意数进行其他操作^_^\n");scanf("%d",&Judge2);if(Judge2==0){int t = 1,d=1;for(t=1;t<=8;t++)/*此处为顺序表首先输入8个元素*/{printf("请输入第%d个线性表元素:",t);scanf("%d",&d);ListInsert(A,t,d);}}int Judge=0;printf("输入0结束程序或者输入其他任意数继续对该表进行操作^_^\n");scanf("%d",&Judge);while(Judge)/*判断是结束程序还是要继续操作该顺序表*/{int a=0;int pos=0;int c=0;int Judge1=0;int P;/*给出顺序表操作选择菜单分别为输入，删除，显示长度，打印顺序表*/printf(" ***************\n *输入1进行插入*\n");printf(" *输入2进行删除*\n");printf(" *输入3显示长度*\n");printf(" *输入4打印该表*\n");printf(" *输入5保存数据*\n");printf(" *输入6进行排序*\n");printf(" *输入7查找数据*\n ***************\n");printf("请选择:");/*选择要进行的操作*/scanf("%d",&P);if(P==0)return 0;else if(P>=1&&P<=7)switch(P){case 1:printf("请输入想进行插入操作的位置:");/*选择待插入位置*/scanf("%d",&pos);int PP;printf("请输入待插入的元素:\n");/*输入要插入的元素*/scanf("%d",&PP);ListInsert(A,pos,PP);c=GetLength(A);printf("该线性表的长度为：%d!\n",c);/*此处选择是重新选择操作还是按顺序进行下一项操作*/printf("请输入0结束操作或者其他任意数继续其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;case 2:printf("输入要删除元素的位置:");/*选择要删除的元素位置*/scanf("%d",&a);ListDelete(A,a);c=GetLength(A);printf("该线性表的长度为：%d!\n",c);/*此处选择是重新选择操作还是按顺序进行下一项操作*/printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;case 3:c=GetLength(A);printf("该线性表的长度为：%d!\n",c);printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;case 4:{c=GetLength(A);int d=0;printf("%s"," 该线性表数据记录如下\n");printf("%s","*****************************************************\n");for(int aa=0;aa<c;aa++){printf(" ");printf("%d \t",A.data[aa]); d++;/*打印该线性表*/if( d%4 ==0) printf("\n");}printf("\n");printf("%s","*****************************************************\n");printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;}case 5:{fp=fopen("Test.txt","wt+");int i=0,j=0;fprintf(fp,"%s"," 文件Test数据记录\n");fprintf(fp,"%s","_________________________\n");for(i=0;i<GetLength(A);){fprintf(fp,"%d",A.data[i]);i++;fputc('\t',fp);j++;if(j%4==0) fputc(10,fp);} ;fprintf(fp,"%s","\n_________________________");fclose(fp);printf("相关数据已经存入文件Test.txt中^_^\n");printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;}case 6:{int i,j,temp;for(i=0;i<GetLength(A)-1;i++)for(j=i+1;j<GetLength(A);j++) /*注意循环的上下限*/{if(A.data[i]>A.data[j]){temp=A.data[i];A.data[i]=A.data[j];A.data[j]=temp;}}c=GetLength(A);int d=0;printf("%s","排序后该线性表数据记录如下\n");printf("%s","**************************\n");for(int aa=0;aa<c;aa++){printf("%d \t",A.data[aa]); d++;/*打印该线性表*/if( d%4 ==0) printf("\n");}printf("\n");printf("%s","**************************\n");printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;}case 7:{int value;printf("请输入待查找的数据：\n");scanf("%d",&value);for(int i=0;i<GetLength(A);){if(A.data[i] == value)printf("待查找的是表中第%d个数据%d^_^\n",i+1,value);else if(i>=(GetLength(A)-1)) printf("待查找的数据不存在+_+\n");i++;}printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;}}printf("请输入0 结束程序或者输入其他任意数继续进行操作^_^\n");scanf("%d",&Judge);}return 0;}四、实验数据记录1，生成长度为8的线性表2，选择插入数据3，删除数据4，打印表5，保存数据6，排序7，查找数据五、实验总结实验在编写源程序是由于参考给的参考程序较多，但是参考程序存在一定的问题且相当不完善，走了弯路。