桂电数据结构实验一-线性表
1数据结构-实验报告一(线性表的基本操作)

实验一 线性表的基本操作及其应用一、实验目的1、帮助读者复习C++语言程序设计中的知识。
2、熟悉线性表的逻辑结构。
3、熟悉线性表的基本运算在两种存储结构上的实现。
4、掌握顺序表的存储结构形式及其描述和基本运算的实现。
5、熟练掌握动态链表结构及有关算法的设计二、实验内容求两个多项式的相加运算[问题描述]用单链表存储一元多项式,并实现两个多项式的相加运算。
[基本要求](1)本程序需要基于线性表的基本操作来实现一元多项式的加法,也可以用数组实现。
;(2)两个多项式都有键盘输入相应的系数和指数[测试数据] 由学生任意指定。
三、源代码#include <stdio.h>#include <malloc.h>#define MAX 20 //多项式最多项数typedef struct //定义存放多项式的数组类型{double coef; //系数int exp; //指数} PolyArray[MAX];typedef struct pnode //定义单链表结点类型{double coef; //系数int exp; //指数struct pnode *next;} PolyNode;void DispPoly(PolyNode *L) //输出多项式{bool first=true; //first为true表示是第一项PolyNode *p=L->next;while (p!=NULL){if (first)first=false;else if (p->coef>0)printf("+");if (p->exp==0)printf("%g",p->coef);else if (p->exp==1)printf("%gx",p->coef);elseprintf("%gx^%d",p->coef,p->exp);p=p->next;}printf("\n");}void DestroyList(PolyNode *&L) //销毁单链表{PolyNode *p=L,*q=p->next;while (q!=NULL){free(p);p=q;q=p->next;}free(p);}void CreateListR(PolyNode *&L,PolyArray a,int n) //尾插法建表{PolyNode *s,*r;int i;L=(PolyNode *)malloc(sizeof(PolyNode)); //创建头结点L->next=NULL;r=L; //r始终指向终端结点,开始时指向头结点for (i=0;i<n;i++){s=(PolyNode *)malloc(sizeof(PolyNode));//创建新结点s->coef=a[i].coef;s->exp=a[i].exp;r->next=s; //将*s插入*r之后r=s;}r->next=NULL; //终端结点next域置为NULL}void Sort(PolyNode *&head) //按exp域递减排序{PolyNode *p=head->next,*q,*r;if (p!=NULL) //若原单链表中有一个或以上的数据结点{r=p->next; //r保存*p结点后继结点的指针 p->next=NULL; //构造只含一个数据结点的有序表 p=r;while (p!=NULL){r=p->next; //r保存*p结点后继结点的指针 q=head;while (q->next!=NULL && q->next->exp>p->exp)q=q->next; //在有序表中找插入*p的前驱结点*qp->next=q->next; //将*p插入到*q之后q->next=p;p=r;}}}void Add(PolyNode *ha,PolyNode *hb,PolyNode *&hc) //求两有序集合的并{PolyNode *pa=ha->next,*pb=hb->next,*s,*tc;double c;hc=(PolyNode *)malloc(sizeof(PolyNode)); //创建头结点tc=hc;while (pa!=NULL && pb!=NULL){if (pa->exp>pb->exp){s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pa->exp;s->coef=pa->coef;tc->next=s;tc=s;pa=pa->next;}else if (pa->exp<pb->exp){s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pb->exp;s->coef=pb->coef;tc->next=s;tc=s;pb=pb->next;}else //pa->exp=pb->exp{c=pa->coef+pb->coef;if (c!=0) //系数之和不为0时创建新结点{s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pa->exp;s->coef=c;tc->next=s;tc=s;}pa=pa->next;pb=pb->next;}}if (pb!=NULL) pa=pb; //复制余下的结点while (pa!=NULL){s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点 s->exp=pa->exp;s->coef=pa->coef;tc->next=s;tc=s;pa=pa->next;}tc->next=NULL;}void main(){PolyNode *ha,*hb,*hc;PolyArray a={{2.3,0},{-2.8,2},{5.6,3},{-10.9,7},{7.6,10}};PolyArray b={{-1.2,0},{8.6,1},{-13.9,3},{15.5,5},{5.6,9}};CreateListR(ha,a,5);CreateListR(hb,b,5);printf("原多项式A: ");DispPoly(ha);printf("原多项式B: ");DispPoly(hb);Sort(ha);Sort(hb);printf("有序多项式A: ");DispPoly(ha);printf("有序多项式B: ");DispPoly(hb);Add(ha,hb,hc);printf("多项式相加: ");DispPoly(hc);DestroyList(ha);DestroyList(hb);DestroyList(hc);}四、测试结果五、心得体会两个简单的的多项式用相加,编程却需要线性表各种用法显得很复杂。
数据结构线性表实验报告

实验报告实验一线性表实验目的: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.复习C语言的上机环境,掌握C语言的基本结构;2.会定义线性表的顺序存储结构和链表的存储结构;3.熟悉对顺序表的一些基本操作和具体的函数定义。
4.掌握顺序表和单链表的存储结构及相关运算5.掌握顺序表和单链表的基本应用二、实验硬软件环境硬件环境:赛扬433以上CPU,10GB以上硬盘,64MB以上内存软件环境:DOS+Turbo C 2.0 或Borland C++ 3.1以上Windowx 9X+VC++ 5.0以上三、实验要求1.认真阅读和掌握本实验内容所给的全部程序。
2.保存和打印出程序运行结果,并结合程序进行分析。
3.按照你对顺序表操作的需要,屏幕考贝运行结果到实验报告中。
4.撰写实验报告并准时上交四、注意事项在做第一次“数据结构”课程实验之前,要在硬盘上建立好自己的工作目录,专门用来存储你所做的实验程序及相关信息,以后每次做实验都采用这个目录。
本实验设计完全由老师设计,版权限本班同学使用,勿外传。
实验材料下载到本机后,请用winrar软件释放到你的电脑磁盘的“数据结构实验(张三)”文件夹中,形成如上图的文件夹结构。
上交实验报告时,请把“实验一”的所有内容(含实验报告)用winrar打包成.rar文件后一并交上来。
上传名字为“实验一(张三).rar”五、基本理论线性表:线性表(linear list)是这样的数据对象,其实例形式为: (e1 , e2 ,... en ),其中n 是有穷自然数。
e是表中的元素,n 是表的长度。
元素i可以被视为原子,因为它们本身的结构与线性表的结构无关。
当n = 0 时,表为空;当n > 0时,e1是第一个元素,e n是最后一个元素,可以认为e l优先于e2,e优先于e3,如此等等。
除了这种优先关系之外,在线性表中不再有其他的结构。
2基本操作:• 创建一个线性表。
• 确定线性表是否为空。
• 确定线性表的长度。
• 查找第k个元素。
数据结构实验一-线性表及其应用

createsqlist(L,n);
printf("Input the insert location:\n");
scanf("%d",&i);
printf("Input the insert data:\n");
scanf("%d",&x);
if (insert(L,i,x))
{printf("The length of new list is:%d\n",L->len);
for(i=0;i<k;i++)
/* 将从屏幕输入的字符存近顺序表中 */
1
scanf("%d",&L->vec[i]); return OK; }
sqlist.c
#include<stdio.h>
#include<conio.h>
#include "sqlist.h"
int main()
{
int i,n;
{
printf ("the list is overfollow\n");
return NULL;
/*如果超出,打印相应字符,然后返
回null*/
}
else if ((i<1)||(i>(*L).len+1)) /*判断插入点是否合理*/
{
printf("position is not corrent.\n"); /*如果不合理打印相应字符,返回null*/
{
int n,i,x;
sequenlist *L, a;
数据结构实验报告1线性表的顺序存储结构

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

实验1 线性表的基本操作一、需求分析目的:掌握线性表运算与存储概念,并对线性表进行基本操作。
1.初始化线性表;2.向链表中特定位置插入数据;3.删除链表中特定的数据;4.查找链表中的内容;5.销毁单链表释放空间;二、概要设计●基础题主要函数:初始化线性表InitList(List* L,int ms)向顺序表指定位置插入元素InsertList(List* L,int item,int rc)删除指定元素值的顺序表记录DeleteList1(List* L,int item)删除指定位置的顺序表记录 DeleteList2(List* L,int rc)查找顺序表中的元素 FindList(List L,int item)输出顺序表元素OutputList(List L)实验步骤:1,初始化顺序表2,调用插入函数3,在顺序表中查找指定的元素4,在顺序表中删除指定的元素5,在顺序表中删除指定位置的元素6,遍历并输出顺序表●提高题要求以较高的效率实现删除线性表中元素值在x到y(x和y自定义)之间的所有元素方法:按顺序取出元素并与x、y比较,若小于x且大于y,则存进新表中。
编程实现将两个有序的线性表进行合并,要求同样的数据元素只出现一次。
方法:分别按顺序取出L1,L2的元素并进行比较,若相等则将L1元素放进L中,否则将L 1,L2元素按顺序放进L。
本程序主要包含7个函数主函数main()初始化线性表InitList(List* L,int ms)向顺序表指定位置插入元素InsertList(List* L,int item,int rc)删除指定元素值的顺序表记录DeleteList1(List* L,int item)删除指定位置的顺序表记录 DeleteList2(List* L,int rc)查找顺序表中的元素 FindList(List L,int item)输出顺序表元素OutputList(List L)提高题的程序void Combine(List* L1,List* L2,List* L)void DeleteList3(List* L,int x,int y)二、详细设计初始化线性表InitList(List* L,int ms)void InitList(List* L,int ms){L->list=(int*)malloc(LIST_INIT_SIZE*sizeof(int));L->size=0;L->MAXSIZE=LIST_INIT_SIZE;}向顺序表指定位置插入元素InsertList(List* L,int item,int rc)void InsertList(List* L,int item,int rc){int i;if (L->size>=L->MAXSIZE){L->list=(int*)realloc(L->list,(L->MAXSIZE+LISTI)*sizeof(int));L->MAXSIZE+=LISTI;}for (i=L->size-1;i>=rc-1;i--){L->list[i+1]=L->list[i];}L->list[rc-1]=item;L->size++;}删除指定元素值的顺序表记录DeleteList1(List* L,int item)void DeleteList1(List* L,int item){int i,j;for (i=0;i<L->size;i++){if (L->list[i]==item){break;}}for (j=i;j<L->size;j++){L->list[j]=L->list[j+1];}L->size--;}删除指定位置的顺序表记录 DeleteList2(List* L,int rc)void DeleteList2(List* L,int rc){int i;for (i=rc-1;i<L->size;i++){L->list[i]=L->list[i+1];}L->size--;}查找顺序表中的元素void FindList(List* L,int item){int i;for (i=0;i<L->size;i++){if (L->list[i]==item)break;}if (L->size==i){printf("找不到\n");}else{printf("第%d个元素为%d\n",i+1,item); }}输出顺序表元素OutputList(List L)void OutputList(List* L){int i;for (i=0;i<L->size;i++){printf("%d ",L->list[i]);}printf("\n");}删除x到y之间的所有元素void DeleteList3(List* L,int x,int y){int i,j,temp;if (x>y)temp=x;x=y;y=temp;}for (i=0,j=0;i<L->size;i++){if (L->list[i]<x || L->list[i]>y){L->list[j]=L->list[i];j++;}}L->size=j;}将两个有序的线性表进行合并void Combine(List* L1,List* L2,List* L) {int i,j,k,temp;if (L1->size>L2->size){temp=L2->size;}else{temp=L1->size;i=0,j=0,k=0;while(1){if (i==L1->size || j==L2->size)break;if (L1->list[i]<L2->list[j]){L->list[k]=L1->list[i];k++;i++;}else if (L1->list[i]>L2->list[j]){L->list[k]=L2->list[j];k++;j++;}else{L->list[k]=L2->list[j];k++;j++;i++;}}if (i==L1->size){for (i=j;i<L2->size;i++,k++){L->list[k]=L2->list[i];}}else{for (j=i;j<L1->size;j++,k++){L->list[k]=L1->list[j];}}L->size=k;}三、调试分析体会:线性表内数据都是顺序排放所以实验中比较容易写出程序时间复杂度:初始化线性表InitList(List* L,int ms)⊙(1)向顺序表指定位置插入元素InsertList(List* L,int item,int rc)⊙(n)删除指定元素值的顺序表记录DeleteList1(List* L,int item) ⊙(n) 删除指定位置的顺序表记录 DeleteList2(List* L,int rc)⊙(n)查找顺序表中的元素 FindList(List L,int item)⊙(n)输出顺序表元素OutputList(List L)⊙(n)删除x到y之间的所有元素⊙(n)将两个有序的线性表进行合并⊙(n) 四、调试与结果测试。
数据结构实验一-线性表

数据结构实验⼀-线性表实验⼀线性表⼀、实验⽬的1、深刻理解线性结构的特点,以及在计算机内的两种存储结构。
2、熟练掌握线性表的顺序存储结构和链式存储结构,及其它们的基本操作,重点掌握查找、插⼊和删除等操作。
⼆、实验要求1、认真阅读程序,将未完成的代码补全(红⾊部分)。
2、上机调试,并运⾏程序。
3、保存和截图程序的运⾏结果,并结合程序进⾏分析。
三、实验内容和基本原理1、实验1.1 顺序表的操作利⽤顺序表存储⽅式实现下列功能(见参考程序1):1)通过键盘输⼊数据建⽴⼀个线性表,并输出该线性表。
如,依次输⼊元素25,21,46,90,12,98。
2)根据屏幕菜单的选择,进⾏数据的插⼊、删除和查找,并在插⼊或删除数据后,再输出线性表。
如,在第2个位置上插⼊元素43,然后输出顺序表。
删除顺序表第4个元素,输出改变的顺序表。
3)在屏幕菜单中选择0,结束程序的运⾏。
基本原理:在顺序表的第i个位置上插⼊⼀个元素时,必须先将线性表的第i个元素之后的所有元素依次后移⼀个位置,以便腾空⼀个位置,在把新元素插⼊到该位置。
当要删除第i个元素时,只需将第i个元素之后的所有元素前移⼀个位置。
程序代码(蓝⾊为补充的语句)://* * * * * * * * * * * * * * * * * * * * * * * *//*PROGRAM :顺序结构的线性表 *//*CONTENT :建⽴,插⼊,删除,查找 *//*编程语⾔: Visual c++ 6.0 *//* * * * * * * * * * * * * * * * * * * * * *#include#include#define MAXSIZE 20typedef int ElemType; //数据元素的类型typedef struct{ElemType a[MAXSIZE];int length;}SqList; //顺序存储的结构体类型SqList a,b,c;//函数声明void creat_list(SqList *L);void out_list(SqList L);void insert_sq(SqList *L,int i,ElemType e); ElemType delete_sq(SqList *L,int i);int locat_sq(SqList L,ElemType e);//主函数void main(){int i,k,loc;ElemType e,x;char ch;do {printf("\n\n\n");printf("\n 吴肖遥20151681310131");printf("\n 1.建⽴线性表");printf("\n 2.插⼊元素");printf("\n 3.删除元素");printf("\n 4.查找元素");printf("\n 0.结束程序运⾏");printf("\n =====================");printf("\n 请输⼊要执⾏的操作: ");scanf("%d",&k);switch(k){case 1:{creat_list(&a);out_list(a);}break;case 2:{printf("\n请输⼊插⼊位置: ",a.length+1); scanf("%d",&i);printf("请输⼊要插⼊的元素值: ");scanf("%d",&e);insert_sq(&a,i,e);out_list(a);}break;case 3:{printf("\n请输⼊要删除元素的位置: ",a.length); scanf("%d",&i);x=delete_sq(&a,i);out_list(a);if(x!=-1)printf("\n删除的元素为:%d\n",x);else printf("要删除的元素不存在!");}break;case 4:{printf("\n请输⼊要查找的元素值:");scanf("%d",&e);loc=locat_sq(a,e);if(loc==-1)printf("\n未找到指定元素!");elseprintf("\n已找到,元素的位置是: %d ",loc);}break;}/*switch*/}while(k!=0);printf("\n 按回车键,返回...\n");ch=getchar();}/*main*///建⽴线性表void creat_list(SqList *L){int i;printf("请输⼊线性表的长度: ");scanf("%d",&L->length);for(i=0;ilength;i++){printf("数据 %d =",i);scanf("%d",&(L->a[i]));}}//输出线性表void out_list(SqList L){int i;for(i=0;i<=L.length-1;i++)printf("%10d",L.a[i]);}//在线性表的第i个位置插⼊元素evoid insert_sq(SqList *L,int i,ElemType e){int j;if(L->length==MAXSIZE)printf("线性表已满!\n");else {if(i<1||i>L->length+1)printf("输⼊位置错!\n");else {for(j=L->length-1;j>=i-1;j--)L->a[j+1]=L->a[j];L->a[j+1]=e;/*将未完成的代码补全,提⽰:此处添加⼀条语句,将被删除的元素值赋给e*/ L->length++;}}}//删除第i个元素,返回其值ElemType delete_sq(SqList *L,int i){ElemType x;int j;if(L->length==0)printf("空表!\n");else if(i<1||i>L->length){printf("输⼊位置错!\n");x=-1;}else{x=L->a[i-1];for(j=i;j<=L->length-1;j++)L->a[j-1]=L->a[j];/*将未完成的代码补全,提⽰:此处添加⼀条语句,将被删除元素之后的元素左移。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
桂电数据结构实验一-线性表
实验一线性表
实验目的
1、掌握线性表的逻辑结构和物理实现;
2、掌握线性表的顺序存储结构和链式存储结构,熟悉对线性表的基本操作;
3、在学有余力的情况下,掌握循环链表的实现及其基本操作;
4、根据实验要求设计并完成程序,把理论的基本操作知识转化到实际的实践应用中。
课题一的具体实验内容
1、构造元素类型为整型的线性表,将以下元素插入分别插入线性表:
<34 56 20 9 15 5>
2、查找表中是否存在元素20,实现元素20与元素9的交换;
3、按照课题要求编写函数,实现线性表元素
<34 56 9 20 15 5>的倒置,即倒置
后的表应为< 5 15 20 9 56 34 >。
主程序代码
#include<stdio.h>
#include<stdlib.h>
#define NULL 0
struct node
{
int num;
struct node *next;
};
void main()
{
int i,flag=1;
struct node *L,*s,*p,*h,*q,*k,*p1,*temp;
L=(node*)malloc(sizeof(struct node));
p=L; printf("请输入\n");
for(i=0;i<6;i++)
{
s=(node*)malloc(sizeof(struct node));
scanf("%d",&s->num);
p->next=s;
p=s;
}
p->next=NULL; //以上是链表的建立和输入
//以下为a元素交换
p=L;
while(p->next->num!=20&&p->next->next!=NULL) p=p->next;
if(p->next->next==NULL)
{
printf("sorry,can not find!\n");
flag=0;
printf("原表括倒置后输出\n");
}
else if (p->next->num==20)
{
flag=1;
printf("find it!\n");
}
if(flag==1)
{
h=p->next;
p->next=p->next->next;
h->next=p->next->next;
p->next->next=h;
//以下为链表括的输出
printf("交换后输出\n");
p=L->next;
while(p!=NULL)
{
printf("%d ",p->num);
p=p->next;
}
printf("倒置后输出\n");
}
//以下为链表括的倒置
p1=L->next;
temp=p1->next;
p1->next=NULL;
p=temp;
while(temp!=NULL)
{ p=p->next;//移动原链表的指针?
temp->next=p1;
L->next=temp;
p1=temp;//需插入节点的指向移动
temp=p;
}
//以下为链表输出
p=L->next;
while(p!=NULL)
{
printf("%d ",p->num);
p=p->next;
}
printf("\n");
}。