数据结构线性表存储实验报告
数据结构线性表实验报告

实验报告实验一线性表实验目的:1. 理解线性表的逻辑结构特性;2. 熟练掌握线性表的顺序存储结构的描述方法,以及在该存储结构下的基本操作;并能灵活运用;3. 熟练掌握线性表的链表存储结构的描述方法,以及在该存储结构下的基本操作;并能灵活运用;4•掌握双向链表和循环链表的的描述方法,以及在该存储结构下的基本操作。
实验原理:线性表顺序存储结构下的基本算法;线性表链式存储结构下的基本算法;实验内容:2 - 21设计单循环链表,要求:(1 ) 单循环链表抽象数据类型包括初始化操作、求数据元素个数操作、插入操作、删除操作、取消数据元素操作和判非空操作。
(2 ) 设计一个测试主函数,实际运行验证所设计单循环链表的正确性。
2 — 22 .设计一个有序顺序表,要求:(1 ) 有序顺序表的操作集合有如下操作:初始化、求数据元素个数、插入、删除和取数据元素。
有序顺序表与顺序表的主要区别是:有序顺序表中的数据元素按数据元素值非递减有序。
(2 ) 设计一个测试主函数,实际运行验证所设计有序顺序表的正确性。
(3) 设计合并函数ListMerge ( L1,L2,L3 ),功能是把有序顺序表 L1和L2中的数据元素合并到L3,要求L3中的数据元素依然保持有序。
并设计一个主函数,验证该合并函数的正确性。
程序代码:2-21 (1)头文件 LinList.h 如下:typedef struct node{DataType data;struct node *next;}SLNode;/* ( 1 )初始化 ListInitiate(SLNode * * head)*/void ListInitiate(SLNode * * head){ /* 如果有内存空间,申请头结点空间并使头指针 head 指向头结点 */if((*head=(SLNode *)malloc(sizeof(SLNode)))==NULL)exit(1);(*head)->next=NULL; /* 置结束标记 NULL*/}/*(2) 求当前数据元素个数 ListLength(SLNode * head)*/int ListLength(SLNode * head){SLNode *p=head;int size=0;while(p->next!=head){p=p->next;size++;}return size;}/*(3) 插入 ListInsert(SLNode * head , int i , DataType x)*//* 在带头结点的单链表的第 i(0<=i<=size) 个结点前 *//* 插入一个存放数据元素 x 的结点。
数据结构实验报告-线性表(顺序表实现)

实验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)熟悉将算法转换为程序代码的过程。
(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;} 顺序表的插入与删除操作类似,在插入与删除后,都要循环调整后面数组的每一位元素,同时记录数据元素的长度的标示符也要跟着改变。
《数据结构》线性结构实验报告

《数据结构》线性结构实验报告2、源程序:#include <stdio.h>#include<stdlib.h>#define MAXSIZE 1024typedef int elemtype;typedef struct SequenStack{elemtype data[MAXSIZE];int top;}SequenStack;SequenStack * Init_SequenStack(){SequenStack * S;S = (SequenStack *)malloc(sizeof(SequenStack));if (S == NULL)return S;S->top = -1;return S;}int SequenStack_Empty(SequenStack * S)//判栈空{if (S->top == -1){return 1;}{int a;printf("请以十进制输入一个数:\n");scanf_s("%d", &a);printf("转化为二进制为:");Conversion(a);printf("\n");}运行结果:3、源程序:#include<stdio.h>#include<stdlib.h>#include<string.h>typedef struct node{char data;struct node* next;}LinkStack;//初始化LinkStack* Init_LinkStack(){LinkStack* top;top = (LinkStack*)malloc(sizeof(LinkStack));top->next = NULL;return top;}//入栈void Push_LinkStack(LinkStack* top, char x){LinkStack* node;node = (LinkStack*)malloc(sizeof(LinkStack));node->data = x;node->next = top->next;top->next = node;}运行结果:4、源程序:#include <stdio.h>#include<stdlib.h>#include<string.h>#define MAXSIZE 20typedef int elemtype;typedef struct QueueNode{elemtype data;struct QueueNode* next;}LinkedQueueNode;typedef struct LQueue{LinkedQueueNode* front;LinkedQueueNode* rear;}LQueue, *LinkedQueue;typedef struct Person{char name[MAXSIZE];char sex;}Person;typedef char* ElemType;//链队初始化LinkedQueue Init_LinkedQueue(){LinkedQueue Q = (LinkedQueue)malloc(sizeof(LQueue));LinkedQueueNode * head = (LinkedQueueNode *)malloc(sizeof(LinkedQueueNode));if (head != NULL && Q != NULL){head->next = NULL;Q->front = head;Q->rear = head;printf("输入参与者的姓名,性别\n");for (i = 0; i < num; i++){printf("输入第%d个舞者的名字:\n", i + 1);scanf_s("%s", &dancer[i].name, 10);printf("输入第%d个人的性别(F/M):\n", i + 1);scanf_s("%s", &dancer[i].sex, 10);while (dancer[i].sex != 'F' && dancer[i].sex != 'M'){printf("输入错误,请重新输入第%d个人的性别(F/M):\n", i + 1);scanf_s("%s", &dancer[i].sex, 10);}}DancePartner(dancer, num);break;case 0:printf("感谢你的使用!\n");break;default:printf("无此选项!\n");break;}} while (n != 0);return 0;}运行结果:。
数据结构实验报告1线性表的顺序存储结构

数据结构实验报告1线性表的顺序存储结构数据结构实验报告1线性表的顺序存储结构第一章引言线性表是计算机中最常见的数据结构之一,它是一种有序的数据元素集合,其中的数据元素之间具有一对一的关系。
线性表的存储结构有多种方式,其中顺序存储结构是最简单的一种,它使用一段连续的存储单元来存储线性表中的元素。
第二章顺序存储结构的定义顺序存储结构是将线性表中的元素按照其逻辑顺序依次存储在一块连续的存储空间中。
顺序存储结构的特点是可以快速地访问任意位置的元素,但插入和删除操作需要移动大量的元素。
第三章顺序存储结构的实现1.存储空间的分配顺序存储结构通常使用数组来实现,数组的长度应该大于等于线性表的长度,以防止溢出。
存储空间的分配可以使用静态分配或动态分配两种方式来实现。
2.线性表的初始化初始化线性表时,需要设置线性表的长度和当前元素的个数。
3.线性表的增删改查操作●插入操作:________在指定位置插入一个元素时,需要将插入位置之后的元素依次后移,给待插入的元素腾出位置。
●删除操作:________删除指定位置的元素时,需要将删除位置之后的元素依次前移,覆盖删除位置上的元素。
●修改操作:________修改指定位置的元素时,直接对该位置上的元素进行修改即可。
●查找操作:________根据指定的元素值,查找其在顺序存储结构中的位置。
4.线性表的遍历操作遍历操作可以按照顺序访问线性表中的每个元素,可以使用循环结构实现遍历操作。
第四章顺序存储结构的优缺点分析1.优点:________可以快速地访问任意位置的元素,节省存储空间。
2.缺点:________插入和删除操作需要移动大量的元素,不适用于频繁插入和删除的场景。
第五章实验过程和结果分析在本次实验中,我们以顺序存储结构为基础,实现了线性表的增删改查操作,并进行了遍历操作。
通过实验,我们发现顺序存储结构在查询操作上有较好的性能,但在插入和删除操作上的性能较差。
第六章附件本文档涉及的附件详见附件文件。
数据结构实验报告线性表

数据结构实验报告线性表数据结构实验报告:线性表引言数据结构是计算机科学中非常重要的一个概念,它是用来组织和存储数据的一种方式。
线性表是数据结构中最基本的一种,它是由n个数据元素组成的有限序列。
在本次实验中,我们将对线性表进行深入研究,并进行实验验证。
实验目的1. 了解线性表的基本概念和特性2. 掌握线性表的顺序存储结构和链式存储结构3. 熟练掌握线性表的基本操作:插入、删除、查找等4. 通过实验验证线性表的操作和性能实验内容1. 学习线性表的基本概念和特性2. 熟悉线性表的顺序存储结构和链式存储结构3. 实现线性表的基本操作:插入、删除、查找等4. 对线性表的操作进行性能测试和分析实验步骤1. 学习线性表的基本概念和特性,包括线性表的定义、顺序存储结构和链式存储结构等2. 实现线性表的基本操作:插入、删除、查找等3. 设计实验用例,对线性表的操作进行性能测试4. 对实验结果进行分析和总结实验结果1. 实现了线性表的顺序存储结构和链式存储结构2. 实现了线性表的基本操作:插入、删除、查找等3. 对线性表的操作进行了性能测试,并得出了相应的性能数据4. 对实验结果进行了分析和总结,得出了相应的结论结论通过本次实验,我们深入了解了线性表的基本概念和特性,掌握了线性表的顺序存储结构和链式存储结构,熟练掌握了线性表的基本操作,并对线性表的性能进行了测试和分析。
这些都为我们进一步深入学习和应用数据结构打下了坚实的基础。
总结数据结构是计算机科学中非常重要的一部分,线性表作为数据结构中最基本的一种,对我们学习和应用数据结构具有重要的意义。
通过本次实验,我们对线性表有了更深入的了解,并且掌握了相关的操作和性能测试方法,这将为我们今后的学习和应用提供很大的帮助。
数据结构实验报告-3-线性表的顺序存储-1

//析构函数为空
int Length();
//求线性表的长度
datatype Get(int i);
//按位查找,取线性表的第 i 个元素
int Locate(datatype item); //查找元素 item
void Insert(int i, datatype item); //在第 i 个位置插入元素 item
cout<<"溢出"<<endl; } if (i<1 || i>length+1) {
cout<<"i 不合法!"<<endl; } for (j=length; j>=i; j--)
data[j]=data[j-1]; data[i-1]=item; length++; } //(5)删除线性表中第 i 个元素算法 /* *输 入:要删除元素位置 i *前置条件:顺序表存在,i 要合法 *功 能:删除顺序表中位置为 i 的元素 *输 出:无 *后置条件: 顺序表册除了一个元素,表长减 1 */ //实现代码: template <class datatype> datatype SeqList<datatype>::Delete(int i) { int item,j; if (length==0) {
cout<<"表为空,无法删除元素!"<<endl; } if (i<1 || i>length)
{ cout<<"i 不合法!"<<endl;
} item=data[i-1];//获得要删除的元素值 for (j=i; j<length; j++)
数据结构实验报告线性表

数据结构实验报告线性表数据结构实验报告:线性表引言:数据结构是计算机科学中的重要概念,它涉及到如何组织和存储数据,以及如何有效地操作和管理这些数据。
线性表是数据结构中最基本的一种,它是一种有序的数据元素集合,其中的元素之间存在着一对一的关系。
一、线性表的定义和特点线性表是由n个数据元素组成的有限序列,其中n为表的长度。
这些数据元素可以是相同类型的,也可以是不同类型的。
线性表中的数据元素按照一定的顺序排列,并且每个数据元素都有唯一的前驱和后继。
线性表的特点有以下几个方面:1. 数据元素之间是一对一的关系,即每个数据元素只有一个直接前驱和一个直接后继。
2. 线性表中的元素是有序的,每个元素都有一个确定的位置。
3. 线性表的长度是有限的,它的长度可以是0,也可以是任意正整数。
二、线性表的实现方式线性表可以使用不同的数据结构来实现,常见的实现方式有数组和链表。
1. 数组实现线性表:数组是一种连续存储的数据结构,它可以用来存储线性表中的元素。
数组的优点是可以快速访问任意位置的元素,但是插入和删除操作需要移动其他元素,效率较低。
2. 链表实现线性表:链表是一种非连续存储的数据结构,它通过指针将线性表中的元素链接起来。
链表的优点是插入和删除操作简单高效,但是访问任意位置的元素需要遍历链表,效率较低。
三、线性表的基本操作线性表的基本操作包括插入、删除、查找和修改等。
1. 插入操作:插入操作用于向线性表中插入一个新元素。
具体步骤是先将插入位置后面的元素依次后移,然后将新元素插入到指定位置。
2. 删除操作:删除操作用于从线性表中删除一个元素。
具体步骤是先将删除位置后面的元素依次前移,然后将最后一个元素删除。
3. 查找操作:查找操作用于在线性表中查找指定元素。
具体步骤是从线性表的第一个元素开始逐个比较,直到找到匹配的元素或者到达线性表的末尾。
4. 修改操作:修改操作用于修改线性表中的某个元素的值。
具体步骤是先查找到要修改的元素,然后将其值更新为新值。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
数据结构《实验1》实验报告实验项目1:线性表存储及运算学号1209030317 姓名王丰生课程号实验地点指导教师时间评语:按时完成实验;实验内容和过程记录完整;回答问题完整、正确;实验报告的撰写认真、格式符合要求;无抄袭的行为。
成绩教师签字线性表链式存储(双向链表)插入、删除运算1、预习要求:线性表的插入、删除相关概念及运算,完成线性表元素的插入、删除。
2、实验目的:(1)了解线性表的插入、删除相关概念;(2)理解线性表的插入、删除过程和结构定义;(3)掌握算法转换为程序的过程中的变化。
3、实验内容及要求:(1)分别建立包含10个数据元素的链式存储线性表;(2)从键盘输入一个数据元素,插入到线性表中第k(包含0号位置)个位置;(3)从键盘输入一个数据元素关键字或位置k(包含1号位置),从线性表中删除相应数据元素;(4)给出程序及插入、删除前和插入、删除后线性表结果。
4、实验设备(环境)及要求硬件:支持 Intel Pentium Ⅱ及其以上 CPU ,内存 128MB 以上、硬盘 1GB 以上容量的微机。
软件:配有 Windows98/2000/XP 操作系统,安装 Visual C++ 。
5、实验时间:6学时6、该文档的文件名不要修改,存入<学号> <姓名> 命名的文件夹中7、该表中的数据只需填空,已有内容不要修改实验结果(运行结果界面及源程序,运行结果界面放在前面):图1.0 菜单栏图1.1 功能1 输出链表中所有元素(截图部分缺省)图1.2 功能以递归方式逆向输出链表中的所有元素(截图部分缺省)图1.3 功能计算双向链表的长度(截图部分缺省)图1.4 功能在链表中查找第K个元素(截图部分缺省)图1.5 功能在链表中查找符合查找关键字 (学号)的元素(截图部分缺省)图1.6 功能在链表中插入新元素到第k个元素后面(截图部分缺省)图1.7 功能删除链表中第k个结点(截图部分缺省)图1.9 功能把链表中第k个结点移至第一个(截图部分缺省)图1.10 功能把链表中第i到第j个结点删除(截图部分缺省)代码#define STUDENT EType#define HeadEType int#include <iostream>#include <cstring>#include <cstdlib>using namespace std;struct STUDENT //学生类的定义{char number[11];char name[10];char sex[3];int age;char place[25];};struct DoubleChainNode // 结点定义{EType data;DoubleChainNode *plink;DoubleChainNode *nlink;};struct HeadNode // 表头结点{HeadEType Hdata;DoubleChainNode *first;};typedef HeadNode *DoubleChainList;// 构造一个空双向链表void CreatDoubleChainList(DoubleChainList &L) {L=new HeadNode;L->first=NULL;}// 逐个地输出链表L中的数据元素void OutputDoubleChainList(DoubleChainList &L) {DoubleChainNode *current=L->first;cout<<"L->first--》";while (current){current=current->nlink ;cout<<"nlink"<<"--------->";}cout<<"NULL"<<endl;current=L->first;cout<<" ";while (current){cout<<current->data.number<<" ";current=current->nlink ;}cout<<endl;current=L->first;cout<<" ";while (current){cout<<current-><<" ";current=current->nlink ;}cout<<endl;current=L->first;cout<<" ";while (current){cout<<current->data.sex<<" ";current=current->nlink ;}cout<<endl;current=L->first;cout<<" ";while (current){cout<<current->data.age<<" ";current=current->nlink ;}cout<<endl;current=L->first;cout<<" ";while (current){cout<<current->data.place<<" ";current=current->nlink ;}cout<<endl;}// 返回双向链表L中数据元素结点数int LengthDoubleChainList(DoubleChainList &L){DoubleChainNode *current=L->first;int length=0;while (current){length++;current=current->nlink;}return length;}// 删除双向链表L中所有数据结点,并释放结点空间void DestroyDoubleChainList(DoubleChainList &L){DoubleChainNode * current;current =L->first;while (L->first){current=current->nlink;delete L->first;L->first=current;}}//将L中第k个元素取至x中带出,如不存在返回false,找到返回true;bool GetElemDoubleChainList(DoubleChainList &L,int k,EType &result) {if (k<1) return false;DoubleChainNode *current;current=L->first;int index=1;while (index<k && current){current=current->nlink;index++;}if (current){result=current->data;return true;}return false; // k值太大,不存在第k个结点}// 查找x,如果找到返回x所在的地址;如果未找到返回NULL DoubleChainNode * SearchDoubleChainList(DoubleChainList &L,EType &x){DoubleChainNode *current;current=L->first;while (current && strcmp(current->data.number,x.number))current=current->nlink;if (current) return current;return NULL;}//在链表L中第k个数据元素之后中插入元素x,如果第k个元素不存在,返回false;bool InsertDoubleChainList(DoubleChainList &L, int k, EType &x ){if (k<0) return false;int index=1;DoubleChainNode *current;current=L->first;while (index<k && current){//找第k个结点index++;current=current->nlink;}if (k>0 && !current) return false;DoubleChainNode *q=new DoubleChainNode;q->data=x;if (k){// 插入的不是第一个结点,插入在current之后;q->nlink=current->nlink;if(!q->nlink) //作为最后一个结点插入{q->plink=current;current->nlink=q;}else{q->nlink->plink=q;q->plink=current;current->nlink=q;}}else{// 作为第一个元素结点插入q->nlink=NULL;q->plink=NULL;L->first=q;}return true;}// 在线性表L中删除第k个数据元素,如果不存在第k个元素返回false; bool DeleteDoubleChainList(DoubleChainList &L, int k ){if (k<1 || !L->first){if(k<1)cout<<"k值过小";if(!L->first)cout<<"线性表为空";return false;}DoubleChainNode * current;current=L->first;if (k == 1) // 删除的是链表中第一个结点{L->first=current->nlink;current->nlink->plink=NULL;}else{DoubleChainNode *q=L->first;for (int index=1; index<k-1 && q ; index++)q=q->nlink; // q 指向第k-1个结点if (!q || !q->nlink) return false;current=q->nlink; // current 指向第k个结点q->nlink=current->nlink;current->nlink->plink=q;}delete current; // 释放被删除结点current的空间return true;}// 在线性表L中将第k个数据元素移至表首bool MoveFirstDoubleChainList (DoubleChainList &L, int k ){if (k<1 || !L->first){if(k<1)cout<<"k值过小";if(!L->first)cout<<"线性表为空";return false;}DoubleChainNode * current=L->first;if (k == 1) return true; //是链表中第一个结点,直接返回else{DoubleChainNode *q=L->first;for (int index=1; index<k-1 && q;index++)q=q->nlink;if (!q || !q->nlink) return false;current=q->nlink; //current指向第k个结点q->nlink=current->nlink;current->nlink->plink=q;}current->nlink=L->first; //被删除结点current指向第一个结点L->first->plink=current; //第二个结点的plink指向currentL->first=current; //表头指针指向被删除结点currentcurrent->plink=NULL; //第一个元素的plink置为空return true;}//递归方式逆向输出线性表L中的所有元素void InvertDisplayDoubleChainList (DoubleChainNode *p){if (p){InvertDisplayDoubleChainList (p->nlink );cout<<p->data.number<<"--->";cout<<p-><<"--->";cout<<p->data.age<<"--->";cout<<p->data.sex<<"--->";cout<<p->data.place<<endl;}}//下面是主程序int main(){DoubleChainNode *p;DoubleChainList L;EType x,result;char number[][11] ={" ","1209030311", "1209030312", "1209030313", "1209030314", "1209030315", "1209030316", "1209030317","1209030318", "1209030319", "1209030320" };char name[][10] ={" ","苏润青", "侯美玲", "万佳","冯玉环", "柳宜江", "邢鑫", "王丰生", "李倩娟", "黄秀芳", "贺博" };char sex[][4] ={" ","女", "女", "女", "女", "男", "男", "男", "女", "女", "女" };char place[][20] ={" ","中区五栋213","中区五栋214","中区五栋215", "中区五栋216", "临湖四栋107", "临湖四栋106", "临湖四栋108", "中区五栋217", "中区五栋218", "中区五栋219" };int k,choice;int start,end;CreatDoubleChainList(L); //构造空链表;for(int i=1;i<11;i++){p=new DoubleChainNode;strcpy(p->data.number,number[i]);strcpy(p->,name[i]);strcpy(p->data.sex,sex[i]);p->data.age=25-i;strcpy(p->data.place,place[i]);if(i==1){p->nlink=NULL;p->plink=NULL;L->first=p;}else{p->nlink=L->first;L->first->plink=p;L->first=p;p->plink=NULL;}}while (true){cout<<endl;cout<<"************************ 线性表简单链表存储的运算*****************"<<endl;cout<<"* 1--------输出链表中的所有元素*"<<endl;cout<<"* 2--------以递归方式逆向输出链表中的所有元素*"<<endl;cout<<"* 3--------计算链表长度*"<<endl;cout<<"* 4--------在链表中查找第K个元素*"<<endl;cout<<"* 5--------在链表中查找符合查找关键字searchkey(学号)的元素*"<<endl;cout<<"* 6--------在链表中插入新元素到第k个元素后面*"<<endl;cout<<"* 7--------在链表中删除第k个元素*"<<endl;cout<<"* 8--------将第K个元素移至第1个元素位置*"<<endl;cout<<"* 9--------删除链表中所有结点*"<<endl;cout<<"* 10-------删除第i到第j个结点*"<<endl;cout<<"* 0--------退出*"<<endl;cout<<"*********************************************************** *******"<<endl;cout<<"请选择处理功能:"; cin>>choice;cout<<endl;system("cls");switch(choice){case 1:{// 1--------输出线性表中的所有元素cout<<"************输出链表中的所有元素*************"<<endl;cout<<endl;OutputDoubleChainList(L);cout<<endl;break;}case 2:{//2---------以递归方式逆向输出链表结果cout<<"************以递归方式逆向输出链表结果**********"<<endl<<endl;cout<<"此操作前链表状态:"<<endl<<endl;OutputDoubleChainList(L);cout<<endl;DoubleChainNode *current=L->first;cout<<"L->first--》";while (current){current=current->nlink ;cout<<"nlink"<<"--------->";}cout<<"NULL"<<endl;cout<<"以递归方式逆向输出链表结果:"<<endl<<endl;p=L->first;InvertDisplayDoubleChainList (p );cout<<endl;break;}case 3:{//3---------计算链表长度cout<<"************计算链表长度**********"<<endl<<endl;cout<<"此操作前链表状态:"<<endl<<endl;OutputDoubleChainList(L);cout<<endl;cout<<"线性表长度="<<LengthDoubleChainList(L)<<endl<<endl;break;}case 4:{//4---------在链表中查找第K个元素cout<<"************在链表中查找第K个元素**********"<<endl<<endl;cout<<"此操作前链表状态:"<<endl<<endl;OutputDoubleChainList(L);cout<<endl;cout<<"输入查找第K个记录的K值:"; cin>>k;cout<<endl;if (GetElemDoubleChainList(L,k,result)){cout<<"第"<<k<<"个元素的值:"<<endl<<endl;cout<<"学号:"<<result.number<<endl;cout<<"姓名:"<<<<endl;cout<<"性别:"<<result.sex<<endl;cout<<"年龄:"<<result.age<<endl;cout<<"住址:"<<result.place<<endl<<endl;}elsecout<<"K值范围不正确!"<<endl<<endl;break;}case 5:{//5----------在链表中查找符合查找关键字searchkey(学号)的元素cout<<"************在链表中查找符合查找关键字searchkey(学号)的元素**********"<<endl<<endl;cout<<"此操作前链表状态:"<<endl<<endl;OutputDoubleChainList(L);cout<<endl;cout<<"输入查找关键字number:"; cin>>x.number;p=SearchDoubleChainList(L, x);cout<<"查找结果:"<<endl<<endl;if(p){cout<<"学号:"<<p->data.number<<endl;cout<<"姓名:"<<p-><<endl;cout<<"性别:"<<p->data.sex<<endl;cout<<"年龄:"<<p->data.age<<endl;cout<<"住址:"<<p->data.place<<endl<<endl;}elsecout<<"无此年龄的人"<<endl<<endl;break;}case 6:{//6-----------在链表中插入新元素到第k个元素后面cout<<"************在链表中插入新元素到第k个元素后面**********"<<endl<<endl;cout<<"此操作前链表状态:"<<endl<<endl;OutputDoubleChainList(L);cout<<endl;cout<<"输入插入点K值:"; cin>>k;cout<<"输入要插入的数据值X:"<<endl<<endl;cout<<"请输入学号:";cin>>x.number;cout<<"请输入姓名:";cin>>;cout<<"请输入性别:";cin>>x.sex;cout<<"请输入年龄:";cin>>x.age;cout<<"请输入住址:";cin>>x.place;cout<<"学号:"<<x.number<<endl;cout<<"姓名:"<<<<endl;cout<<"性别:"<<x.sex<<endl;cout<<"年龄:"<<x.age<<endl;cout<<"住址:"<<x.place<<endl<<endl;cout<<"插入数据X到第"<<k<<"个记录后面的结果:"<<endl<<endl;if (InsertDoubleChainList(L, k, x ))OutputDoubleChainList(L);elsecout<<"K值范围不正确!"<<endl<<endl;break;}case 7:{//7---------在链表中删除第k个元素cout<<"************在链表中删除第k个元素**********"<<endl<<endl;cout<<"此操作前链表状态:"<<endl<<endl;OutputDoubleChainList(L);cout<<endl;cout<<"删除第几个结点:"; cin>>k;cout<<"删除第"<<k<<"个结点后的结果:"<<endl<<endl;if (DeleteDoubleChainList(L, k ))OutputDoubleChainList(L);elsecout<<"K值范围不正确!"<<endl<<endl;break;}case 8:{//8---------将第K个结点移至第1个结点位置cout<<"************将第K个结点移至第1个结点位置**********"<<endl<<endl;cout<<"此操作前链表状态:"<<endl<<endl;OutputDoubleChainList(L);cout<<endl;cout<<"将第几个结点移至第1个结点位置:"; cin>>k;cout<<endl<<"将第"<<k<<"个结点移至第1个结点位置结果:"<<endl<<endl;if (!MoveFirstDoubleChainList (L, k ))cout<<"K值不存在!"<<endl;elseOutputDoubleChainList(L);break;}case 9:{//9-------删除链表中所有结点cout<<"************删除链表中所有结点**********"<<endl<<endl;cout<<"此操作前链表状态:"<<endl<<endl;OutputDoubleChainList(L);cout<<endl;cout<<"删除整个链表中的结点后的结果:"<<endl<<endl;DestroyDoubleChainList(L);OutputDoubleChainList(L);break;}case 10:{//10---------删除第i到第j个结点cout<<"************在链表中删除第i到第j个结点**********"<<endl<<endl;cout<<"此操作前链表状态:"<<endl<<endl;OutputDoubleChainList(L);cout<<endl;cout<<" 输入起点i值:"; cin>>start;cout<<" 输入终点j值:"; cin>>end;cout<<endl<<endl;int len=LengthDoubleChainList(L);cout<<endl<<"删除第"<<start<<"到第"<<end<<"个结点后的结果:"<<endl;if (L->first && (start>0 && start<=len) && (end>0 && end<=len) && (start<=end)){k=start;for(int i=1;i<=end-start+1;i++){DeleteDoubleChainList(L, k );}OutputDoubleChainList(L);}elsecout<<"起点或终点值不对!"<<endl;break;}case 0:{//0-------退出链表操作cout<<endl<<"*********退出链表操作*********"<<endl;DestroyDoubleChainList(L);delete L;return 0;break;}}system("pause");system("cls");数据结构实验报告二〇一二年}}。