中国石油大学(北京)数据结构上机实验1

合集下载

数据结构上机指导书_实验一

数据结构上机指导书_实验一

数据结构与算法实验指导书中国石油大学(北京)计算机科学与技术系前言《数据结构》是计算机及相关专业的一门核心基础课程,也是很多高校考研专业课之一。

它主要介绍线性结构、树结构、图结构三种逻辑结构元素的存储实现,在此基础上介绍一些典型算法及时、空效率分析。

这门课程的主要任务是培养学生的算法设计能力及良好的程序设计习惯。

通过学习,要求学生能够掌握典型算法的设计思想及程序实现,能够根据实际问题选取合适的存储方案,设计出简洁、高效、实用的算法,为后续课程的学习及软件开发打下良好的基础。

学习这门课程,习题和实验是两个关键环节。

学生理解算法,上机实验是最佳的途径之一。

因此,实验环节的好坏是学生能否学好《数据结构》的关键。

为了更好地配合学生实验,特编写实验指导书。

一、实验目的更好的理解算法的思想、培养编程能力。

二、实验要求1、每次实验前学生必须根据试验内容认真准备实验程序及调试时所需的输入数据。

2、在指导教师的帮助下能够完成实验内容,得出正确的实验结果。

3、实验结束后总结实验内容、书写实验报告。

4、遵守实验室规章制度、不缺席、按时上、下机。

5、实验学时内必须做数据结构的有关内容,不允许上网聊天或玩游戏,如发现上述现象,取消本次上机资格,平时成绩扣10分。

6、实验报告有一次不合格,扣5分,两次以上不合格者,平时成绩以零分记。

三、实验环境 VC++6.0或者VC2010四、说明1、本实验的所有算法中元素类型可以根据实际需要选择。

2、实验题目中带*者为较高要求,学生可自选;其余部分为基本内容,应尽量完成(至少完成70%,否则实验不合格)。

3、数据结构是很多高校的硕士研究生入学考试的专业课之一,希望有志于考研的学生能够在学习过程中注意各种算法的理解,以便为考研做一定的准备。

五、实验报告的书写要求1.明确实验的目的及要求;2.记录实验的输入数据和输出结果;3.说明实验中出现的问题和解决过程;4.写出实验的体会和实验过程中没能解决的问题;六、参考书目《数据结构》(C++语言描述)王红梅等清华大学出版社《DATA STRUCTURE WITH C++》 William Ford,William Topp清华大学出版社(影印版)实验平台控制台程序1、启动Microsoft VC6.0集成开发环境如图所示:2、单击“文件”菜单,选择“新建”项。

中国石油大学数据结构上机实验3

中国石油大学数据结构上机实验3

《数据结构》实验报告学号2015011512 姓名胡明禹专业数学与应用数学时间2018.4.3一、实验题目实验3 顺序栈基本操作二、实验目的1.熟练掌握顺序栈的实现和基本操作2.理解栈后进先出的特点3.熟练应用顺序栈解决实际问题三、算法设计分析(一)数据结构的定义数据结构是计算机存储、组织数据的方式。

数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。

(二)总体设计此处给出主要函数功能、及函数间调用关系的的描述。

例如:①初始化并建立一个新栈表函数②栈清空函数③栈判断是否为空函数④进栈函数⑤出栈函数⑥取栈顶元素函数⑦输出栈元素函数⑧计算栈中元素个数函数⑨销毁栈函数(1)主函数:统筹调用各个函数以实现相应功能void main()(2)①初始化并建立一个新栈表SqStack *InitStack(SqStack *s){int i;s=(SqStack*)malloc(sizeof(SqStack));s->top=-1;printf("输入顺序栈元素(以0结束):\n");scanf("%d",&i);do{s->top++;//栈顶指针增加一s->data[s->top]=i; //将新插入元素赋值给栈顶空间scanf("%d",&i);while(i!=0);printf("成功\n");return s;}②栈清空函数void SetNULL(SqStack *s){//清空栈s->top=-1;//当栈存在一个元素时,top等于0,因此通常把空栈的条件定位top等于-1 }③栈判断是否为空函数int EMPTY(SqStack *s){//判断栈空if(s->top>=0)return 0;else return 1;}④进栈函数SqStack *Push(SqStack *s){//进栈int a;printf("插入数字:");scanf("%d",&a);if(s->top==maxsize-1)//判断是否栈满{printf("overflow");//溢出return NULL;}else{s->top++;//栈顶指针增加1s->data[s->top]=a;//将新插入元素赋值给栈顶空间}return s;}⑤出栈函数SqStack *Pop(SqStack *s){//出栈if(s->top==-1)//当栈存在一个元素时,top等于0,因此通常把空栈的条件定位top等于-1 {printf("underlow");return s;}else{s->top--;//栈顶指针减一printf("删除的栈顶元素:");printf("%d\n",(s->data[s->top+1]));//若栈不为空,则删除s的栈顶元素}return s;}⑥取栈顶元素函数void GetTop(SqStack *s){//取栈顶if(s->top==-1){printf("SqStack is empty");//当栈存在一个元素时,top等于0,因此通常把空栈的条件定位top 等于-1}else{printf("当前栈顶元素是:");printf("%d\n",(s->data[s->top]));//取栈顶元素地址}}⑦输出栈元素函数void print(SqStack *s){//输出栈int i=0;if(s->top==-1){printf("成功!");}while(i<=s->top){//遍历栈中所有元素printf("%d ",s->data[i]);i++;}}⑧计算栈中元素个数函数void Count(SqStack *s){//计算栈中元素int i=0;while(i<=s->top){i++;}printf("个数为%d",i);}⑨销毁栈函数int DestroyStack_Sq(SqStack *s){ //销毁一个顺序栈Sfree(s);s=NULL;return 1;}四、实验测试结果及结果分析(一)测试结果(此处给出程序运行截图)(二)结果分析成功完成了题目所要求的插入,删除,查找等基本操作。

数据结构上机实验报告

数据结构上机实验报告
{if(i%2==0) insert(lb,i/2,la.list[i]); //奇数位次元诩插入lb
else insert(lc,i/2,la.list[i]); //偶数位次元素插入lc
}
printf("\n您输入的线性表元素为:\n\n");
print(la);
printf("线性表的奇数位次的元素为:\n\n");
print(lb);
printf("线性表的偶数位次的元素为:\n\n");
print(lc);
}
void initial(sqlist &v)
{printf(" ****本程序可以实现线性表奇偶位序的元素分别输出****\n\n\n");
int i,a;
printf("请输入一个偶数作为线性表的长度:\n\n");
void initlist(sqlist &);
void print(sqlist); //输出线性表
void main()
{printf(" *****************本程序可以实现线性表的复制******************\n");
sqlist la,lb; //声明线性表
initial(la);
【程序设计细想】:
建立三个线性表la,lb,lc,对线性表la进行输入,然后利用循环结构对la中奇数位序的元素对lb进行插入操作,对偶数位序的元素对lc进行插入操作,从而得到线性表lb和lc。
【程序代码】:
#include<stdio.h>
#include<malloc.h>

matlab 上机作业1,中国石油大学

matlab 上机作业1,中国石油大学

第一次上机实习1.编写一个程序ex1_1.m,对输入的方阵计算其伴随矩阵。

a)要求第一行帮助行注明这个函数的用途,能在matlab命令窗口可以用help或lookfor查到该帮助;b)对输入的变量进行检测,如果输入的不是方阵或者矩阵元素不是数,则报错,退出程序。

function A=ex1_1(X)% 建立函数A=ex1_1(X),求矩阵X的伴随矩阵[a,b]=size(X);if a~=b||~isnumeric(X) || ~ismatrix(X)error('输入的不是方阵或者矩阵元素不是数!');endfor i=1:afor j=1:bA(i,j)=(-1)^(i+j)*X(i,j)*det(X([1:i-1,i+1:end],[1:j-1,j+1:end]));endendA=A';2.已知表达式y=6*x^5+4*x^3+2*x^2-7x+10,x的范围是[0,100],使用三阶拟合和五阶的方法得出多项式的表达式,并编程在图中绘制出原曲线、三阶拟合和五段拟合的曲线。

clcclear allx=linspace(0,100,2000);p1=[6 0 4 2 -7 0];y=polyval(p1,x);p3=polyfit(x,y,3);p5=polyfit(x,y,5);y1=polyval(p3,x);y2=polyval(p5,x);plot(x,y,'r-o')hold ongrid onplot(x,y1,'b-.',x,y2,'y--*');grid on三条曲线放大图(原曲线与五阶拟合完全重合):3.读如图像5.tif(450*450),做fourier变换,a)将变换之后所得到的矩阵只保留前10行10列,后10行10列的数据,其他位置都设置为0,然后再作反fourier变换,观察结果;原图:运行程序:clcclear allI=imread('5.tif');figure(1);imshow(I);B=fft2(I);C=ones(size(B));C(11:end-10,11:end-10)=0;B1=B.*C;B1=B1./256;I1=ifft2(B1);figure(2);imshow(I1);图像:b)将变换之后所得到的矩阵将前10行10列,后10行10列的数据置为0,然后再作反fourier变换,观察结果;clcclear allI=imread('5.tif');figure(1);imshow(I);B=fft2(I);C=zeros(size(B));C(11:end-10,11:end-10)=1;B1=B.*C;B1=B1./256;I1=ifft2(B1);figure(2);imshow(I1);c) 从观察的结果你有什么体会。

数据结构上机操作实验报告

数据结构上机操作实验报告

实验一单链表的基本操作(必做)一、实验目的1.掌握单链表的存储、初始化、插入、删除等操作的程序实现。

2.加深对单链表基本概念,基本理论及相应算法的掌握与理解。

3.了解链表的处理方式,学习体会简单的单链表程序实现相关知识。

二、实验内容1.建立一个链表、设计链表的基本操作实现算法、输出一个链表表,调试并输出结果。

2.编写一个程序实现如下功能:让计算机产生出50个0~9之间的随机数并依次保存到单链表中;输出遍历单链表;从单链表中删除与给定值相等的所有结点;输出遍历单链表;输出单链表长度,调试并输出结果。

三、实验步骤1.定义一个链表结构体。

2.利用插入功能插入一个结点。

3.利用删除功能删除一个结点。

四、程序运行测试1.利用插入功能插入一个结点。

2.利用删除功能删除一个结点。

五、实验报告要求1.绘制链表操作实现的流程图。

2.详细给出程序运行测试结果(包括测试数据和测试结果)。

3.选试验步骤2-3中的任意一个,给出程序的详细注释。

4.参考程序中某一部分功能的改进(选做)5.实验心得与体会6.附录,实验用源程序六、参考源代码#include <iostream.h>#include <malloc.h>typedef struct LNode{int data;struct LNode *next;}Lnode, *LinkList;//假设下面的单链表均为带头结点。

void CreatLinkList(LinkList &L,int j){//建立一个单链表L,数据为整数,数据由键盘随机输入。

LinkList p,q;L=(LinkList )malloc(sizeof(Lnode));L->next=NULL;q=L;cout<<"在单链表内输入整数:"<<endl;for(int i=0;i<j;i++) p=(LinkList)malloc(sizeof(Lnode)); cin>>p->data;p->next=q->next;q->next=p;q=p; }int PrintLinkList(LinkList &L){//输出单链表L的数据元素LinkList p;p=L->next;if(L->next==NULL){cout<<"链表没有元素!"<<endl;return 0;}cout<<"单链表的数据元素为:";while(p){cout<<p->data<<" ";p=p->next;}cout<<endl;return 1;}void LinkListLengh(LinkList &L){//计算单链表L的数据元素个数。

数据结构上机实验

数据结构上机实验

目录第1章绪论——上机实验题1解析实验题1.1求素数实验题1.2求一个正整数的各位数字之和实验题1.3求一个字符串是否为回文第2章线性表——上机实验题2解析实验题2.1实现顺序表各种基本运算的算法/*文件名:algo2-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char 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--; /*将顺序表位序转化为elem下标*/for (j=L->length;j>i;j--) /*将elem[i]及后面元素后移一个位置*/L->elem[j]=L->elem[j-1];L->elem[i]=e;L->length++; /*顺序表长度增1*/return 1;}int ListDelete(SqList *&L,int i,ElemType &e){int j;if (i<1 || i>L->length)return 0;i--; /*将顺序表位序转化为elem下标*/e=L->elem[i];for (j=i;j<L->length-1;j++)L->elem[j]=L->elem[j+1];L->length--;return 1;}实验题2.2实现单链表各种基本运算的算法*文件名:algo2-2.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct LNode /*定义单链表结点类型*/{ElemType data;struct LNode *next;} LinkList;void InitList(LinkList *&L){L=(LinkList *)malloc(sizeof(LinkList)); /*创建头结点*/L->next=NULL;}void DestroyList(LinkList *&L){LinkList *p=L,*q=p->next;while (q!=NULL){free(p);p=q;q=p->next;}free(p);}int ListEmpty(LinkList *L){return(L->next==NULL);}int ListLength(LinkList *L){LinkList *p=L;int i=0;while (p->next!=NULL){i++;p=p->next;}return(i);}void DispList(LinkList *L){LinkList *p=L->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}int GetElem(LinkList *L,int i,ElemType &e) {int j=0;LinkList *p=L;while (j<i && p!=NULL){j++;p=p->next;}if (p==NULL)return 0;else{e=p->data;return 1;}}int LocateElem(LinkList *L,ElemType e){LinkList *p=L->next;int n=1;while (p!=NULL && p->data!=e){p=p->next;n++;}if (p==NULL)return(0);elsereturn(n);}int ListInsert(LinkList *&L,int i,ElemType e)int j=0;LinkList *p=L,*s;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{s=(LinkList *)malloc(sizeof(LinkList)); /*创建新结点*s*/s->data=e;s->next=p->next; /*将*s插p->next=s;return 1;}}int ListDelete(LinkList *&L,int i,ElemType &e){int j=0;LinkList *p=L,*q;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{q=p->next; /*q指向要删除的结点*/p->next=q->next; /*从单链表中删除*q结点*/free(q); /*释放*q结点*/return 1;}}第3章栈和队列——上机实验题3解析实验题3.1实现顺序栈各种基本运算的算法*文件名:algo3-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 100typedef char ElemType;typedef struct{ElemType elem[MaxSize];int top; /*栈指针*/} SqStack;void InitStack(SqStack *&s){s=(SqStack *)malloc(sizeof(SqStack));s->top=-1;}void ClearStack(SqStack *&s){free(s);}int StackLength(SqStack *s){return(s->top+1);}int StackEmpty(SqStack *s){return(s->top==-1);}int Push(SqStack *&s,ElemType e){if (s->top==MaxSize-1)return 0;s->top++;s->elem[s->top]=e;return 1;}int Pop(SqStack *&s,ElemType &e){if (s->top==-1)return 0;e=s->elem[s->top];s->top--;return 1;int GetTop(SqStack *s,ElemType &e){if (s->top==-1)return 0;e=s->elem[s->top];return 1;}void DispStack(SqStack *s){int i;for (i=s->top;i>=0;i--)printf("%c ",s->elem[i]);printf("\n");}实验题3.2实现链栈各种基本运算的算法/*文件名:algo3-2.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct linknode{ElemType data; /*数据域*/struct linknode *next; /*指针域*/} LiStack;void InitStack(LiStack *&s){s=(LiStack *)malloc(sizeof(LiStack));s->next=NULL;}void ClearStack(LiStack *&s){LiStack *p=s->next;while (p!=NULL){free(s);s=p;p=p->next;}}int StackLength(LiStack *s){int i=0;LiStack *p;p=s->next;while (p!=NULL){i++;p=p->next;}return(i);}int StackEmpty(LiStack *s){return(s->next==NULL);}void Push(LiStack *&s,ElemType e){LiStack *p;p=(LiStack *)malloc(sizeof(LiStack));p->data=e;p->next=s->next; /*插入*p结点作为第一个数据结点*/s->next=p;}int Pop(LiStack *&s,ElemType &e){LiStack *p;if (s->next==NULL) /*栈空的情况*/return 0;p=s->next; /*p指向第一个数据结点*/e=p->data;s->next=p->next;free(p);return 1;}int GetTop(LiStack *s,ElemType &e){if (s->next==NULL) /*栈空的情况*/return 0;e=s->next->data;return 1;}void DispStack(LiStack *s){LiStack *p=s->next;while (p!=NULL){printf("%c ",p->data);p=p->next;}printf("\n");}实验题3.3实现顺序队列各种基本运算的算法/*文件名:algo3-3.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 5typedef char ElemType;typedef struct{ElemType elem[MaxSize];int front,rear; /*队首和队尾指针*/} SqQueue;void InitQueue(SqQueue *&q){q=(SqQueue *)malloc (sizeof(SqQueue));q->front=q->rear=0;}void ClearQueue(SqQueue *&q){free(q);}int QueueEmpty(SqQueue *q){return(q->front==q->rear);}int QueueLength(SqQueue *q){return (q->rear-q->front+MaxSize)%MaxSize; }int enQueue(SqQueue *&q,ElemType e){if ((q->rear+1)%MaxSize==q->front) /*队满*/return 0;q->rear=(q->rear+1)%MaxSize;q->elem[q->rear]=e;return 1;}int deQueue(SqQueue *&q,ElemType &e){if (q->front==q->rear) /*队空*/return 0;q->front=(q->front+1)%MaxSize;e=q->elem[q->front];return 1;}实验题3.4实现链队各种基本运算的算法/*文件名:algo3-4.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct qnode{ElemType data;struct qnode *next;} QNode;typedef struct{QNode *front;QNode *rear;} LiQueue;void InitQueue(LiQueue *&q){q=(LiQueue *)malloc(sizeof(LiQueue));q->front=q->rear=NULL;}void ClearQueue(LiQueue *&q){QNode *p=q->front,*r;if (p!=NULL) /*释放数据结点占用空间*/{r=p->next;while (r!=NULL){free(p);p=r;r=p->next;}}free(q); /*释放头结点占用空间*/ }int QueueLength(LiQueue *q){int n=0;QNode *p=q->front;while (p!=NULL){n++;p=p->next;}return(n);}int QueueEmpty(LiQueue *q){if (q->rear==NULL)return 1;elsereturn 0;}void enQueue(LiQueue *&q,ElemType e){QNode *s;s=(QNode *)malloc(sizeof(QNode));s->data=e;s->next=NULL;if (q->rear==NULL) /*若链队为空,则新结点是队首结点又是队尾结点*/q->front=q->rear=s;else{q->rear->next=s; /*将*s结点链到队尾,rear指向它*/q->rear=s;}}int deQueue(LiQueue *&q,ElemType &e){QNode *t;if (q->rear==NULL) /*队列为空*/return 0;if (q->front==q->rear) /*队列中只有一个结点时*/{t=q->front;q->front=q->rear=NULL;}else /*队列中有多个结点时*/{t=q->front;q->front=q->front->next;}e=t->data;free(t);return 1;}第4章串——上机实验题4解析实验题4.1实现顺序串各种基本运算的算法/*文件名:algo4-1.cpp*/#include <stdio.h>#define MaxSize 100 /*最多的字符个数*/typedef struct{ char ch[MaxSize]; /*定义可容纳MaxSize个字符的空间*/ int len; /*标记当前实际串长*/} SqString;void StrAssign(SqString &str,char cstr[]) /*str为引用型参数*/ {int i;for (i=0;cstr[i]!='\0';i++)str.ch[i]=cstr[i];str.len=i;}void StrCopy(SqString &s,SqString t) /*s为引用型参数*/ {int i;for (i=0;i<t.len;i++)s.ch[i]=t.ch[i];s.len=t.len;}int StrEqual(SqString s,SqString t){int same=1,i;if (s.len!=t.len) /*长度不相等时返回0*/same=0;else{for (i=0;i<s.len;i++)if (s.ch[i]!=t.ch[i]) /*有一个对应字符不相同时返回0*/same=0;}return same;}int StrLength(SqString s){return s.len;}SqString Concat(SqString s,SqString t){SqString str;int i;str.len=s.len+t.len;for (i=0;i<s.len;i++) /*将s.ch[0]~s.ch[s.len-1]复制到str*/ str.ch[i]=s.ch[i];for (i=0;i<t.len;i++) /*将t.ch[0]~t.ch[t.len-1]复制到str*/ str.ch[s.len+i]=t.ch[i];return str;}SqString SubStr(SqString s,int i,int j){SqString str;int k;str.len=0;if (i<=0 || i>s.len || j<0 || i+j-1>s.len){printf("参数不正确\n");return str; /*参数不正确时返回空串*/}for (k=i-1;k<i+j-1;k++) /*将s.ch[i]~s.ch[i+j]复制到str*/str.ch[k-i+1]=s.ch[k];str.len=j;return str;}SqString InsStr(SqString s1,int i,SqString s2){int j;SqString str;str.len=0;if (i<=0 || i>s1.len+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return s1;}for (j=0;j<i-1;j++) /*将s1.ch[0]~s1.ch[i-2]复制到str*/str.ch[j]=s1.ch[j];for (j=0;j<s2.len;j++) /*将s2.ch[0]~s2.ch[s2.len-1]复制到str*/str.ch[i+j-1]=s2.ch[j];for (j=i-1;j<s1.len;j++) /*将s1.ch[i-1]~s.ch[s1.len-1]复制到str*/str.ch[s2.len+j]=s1.ch[j];str.len=s1.len+s2.len;return str;}SqString DelStr(SqString s,int i,int j){int k;SqString str;str.len=0;if (i<=0 || i>s.len || i+j>s.len+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return str;}for (k=0;k<i-1;k++) /*将s.ch[0]~s.ch[i-2]复制到str*/str.ch[k]=s.ch[k];for (k=i+j-1;k<s.len;k++)/*将s.ch[i+j-1]~ch[s.len-1]复制到str*/ str.ch[k-j]=s.ch[k];str.len=s.len-j;return str;}SqString RepStr(SqString s,int i,int j,SqString t){int k;SqString str;str.len=0;if (i<=0 || i>s.len || i+j-1>s.len) /*参数不正确时返回空串*/ {printf("参数不正确\n");return str;}for (k=0;k<i-1;k++) /*将s.ch[0]~s.ch[i-2]复制到str*/str.ch[k]=s.ch[k];for (k=0;k<t.len;k++) /*将t.ch[0]~t.ch[t.len-1]复制到str*/str.ch[i+k-1]=t.ch[k];for (k=i+j-1;k<s.len;k++) /*将s.ch[i+j-1]~ch[s.len-1]复制到str*/str.ch[t.len+k-j]=s.ch[k];str.len=s.len-j+t.len;return str;}void DispStr(SqString str){int i;if (str.len>0){for (i=0;i<str.len;i++)printf("%c",str.ch[i]);printf("\n");}}实验题4.2实现链串各种基本运算的算法*文件名:algo4-2.cpp*/#include <stdio.h>#include <malloc.h>typedef struct snode{char data;struct snode *next;} LiString;void StrAssign(LiString *&s,char t[]){int i;LiString *r,*p;s=(LiString *)malloc(sizeof(LiString));s->next=NULL;r=s;for (i=0;t[i]!='\0';i++){p=(LiString *)malloc(sizeof(LiString));p->data=t[i];p->next=NULL;r->next=p;r=p;}}void StrCopy(LiString *&s,LiString *t){LiString *p=t->next,*q,*r;s=(LiString *)malloc(sizeof(LiString));s->next=NULL;s->next=NULL;r=s;while (p!=NULL) /*将t的所有结点复制到s*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}}int StrEqual(LiString *s,LiString *t){LiString *p=s->next,*q=t->next;while (p!=NULL && q!=NULL && p->data==q->data){p=p->next;q=q->next;}if (p==NULL && q==NULL)return 1;elsereturn 0;}int StrLength(LiString *s){int i=0;LiString *p=s->next;while (p!=NULL){i++;p=p->next;}return i;}LiString *Concat(LiString *s,LiString *t){LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;while (p!=NULL) /*将s的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}p=t->next;while (p!=NULL) /*将t的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *SubStr(LiString *s,int i,int j){int k;LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++)p=p->next;for (k=1;k<=j;k++) /*将s的第i个结点开始的j个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *InsStr(LiString *s,int i,LiString *t){int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s)+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return str;}for (k=1;k<i;k++) /*将s的前i个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}while (p1!=NULL) /*将t的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p1->data;q->next=NULL;r->next=q;r=q;p1=p1->next;}while (p!=NULL) /*将*p及其后的结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *DelStr(LiString *s,int i,int j){int k;LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++) /*将s的前i-1个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++) /*让p沿next跳j个结点*/p=p->next;while (p!=NULL) /*将*p及其后的结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *RepStr(LiString *s,int i,int j,LiString *t){int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++) /*将s的前i-1个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++) /*让p沿next跳j个结点*/p=p->next;while (p1!=NULL) /*将t的所有结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p1->data;q->next=NULL;r->next=q;r=q;p1=p1->next;}while (p!=NULL) /*将*p及其后的结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}void DispStr(LiString *s){LiString *p=s->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}第5章数组和稀疏矩阵——上机实验题5解析实验题5.1求5×5阶螺旋方阵/*文件名:exp5-1.cpp*/#include <stdio.h>#define MaxLen 10void fun(int a[MaxLen][MaxLen],int n){int i,j,k=0,m;if (n%2==0) //m=én/2ùm=n/2;elsem=n/2+1;for (i=0;i<m;i++){for (j=i;j<n-i;j++){k++;a[i][j]=k;}for (j=i+1;j<n-i;j++){k++;a[j][n-i-1]=k;}for (j=n-i-2;j>=i;j--){k++;a[n-i-1][j]=k;}for (j=n-i-2;j>=i+1;j--){k++;a[j][i]=k;}}}void main(){int n,i,j;int a[MaxLen][MaxLen];printf("\n");printf("输入n(n<10):");scanf("%d",&n);fun(a,n);printf("%d阶数字方阵如下:\n",n);for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",a[i][j]);printf("\n");}printf("\n");}实验题5.2求一个矩阵的马鞍点/*文件名:exp5-2.cpp*/#include <stdio.h>#define M 4#define N 4void MinMax(int A[M][N]){int i,j,have=0;int min[M],max[N];for (i=0;i<M;i++) /*计算出每行的最小值元素,放入min[0..M-1]之中*/{min[i]=A[i][0];for (j=1;j<N;j++)if (A[i][j]<min[i])min[i]=A[i][j];}for (j=0;j<N;j++) /*计算出每列的最大值元素,放入max[0..N-1]之中*/{max[j]=A[0][j];for (i=1;i<M;i++)if (A[i][j]>max[j])max[j]=A[i][j];}for (i=0;i<M;i++)for (j=0;j<N;j++)if (min[i]==max[j]){printf(" A[%d,%d]=%d\n",i,j,A[i][j]); /*显示马鞍点*/have=1;}if (!have)printf("没有鞍点\n");}void main(){int i,j;int A[M][N]={{9, 7, 6, 8},{20,26,22,25},{28,36,25,30},{12,4, 2, 6}};printf("A矩阵:\n");for (i=0;i<M;i++){for (j=0;j<N;j++)printf("%4d",A[i][j]);printf("\n");}printf("A矩阵中的马鞍点:\n");MinMax(A); /*调用MinMax()找马鞍点*/}实验题5.3求两个对称矩阵之和与乘积/*文件名:exp5-3.cpp*/#include <stdio.h>#define n 4#define m 10int value(int a[],int i,int j){if (i>=j)return a[(i*(i-1))/2+j];elsereturn a[(j*(j-1))/2+i];}void madd(int a[],int b[],int c[n][n]){int i,j;for (i=0;i<n;i++)for (j=0;j<n;j++)c[i][j]=value(a,i,j)+value(b,i,j);}void mult(int a[],int b[],int c[n][n]){int i,j,k,s;for (i=0;i<n;i++)for (j=0;j<n;j++){s=0;for (k=0;k<n;k++)s=s+value(a,i,k)*value(b,k,j); c[i][j]=s;}}void disp1(int a[]){int i,j;for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",value(a,i,j));printf("\n");}}void disp2(int c[n][n]){int i,j;for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",c[i][j]);printf("\n");}}void main(){int a[m]={1,2,3,4,5,6,7,8,9,10};int b[m]={1,1,1,1,1,1,1,1,1,1};int c1[n][n],c2[n][n];madd(a,b,c1);mult(a,b,c2);printf("\n");printf("a矩阵:\n");disp1(a);printf("b矩阵:\n");disp1(b);printf("a+b:\n");disp2(c1);printf("a*b:\n");disp2(c2);printf("\n");}实验题5.4实现稀疏矩阵(采用三元组表示)的基本运算/*文件名:exp5-4.cpp*/#include <stdio.h>#define N 4typedef int ElemType;#define MaxSize 100 /*矩阵中非零元素最多个数*/ typedef struct{ int r; /*行号*/int c; /*列号*/ElemType d; /*元素值*/} TupNode; /*三元组定义*/typedef struct{ int rows; /*行数值*/int cols; /*列数值*/int nums; /*非零元素个数*/TupNode data[MaxSize];} TSMatrix; /*三元组顺序表定义*/void CreatMat(TSMatrix &t,ElemType A[N][N]){int i,j;t.rows=N;t.cols=N;t.nums=0;for (i=0;i<N;i++){for (j=0;j<N;j++)if (A[i][j]!=0){t.data[t.nums].r=i;t.data[t.nums].c=j;t.data[t.nums].d=A[i][j];t.nums++;}}}void DispMat(TSMatrix t){int i;if (t.nums<=0)return;printf("\t%d\t%d\t%d\n",t.rows,t.cols,t.nums);printf("\t------------------\n");for (i=0;i<t.nums;i++)printf("\t%d\t%d\t%d\n",t.data[i].r,t.data[i].c,t.data[i].d); }void TranMat(TSMatrix t,TSMatrix &tb){int p,q=0,v; /*q为tb.data的下标*/tb.rows=t.cols;tb.cols=t.rows;tb.nums=t.nums;if (t.nums!=0){for (v=0;v<t.cols;v++) /*tb.data[q]中的记录以c 域的次序排列*/for (p=0;p<t.nums;p++) /*p为t.data的下标*/if (t.data[p].c==v){tb.data[q].r=t.data[p].c;tb.data[q].c=t.data[p].r;tb.data[q].d=t.data[p].d;q++;}}}int MatAdd(TSMatrix a,TSMatrix b,TSMatrix &c){int i=0,j=0,k=0;ElemType v;if (a.rows!=b.rows || a.cols!=b.cols)return 0; /*行数或列数不等时不能进行相加运算*/c.rows=a.rows;c.cols=a.cols; /*c的行列数与a的相同*/while (i<a.nums && j<b.nums) /*处理a和b中的每个元素*/{if (a.data[i].r==b.data[j].r) /*行号相等时*/{if(a.data[i].c<b.data[j].c) /*a元素的列号小于b 元素的列号*/{c.data[k].r=a.data[i].r;/*将a元素添加到c中*/c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else if (a.data[i].c>b.data[j].c)/*a元素的列号大于b元素的列号*/{c.data[k].r=b.data[j].r; /*将b元素添加到c中*/c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}else /*a元素的列号等于b元素的列号*/{v=a.data[i].d+b.data[j].d;if (v!=0) /*只将不为0的结果添加到c中*/{c.data[k].r=a.data[i].r;c.data[k].c=a.data[i].c;c.data[k].d=v;k++;}i++;j++;}}else if (a.data[i].r<b.data[j].r) /*a元素的行号小于b元素的行号*/{c.data[k].r=a.data[i].r; /*将a元素添加到c中*/c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else /*a元素的行号大于b元素的行号*/{c.data[k].r=b.data[j].r; /*将b元素添加到c中*/c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}c.nums=k;}return 1;}int value(TSMatrix c,int i,int j){int k=0;while (k<c.nums && (c.data[k].r!=i || c.data[k].c!=j))k++;if (k<c.nums)return(c.data[k].d);elsereturn(0);}int MatMul(TSMatrix a,TSMatrix b,TSMatrix &c){int i,j,k,p=0;ElemType s;if (a.cols!=b.rows) /*a的列数不等于b的行数时不能进行相乘运算*/return 0;for (i=0;i<a.rows;i++)for (j=0;j<b.cols;j++){s=0;for (k=0;k<a.cols;k++)s=s+value(a,i,k)*value(b,k,j);if (s!=0) /*产生一个三元组元素*/{c.data[p].r=i;c.data[p].c=j;c.data[p].d=s;p++;}}c.rows=a.rows;c.cols=b.cols;c.nums=p;return 1;}void main(){ElemType a1[N][N]={{1,0,3,0},{0,1,0,0},{0,0,1,0},{0,0,1,1}};ElemType b1[N][N]={{3,0,0,0},{0,4,0,0},{0,0,1,0},{0,0,0,2}};TSMatrix a,b,c;CreatMat(a,a1);CreatMat(b,b1);printf("a的三元组:\n");DispMat(a);printf("b的三元组:\n");DispMat(b);printf("a转置为c\n");TranMat(a,c);printf("c的三元组:\n");DispMat(c);printf("c=a+b\n");MatAdd(a,b,c);printf("c的三元组:\n");DispMat(c);printf("c=a*b\n");MatMul(a,b,c);printf("c的三元组:\n");DispMat(c);}实验题5.5实现广义表的基本运算#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct lnode{ int tag; /*结点类型标识*/ union{ElemType data;struct lnode *sublist;}val;struct lnode *link; /*指向下一个元素*/} GLNode;extern GLNode *CreatGL(char *&s);extern void DispGL(GLNode *g);void Change(GLNode *&g,ElemType s,ElemType t) /*将广义表g中所有原子s 替换成t*/{if (g!=NULL){if (g->tag==1) /*子表的情况*/Change(g->val.sublist,s,t);else if (g->val.data==s) /*原子且data域值为s的情况*/g->val.data=t;Change(g->link,s,t);}}void Reverse(GLNode *&g) /*将广义表g所有元素逆置*/{GLNode *p,*q,*t;t=NULL;if (g!=NULL){p=g;while (p!=NULL) /*将同级的兄弟逆置*/{q=p->link;if (t==NULL){t=p;p->link=NULL;}else{p->link=t;t=p;}p=q;}g=t;p=g;while (p!=NULL){if (p->tag==1)Reverse(p->val.sublist);p=p->link;}}}int Same(GLNode *g1,GLNode *g2) /*判断两个广义表是否相同*/ {int s;if (g1==NULL && g2==NULL) /*均为NULL的情况*/return 1;else if ((g1==NULL && g2!=NULL) || (g1!=NULL && g2==NULL)) /*一个为NULL,另一不为NULL的情况*/return 0;else{s=1;while (g1!=NULL && g2!=NULL && s==1){if (g1->tag==1 && g2->tag==1)/*均为子表的情况*/s=Same(g1->val.sublist,g2->val.sublist);else if (g1->tag==0 && g2->tag==0)/*均为原子的情况*/{if (g1->val.data!=g2->val.data)s=0;}else /*一个为原子,另一为子表的情况*/s=0;g1=g1->link;g2=g2->link;}if (g1!=NULL || g2!=NULL) /*有一个子表尚未比较完时*/s=0;return s;}}ElemType MaxAtom(GLNode *g) /*求广义表g中最大的原子*/{ElemType m=0,m1; /*m赋初值0*/while (g!=NULL){if (g->tag==1) /*子表的情况*/{m1=MaxAtom(g->val.sublist); /*对子表递归调用*/if (m1>m) m=m1;}else{if (g->val.data>m) /*为原子时,进行原子比较*/m=g->val.data;}g=g->link;}return m;}void DelAtom(GLNode *&g,ElemType x) /*删除广义表g中的第一个为x原子*/{GLNode *p=g,*q,*pre;while (p!=NULL){q=p->link;if (p->tag==1) /*子表的情况*/DelAtom(p->val.sublist,x); /*对子表递归调用*/else{if (p->val.data==x) /*为原子时,进行原子比较*/{if (p==g)/*被删结点是本层的第1个结点*/{g=q;free(p); /*释放结pre=g;}else /*被删结{pre->link=q;free(p);}return;}}pre=p;p=q;}}void DelAtomAll(GLNode *&g,ElemType x) /*删除广义表g中的所有为x原子*/{GLNode *p=g,*q,*pre;while (p!=NULL){q=p->link;if (p->tag==1) /*子表的情况*/DelAtomAll(p->val.sublist,x); /*对子表递归调用*/else{if (p->val.data==x) /*为原子时,进行原子比较*/if (p==g)/*被删结点是本层的第1个结点*/{g=q;free(p); /*释放结pre=g;}else /*被删结{pre->link=q;free(p);}}pre=p;p=q;}}void PreOrder(GLNode *g) /*采用先根遍历g*/{if (g!=NULL){if (g->tag==0) /*为原子结点时*/printf("%c ",g->val.data);elsePreOrder(g->val.sublist); /*为子表时*/ PreOrder(g->link);}}void main(){GLNode *g1,*g2,*g3,*g4;char *str1="(a,(a),((a,b)),((a)),a)";char *str2="(a,(b),((c,d)),((e)),f)";char *str3="(a,(a,b),(a,b,c)))";char *str4="(a,(b),((c,d)),((e)),f)";g1=CreatGL(str1);printf("\n");printf(" 广义表g1:");DispGL(g1);printf("\n");printf(" 将广义表g1中所有'a'改为'b'\n");Change(g1,'a','b');printf(" 广义表g1:");DispGL(g1);printf("\n\n");g2=CreatGL(str2);printf(" 广义表g2:");DispGL(g2);printf("\n");printf(" 广义表g2中最大原子:%c\n",MaxAtom(g2));printf(" 将g2的元素逆置\n");Reverse(g2);printf(" 广义表g2:");DispGL(g2);printf("\n\n");printf(" 广义表g1和g2%s\n\n",(Same(g1,g2)?"相同":"不相同"));g3=CreatGL(str3);printf(" 广义表g3:");DispGL(g3);printf("\n");printf(" 删除广义表g3的第一个为'a'的原子\n");DelAtom(g3,'a');printf(" 广义表g3:");DispGL(g3);printf("\n\n");printf(" 删除广义表g3中的所有'a'原子\n");DelAtomAll(g3,'a');printf(" 广义表g3:");DispGL(g3);printf("\n\n");g4=CreatGL(str4);printf(" 广义表g4:");DispGL(g4);printf("\n");printf(" 采用先根遍历g4的结果:");PreOrder(g4);printf("\n\n");}。

数据结构实验(北京石油化工学院 )

数据结构实验(北京石油化工学院 )
void Link::display(LinkList L) {
printf("\n 链表为:\n"); int flag = 1; while(L != NULL) {
printf("%d",flag); printf("---"); printf("%c",L->data); printf(" "); L = L->next; flag++; }
1.硬件环境: PC 机 内存 4G;硬盘 500G
2.软件环境: 操作系统:windows 7 编辑环境:Visual C++6.0
word2007
3. 问题描述, 包括目标、任务、条件和约束的描述。
1. 定义节点 2. 生成一个单链表(正序建立单链表或逆序建立单链表) 3. 单链表中插入一个元素 4. 在单链表中删除一个元素 5. 按序号查找一个元素 6. 按值(关键字)查找一个元素 7. 显示单链表所有元素
Generated by Unregistered Batch DOC & DOCX Converter 2010.2.205.1366, please register!
printf("\n 展示结束!\n"); }//显示
Node *Link::locatenode(LinkList head,char key) {
Generated by Unregistered Batch DOC & DOCX Converter 2010.2.205.1366, please register!
班级:计 111 姓名:李洋宇 1. 设计题目。

中国石油大学数据结构上机实验

中国石油大学数据结构上机实验

《数据结构》实验报告学号2015011512 姓名胡明禹专业数学与应用数学时间2018.4.24一、实验题目实验5 稀疏矩阵的转置二、实验目的1. 稀疏矩阵的压缩存储方法2. 掌握稀疏矩阵的转置算法三、算法设计分析(一)实验内容1.从键盘输入数据,建立稀疏矩阵的三元组顺序存储2.实现稀疏矩阵的转置算法3.输出原矩阵及转置后的矩阵4.实现矩阵的快速转置算法(二)总体设计此处给出主要函数功能、及函数间调用关系的的描述。

例如:①创建稀疏矩阵函数②转置矩阵T函数③快速转置函数④输出函数⑤输出原矩阵和转置函数其功能描述如下:(1)主函数:统筹调用各个函数以实现相应功能Status main()(2)①创建稀疏矩阵函数Status CreateSMatrix(TSMatrix &M){printf("请输入原矩阵:\n");printf("行数、列数:");scanf("%d%d", &M.mu, &M.nu);printf("元素总数:");scanf("%d", &M.tu);printf("输入各个对应压缩值:\n");for (int i = 1; i <= M.tu; ++i)scanf("%d%d%d", &M.data[i].i, &M.data[i].j, &M.data[i].e); return OK;}②转置矩阵T函数Status TransposeSMatrix(TSMatrix M, TSMatrix &T){ int p, q, col;T.mu = M.nu; T.nu = M.mu; T.tu = M.tu;if (T.tu){q = 1;for (col = 1; col <= M.nu; ++col)for (p = 1; p <= M.tu; ++p)if (M.data[p].j == col){T.data[q].i = M.data[p].j;T.data[q].j = M.data[p].i;T.data[q].e = M.data[p].e;++q;}}printf("\n\n稀疏矩阵M转置成功。

〈数据结构〉上机实验指导

〈数据结构〉上机实验指导

〈数据结构〉上机实验指导数据结构是计算机科学中的一门重要课程,它研究的是数据的组织、存储和管理方式,以及对数据进行操作和处理的算法。

上机实验是数据结构课程的重要组成部分,通过实践操作,能够更好地理解和掌握数据结构的基本概念、算法和应用。

在进行〈数据结构〉上机实验之前,首先需要准备实验环境。

通常情况下,我们会使用一种编程语言来实现数据结构的相关操作,比如C++、Java等。

根据自己的实际情况和实验要求,选择一种合适的编程语言,并确保在实验环境中已经正确安装了相应的编译器或解释器。

接下来,我们可以开始进行具体的上机实验了。

下面以链表为例,介绍一下〈数据结构〉上机实验的指导步骤和要求:1. 实验目的:掌握链表的基本概念、操作和应用,理解链表与数组的区别和联系。

2. 实验原理:链表是一种动态数据结构,它由一系列的节点组成,每个节点包含数据和指向下一个节点的指针。

链表的特点是插入和删除操作的时间复杂度为O(1),但是查找操作的时间复杂度为O(n)。

3. 实验步骤:3.1 创建链表:首先,我们需要定义一个链表的结构体,包含数据和指针两个成员变量。

然后,通过动态内存分配来创建链表的节点,并将节点之间通过指针连接起来,形成一个完整的链表。

3.2 插入节点:可以在链表的任意位置插入一个新的节点。

插入节点的操作包括:创建一个新的节点,将新节点的指针指向插入位置的下一个节点,将插入位置的前一个节点的指针指向新节点。

3.3 删除节点:可以删除链表中的任意一个节点。

删除节点的操作包括:将要删除的节点的前一个节点的指针指向要删除的节点的下一个节点,然后释放要删除的节点的内存空间。

3.4 遍历链表:可以通过遍历链表来访问链表中的每一个节点,并对节点进行相应的操作。

遍历链表的操作包括:从链表的头节点开始,依次访问每个节点,直到链表的尾节点。

3.5 查找节点:可以根据节点的值来查找链表中的某一个节点。

查找节点的操作包括:从链表的头节点开始,依次比较每个节点的值,直到找到目标节点或者链表结束。

中国石油大学数据结构上机实验2

中国石油大学数据结构上机实验2

《数据结构》实验报告学号2015011512 姓名胡明禹专业数学与应用数学时间2018320一、实验题目实验2单链表基本操作二、实验目的1.熟练掌握线性表的顺序存储方式下,基本操作的实现算法,巩固和体会单链表操作特点;2.理解体会动态内存申请与释放;3.通过本次实验,熟练掌握C语言指针的使用三、算法设计分析(一)实验内容1.创建一个空的带头结点的单链表2.采用头插法在单链表中插入n个元素3.删除单链表中第i个元素4.实现单链表按关键字查找操作5.计算单链表的表长并输出单链表6.销毁单链表(二)总体设计此处给出主要函数功能、及函数间调用关系的的描述。

例如:1.构造一个空的单链表的函数;2.插入函数;3.删除函数4.查找函数;5.计算并输出函数;6.销毁函数。

其功能描述如下:(1 )主函数:统筹调用各个函数以实现相应功能void mai n()(2)①构造一个空的单链表的函数Status In itList_L(Li nkList &L){L=(LinkList)malloc(sizeof(LNode));// 构造一个空的线性表L f(!L) exit (OVERFLOW);// 存储分配失败L->next=NULL;〃空表长度为Osystem("cls");〃清空屏幕printf("\n\n 初始化成功\n\n\n"); system("PAUSE");〃按任意键继续return OK;}void CreateList_L(LinkList &L){// 创建一个新表int i,count;LinkList p;system("cls");// 清屏printf("\n 输入总结点数:");scanf("%d",&count);printf("\n 输入各个结点数值,每输一个按下回车:\n");for(i = count; i > 0; i--){p = (LinkList)malloc(sizeof(LNode)); scanf("%d",&p->data);p->next = L->next;L-> next = p;〃赋值}system("cls");// 清屏printf("\n 录入成功\n");}②插入函数Status ListInsert_L(LinkList &L, int i, int newnode){// 在顺序线性表L 中第i 个位置之前插入新的元素LinkList p = L;LinkList s;int j = 0;while(p&&j<i-1){p = p->next;++j;}if(!p||j>i-1)//i 插入的位置不合法{printf("error\n");}s = (LinkList)malloc(sizeof(LNode));s->data = newnode;s->next = p->next;// 将p 的后继结点给s 的后继结点p->next = s;// 将s 给p 的后继结点return OK;}③删除函数Status ListDelete_L(LinkList &L, int i){//在顺序线性表L中删除第i个元素,并用e返回其值LinkList p=L;LinkList q;int j=0;while(p->next&&j<i-1)// 如果满足这样的条件{p = p->next;++j;}if(!(p->next)||j>i-1) return ERROR;// 删除位置非法q= p->next;// 将p 的后继结点给qp->next = q->next;// 将q 的后继结点给p 的后继结点printf("\n\n 删除成功\n\n 被删除的结点是:%d\n",q->data); free(q);return OK;}④查找函数Status FindElemList_L(LinkList &L){// 单链表按照关键字查询LinkList p;int i=1,NUMBER;int n=0;p = L->next;printf("\n 输入查询数字:");scanf("%d",&NUMBER);while(p){if(p->data==NUMBER){printf("\n 查询成功!该数字位于结点%d\n",i);n++;}p = p->next;i++;}if(!n){printf("\n 查询失败!未找到该元素!\n");}return OK;}⑤计算并输出函数Status PrintList_L(LinkList &L){// 输出链表m=0;LinkList p;p=L;printf("\n");while(p->next!=NULL)// 当链表非空{p=p->next;printf("%d: %d\n",++m,p->data);// 输出}printf("\n");return OK;}⑥销毁函数Status DestroyList_L(LinkList &L) // 销毁单链表{ LinkList p, q;p=L;while(p){q=p;p=p->next;free(q); // 释放}if(p==NULL)printf("\n 成功,请退出\n\n");elseprintf (” 失败 \n");return OK;}四、实验测试结果及结果分析(一)测试结果(此处给出程序运行截图)'D:\Microsoft Visual Studio\Common\MSDev98\Bin\Debug\hmy_3 27nexe'入成功I 希W'.羊.:-*;-辛吊fi:j ^_ 单— —ic*i3.l wi 6On 冷】•♦•***・*2默#欲譎值:9 • 'O A IA^OW H Vnual Stu4»o \Com«i^rAM$0«vW^rAD<^u9\hn»yJ.2?.ex ,■ ' •WMcp'S V HIO I JwdoXQnvrcrAMSO^v^VBAQ^bvgfmy,業单»<»<»«><> 歩 兀奠 单屢 S 8S —i2c *s 4-u i&7.a年%去的去长为,7 请祐儀泄注・・・12J 15 门7 £ 4Z 人人障九 2r 44u *j 6x a • • •0\Mig5e 々、“2 女u£*OE»M \M5De*^2"d>e0jaE谓捜衽苜槌熨冬•・・ 7 6 L4 9 2匝内,诵怎出清馬任社情辭紈・■!• ■D H \ME M H 七畔叽|细6占说“血射衬翻、伯e 翱诃津《jwbuqmb 」£T ・Ee"(二)结杲分析 成功完成了题冃所要求的插入,删除,查找等基本操作。

数据结构上机实验报告

数据结构上机实验报告

数据结构上机实验报告一、实验目的本次数据结构上机实验的主要目的是通过实际编程操作,深入理解和掌握常见的数据结构及其基本操作,提高解决实际问题的能力和编程技能。

具体目标包括:1、熟练掌握线性表、栈、队列、树、图等数据结构的基本概念和存储方式。

2、学会运用数据结构的相关算法进行数据的插入、删除、查找、排序等操作。

3、培养分析问题、设计算法、编写代码和调试程序的综合能力。

4、增强对数据结构在实际应用中的认识,提高解决复杂问题的思维能力。

二、实验环境1、操作系统:Windows 102、编程环境:Visual Studio 20193、编程语言:C++三、实验内容本次实验共包括以下几个部分:1、线性表的操作实现顺序表和链表的创建、插入、删除、查找和遍历操作。

比较顺序表和链表在不同操作下的性能差异。

2、栈和队列的应用利用栈实现表达式求值。

用队列模拟银行排队系统。

3、树的遍历实现二叉树的先序、中序和后序遍历算法,并输出遍历结果。

构建哈夫曼树,并进行编码和解码操作。

4、图的基本操作用邻接矩阵和邻接表存储图,并实现图的深度优先搜索和广度优先搜索算法。

四、实验步骤及结果1、线性表的操作顺序表的实现:```cppinclude <iostream>using namespace std;define MAXSIZE 100 //顺序表的最大长度class SeqList {private:int dataMAXSIZE; //存储顺序表元素的数组int length; //顺序表的当前长度public:SeqList(){//构造函数,初始化顺序表length = 0;}//插入元素bool insert(int pos, int element) {if (pos < 0 || pos > length || length == MAXSIZE) {return false;}for (int i = length; i > pos; i) {datai = datai 1;}datapos = element;length++;return true;}//删除元素bool remove(int pos) {if (pos < 0 || pos >= length) {return false;}for (int i = pos; i < length 1; i++){datai = datai + 1;}length;return true;}//查找元素int search(int element) {for (int i = 0; i < length; i++){if (datai == element) {return i;}}return -1;}//遍历输出顺序表void traverse(){for (int i = 0; i < length; i++){cout << datai <<"";}cout << endl;}};int main(){SeqList list;listinsert(0, 10);listinsert(1, 20);listinsert(2, 30);listtraverse();listremove(1);listtraverse();int position = listsearch(30);if (position!=-1) {cout <<"元素 30 在位置"<< position << endl;} else {cout <<"未找到元素 30" << endl;}return 0;}```链表的实现:```cppinclude <iostream>using namespace std;class Node {public:int data;Node next;Node(int element) {data = element;next = NULL;}};class LinkedList {private:Node head;public:LinkedList(){head = NULL;}//插入元素void insert(int element) {Node newNode = new Node(element);if (head == NULL) {head = newNode;} else {Node current = head;while (current>next!= NULL) {current = current>next;}current>next = newNode;}}//删除元素void remove(int element) {if (head == NULL) {return;}if (head>data == element) {Node temp = head;head = head>next;delete temp;return;}Node current = head;Node prev = NULL;while (current!= NULL && current>data!= element) {prev = current;current = current>next;}if (current!= NULL) {prev>next = current>next;delete current;}}//查找元素bool search(int element) {Node current = head;while (current!= NULL) {if (current>data == element) {return true;}current = current>next;}return false;}//遍历输出链表void traverse(){Node current = head;while (current!= NULL) {cout << current>data <<"";current = current>next;}cout << endl;}};int main(){LinkedList list;listinsert(10);listinsert(20);listinsert(30);listtraverse();listremove(20);listtraverse();if (listsearch(30)){cout <<"找到元素 30" << endl;} else {cout <<"未找到元素 30" << endl;}return 0;}```性能比较:在插入和删除操作中,顺序表在表头或中间位置操作时需要移动大量元素,时间复杂度较高;而链表只需要修改指针,时间复杂度较低。

KWIC实验报告(C++)

KWIC实验报告(C++)

软件体系结构上机实验报告书中国石油大学(北京)信息学院计算机科学与技术系制订人:周新学号:2008082207指导教师:朱雪峰博士2011年10月27日1、课程实验目的通过KWIC(Key Word in Context)检索系统,对软件体系结构有更加深入的了解和认识。

通过运用几种体系结构,熟悉常见的软件体系结构,并对这几种结构有进一步了解。

2、任务概述用管道过滤器,主程序、子程序,抽象数据类型,隐式调用这四种结构来分别实现KWIC检索系统。

3、实现方法用C++主要实现了两种结构:主程序、子程序结构,抽象数据类型。

(1)KWIC1工程的入口函数int _tmain(int argc, _TCHAR* argv[]){//界面,结构选择cout<<"Input a absolute filename:";char filename[30];cin>>filename;cout<<"Choose KWIC function"<<endl<<"1 is Main Program/Subroutine with Shared Data"<<endl<<"2 is Abstract Data Types"<<endl;int choose=0;cin>>choose;if(1==choose)//主程序和子程序{MainSubroutine mainSub;vector<vector<string> > lines=mainSub.readLines(filename);vector<LINE> lineIndex=mainSub.shiftString(lines);lineIndex=mainSub.firstAlphaSort(lineIndex,lines);mainSub.outPut(lineIndex,lines);}else//抽象收据类型{Lines *lines=new Lines;Input input;Shift *shift=new Shift;FirstAlphaSort alphaSort;Output output;input.readLines(filename,*lines);shift->circularShift(*lines);alphaSort.alphaSort(*shift);output.print(alphaSort);delete shift;delete lines;}return 0;}(2)主程序、子程序结构实现类//从文件中按行读取vector<vector<string> > MainSubroutine::readLines(char* filename){vector<vector<string> > dst;ifstream infile(filename,ios::in);if(!infile){cout<<"open error!"<<endl;exit(0);}char temp[100]="";//存储从文件中读取的行的临时变量//按行读取while(infile.getline(temp,100)){int k=0,j=0;vector<string> line;line.swap(vector<string>());char s[20]="";//存储从行中取字符串的临时变量while(temp[k]!=0){//每个单词的截取条件为下一个字符为空格或者为行的末尾if((temp[k+1]==' '||temp[k+1]==0)&&temp[k]!=' '){s[j]=temp[k];s[j+1]='\0';string ss=s;line.push_back(ss);j=0;}else if(temp[k]==' '){j=0;}else{s[j]=temp[k];j++;}k++;}dst.push_back(line);//将从文件中中读出的行加入到dst中}infile.close();for(int i=0;i<dst.size();i++){for(int j=0;j<dst.at(i).size();j++){cout<<dst[i][j]<<" ";}cout<<endl;}cout<<endl<<endl;return dst;}//循环左移vector<LINE> MainSubroutine::shiftString(vector<vector<string> > srcLines){vector<LINE> shiftLines;for(int row=0;row<srcLines.size();row++){int colnum=srcLines[row].size();//获取每一行的字符串个数//对第row行循环colnum(字符串个数)次,生成循环移位后的colnum 行for(int col=0;col<colnum;col++){LINE linePos;//声明存放一行的行标以及各列的列表的结构体linePos.rowIndex=row;//给行标赋值//循环生成一行的列标for(int colshift=0;colshift<colnum;colshift++){linePos.colIndex.push_back((col+colshift)%colnum);//取模运算}shiftLines.push_back(linePos);}}return shiftLines;}//字母排序vector<LINE> MainSubroutine::firstAlphaSort(vector<LINE> lineIndex,vector<vector<string> > srcLines){vector<vector<char> > firstChar;vector<LINE> dstIndex;for(int row=0;row<srcLines.size();row++){vector<char> firstCharLine;//逐行提取各个字符串的首字母for(int col=0;col<srcLines[row].size();col++){firstCharLine.push_back(srcLines[row][col][0]);}firstChar.push_back(firstCharLine);//}int rowPos=0;int colPos=0;//外面的两层for循环是控制循环次数的//内部的两层for循环是遍历所有的字符串首字母,寻找最小的字母for(int row=0;row<firstChar.size();row++){for(int col=0;col<firstChar[row].size();col++){char min='z';for(int row=0;row<firstChar.size();row++){for(int col=0;col<firstChar[row].size();col++){if(min>=firstChar[row][col]&&''!=firstChar[row][col]){rowPos=row;colPos=col;min=firstChar[row][col];}}}firstChar[rowPos][colPos]=' ';int linePos=0;//在原行矩阵中的位置for(int line=0;line<rowPos;line++){linePos+=srcLines[line].size();}linePos=linePos+colPos;dstIndex.push_back(lineIndex[linePos]);}}return dstIndex;}//按照lineIndex中的字符串的行标和列标输出所有字符串void MainSubroutine::outPut(vector<LINE> lineIndex, vector<vector<string> > srcLines){for(int row=0;row<lineIndex.size();row++){for(int col=0;col<lineIndex[row].colIndex.size();col++){cout<<srcLines[lineIndex[row].rowIndex][lineIndex[row].colIndex[col]]<< " ";}cout<<endl;}cout<<endl;}(3)抽象数据类型结构实现行存储类//增加行//参数:line字符串向量列表void Lines::addLine(vector<string> line){lines.push_back(line);}//从存储结构中获取某一行//参数:lineIndex为获取的行的序号,从0开始//返回获取的行vector<string> Lines::getLine(int lineIndex){return lines[lineIndex];}// 增加字符串//参数:instring为所添加字符串,lineIndex为字符串所在行的序号(从0开始)void Lines::addString(string instring, int lineIndex){lines[lineIndex].push_back(instring);}//获取字符串//参数:lineIndex为行序号,stringIndex为字符串在行中的序号//返回获取的字符串string Lines::getString(int lineIndex,int stringIndex){return lines[lineIndex][stringIndex];}//增加字符//参数:inchar为增加的字符,stringIndex为增加的字符所在的字符串的序号,lineIndex为增加的字符所在的行的序号void Lines::addChar(char inchar, int stringIndex, int lineIndex){lines[lineIndex][stringIndex].push_back(inchar);}//获取字符//参数:lineIndex为行序号,stringIndex为字符串的序号,charIndex为字符的序号//返回获取的字符char Lines::getChar(int lineIndex, int stringIndex, int charIndex){return lines[lineIndex][stringIndex][charIndex];}//获取总的行数int Lines::getLineNum(void){return lines.size();}//获取特定行的字符串个数int Lines::getStringNum(int lineIndex){return lines[lineIndex].size();}输入类void Input::readLines(char* filename, Lines &readLines){// vector<vector<string> > dst;ifstream infile(filename,ios::in);if(!infile){cout<<"open error!"<<endl;exit(0);}char temp[100]="";//存储从文件中读取的行的临时变量int lineIndex=0;//行序号//按行读取while(infile.getline(temp,100)){int k=0,j=0;vector<string> line;line.swap(vector<string>());readLines.addLine(line);char s[20]="";//存储从行中取字符串的临时变量int stringIndex=0;//字符串序号readLines.addString(s,lineIndex);while(temp[k]!=0){if(temp[k]!=' '){readLines.addChar(temp[k],stringIndex,lineIndex);}//每个单词的截取条件为下一个字符为空格或者为行的末尾if(temp[k]==' '&&temp[k+1]!=' '){// readLines.addChar(temp[k],stringIndex,lineIndex);//将该字符串加入到指定行的指定字符串中// readLines.addChar('\0',stringIndex,lineIndex);s[0]='\0';//清空字符串readLines.addString(s,lineIndex);stringIndex++;//字符串序号加1}k++;}lineIndex++;// dst.push_back(line);//将从文件中中读出的行加入到dst中}infile.close();for(int i=0;i<readLines.getLineNum();i++){for(int j=0;j<readLines.getStringNum(i);j++){cout<<readLines.getString(i,j)<<" ";}cout<<endl;}cout<<endl<<endl;}循环左移类//实现所有行的循环移位void Shift::circularShift(Lines srcLines){int lineIndex=0;for(int row=0;row<srcLines.getLineNum();row++){int cols=srcLines.getStringNum(row);for(int col=0;col<cols;col++){vector<string> newLine;lineShift.addLine(newLine);for(int newcol=0;newcol<cols;newcol++){lineShift.addString(srcLines.getString(row,(col+newcol)%cols),lineIndex);}lineIndex++;}}}//获取所有行Lines Shift::getLines(void){return lineShift;}//获取某一行vector<string> Shift::getLine(int lineIndex){return lineShift.getLine(lineIndex);}//获取某一行中某一位置的字符串string Shift::getString(int lineIndex,int stringIndex){return lineShift.getString(lineIndex,stringIndex);}//获取某一行中某一个字符串中的某一位置的字符char Shift::getChar(int lineIndex, int stringIndex, int charIndex){return lineShift.getChar(lineIndex,stringIndex,charIndex);}//获取行数int Shift::getLineNum(void){return lineShift.getLineNum();}//获取某一行的字符串个数int Shift::getStringNum(int lineIndex){return lineShift.getStringNum(lineIndex);}排序类//实现按首字母排序void FirstAlphaSort::alphaSort(Shift srcShiftLines){shiftLines=srcShiftLines;//将传进得Shift对象赋值给成员变量vector<char> firstChar;for(int row=0;row<shiftLines.getLineNum();row++){firstChar.push_back(shiftLines.getChar(row,0,0));//获取首字母}//首字母排序for(int loop=0;loop<firstChar.size();loop++){char min='z';int rowIndex=0;for(int row=0;row<firstChar.size();row++){if(min>=firstChar[row]&&' '!=firstChar[row]){min=firstChar[row];rowIndex=row;}}charSort.push_back(rowIndex);firstChar[rowIndex]=' ';//将找到的最小的字母置为‘’,以便在下一次查找时不再保留}}//首字母排序vector<int> FirstAlphaSort::getCharSort(){return charSort;}//获取行数int FirstAlphaSort::getLineNum(void){return shiftLines.getLineNum();}//按行的序号,将各字符串合并成一个字符串,然后获取一行//lineIndex为行序号string FirstAlphaSort::getLineAsString(int lineIndex){string lineString;for(int strCount=0;strCount<shiftLines.getStringNum(lineIndex);strCount++) {lineString+=shiftLines.getString(lineIndex,strCount)+" ";}lineString+="\0";return lineString;}输出类//按字母表顺序输出void Output::print(FirstAlphaSort sortLines){for(int row=0;row<sortLines.getLineNum();row++){cout<<sortLines.getLineAsString(sortLines.getCharSort()[row])<<endl;}cout<<endl;}4、实验的例程(1)主程序、子程序运行结果1选择的实现结构为主程序、子程序(2)抽象收据类型-------------------------------------------------------------------------------2选择的实现结构为抽象数据类型5、总结通过本次实验,首先对软件体系结构有了更真切的了解,尤其是对管道过滤器结构,主程序、子程序结构,抽象数据类型结构,隐式调用这四种结构的理解更加透彻了。

中国石油大学C语言上机题答案(2013版)答案_最全最详细

中国石油大学C语言上机题答案(2013版)答案_最全最详细

中国石油大学c语言上机题答案大全(2013版)最全最详细1.1 Hello world.让我们用C语言向世界问好。

最早的程序基本是这个样子的:程序一:#include <stdio.h>void main(){printf("Hello world.\n");}程序二:#include <stdio.h>int main(){printf("Hello world.\n");return 0;}上面的程序你任意模仿一个,看看是否可以通过?如果你能通过这个简单的程序,那就让我们继续完成后面的习题吧。

输入:无输出:Hello world.#include<stdio.h>int main(){printf("Hello world.\n");}1.2 Welcome to Beijing.让我们来练习如何显示多行文字。

输入:无输出:就是下面的那段文字。

#include<stdio.h>void main(){printf("Welcome\n");printf("to\n");printf("Beijing.\n");}1.3 练习最简单的printf和scanfprintf函数和scanf函数是C语言中最常用的函数之一,下面让我们练习一下吧。

输入:整型变量x的值。

输出:输出整型变量x对应的十进制、八进制和十六进制形式。

认真观察-1的八进制和十六进制输出,请想想是为什么。

#include <stdio.h>int main(){int x;scanf("%d",&x);printf("x=%d,",x);printf("x=%o,",x);printf("x=%x\n",x);return 0;}1.4 练习两个整数之间的运算背景:基本练习。

数据结构实验报告实验1

数据结构实验报告实验1

数据结构实验报告实验1一、实验目的本次实验的主要目的是通过实际操作和编程实现,深入理解和掌握常见的数据结构,如线性表、栈、队列等,并能够运用所学知识解决实际问题。

二、实验环境本次实验使用的编程环境为Visual Studio 2019,编程语言为C++。

三、实验内容与步骤(一)线性表的实现与操作1、顺序表的实现定义一个固定大小的数组来存储线性表的元素。

实现插入、删除、查找等基本操作。

2、链表的实现定义链表节点结构体,包含数据域和指针域。

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

(二)栈的实现与应用1、栈的实现使用数组或链表实现栈的数据结构。

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

2、栈的应用利用栈实现表达式求值。

(三)队列的实现与应用1、队列的实现使用循环数组或链表实现队列。

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

2、队列的应用模拟银行排队系统。

四、实验结果与分析(一)线性表1、顺序表插入操作:在指定位置插入元素时,需要移动后续元素,时间复杂度为 O(n)。

删除操作:删除指定位置的元素时,同样需要移动后续元素,时间复杂度为 O(n)。

查找操作:可以直接通过索引访问元素,时间复杂度为 O(1)。

2、链表插入操作:只需修改指针,时间复杂度为 O(1)。

删除操作:同样只需修改指针,时间复杂度为 O(1)。

查找操作:需要遍历链表,时间复杂度为 O(n)。

(二)栈1、表达式求值能够正确计算简单的四则运算表达式,如 2 + 3 4。

对于复杂表达式,如(2 + 3) 4,也能得到正确结果。

(三)队列1、银行排队系统模拟了客户的到达、排队和服务过程,能够反映出队列的先进先出特性。

五、实验中遇到的问题及解决方法(一)线性表1、顺序表的空间浪费问题问题描述:当预先分配的空间过大而实际使用较少时,会造成空间浪费。

解决方法:可以采用动态分配空间的方式,根据实际插入的元素数量来调整存储空间。

2、链表的指针操作错误问题描述:在链表的插入和删除操作中,容易出现指针指向错误,导致程序崩溃。

2020年中国石油大学北京网络学院 数据结构-第一次在线作业 参考答案

2020年中国石油大学北京网络学院 数据结构-第一次在线作业 参考答案
C、算法的可行性是指指令不能有二义性
D、以上几个都是错误的
我的答案:D 此题得分:2.5分
6.(2.5分) 下面说法错误的是
A、算法原地工作的含义是指不需要任何额外的辅助空间
B、在相同的规模n下,复杂度O(n)的算法在时间上总是优于复杂度O(2n)的算法
C、所谓时间复杂度是指最坏情况下,估算算法执行时间的一个上界
我的答案:A 此题得分:2.5分
23.(2.5分) 完成在双循环链表结点p之后插入s的操作是( )
A、p^.next:=s ; s^.priou:=p; p^.next^.priou:=s ; s^.next:=p^.next;
B、p^.next^.priou:=s; p^.next:=s; s^.priou:=p; s^.next:=p^.next;
A、P^.NEXT:=H
B、P^.NEXT:= H^.NEXT
C、P:=H
D、P:=H^.NEXT
我的答案:A 此题得分:2.5分
22.(2.5分) 在一个以 h 为头的单循环链中,p 指针指向链尾的条件是()
A、p^.next=h
B、p^.next=NIL
C、p^.next.^next=h
D、p^.data=-1
A、单链表
B、双链表
C、单循环链表
D、带头结点的双循环链表
我的答案:D 此题得分:2.5分
18.(2.5分) 链表不具有的特点是( )
A、插入、删除不需要移动元素
B、可随机访问任一元素
C、不必事先估计存储空间
D、所需空间与线性长度成正比
我的答案:B 此题得分:2.5分
19.(2.5分) 线性表( a1,a2,…,an)以链接方式存储时,访问第i位置元素的时间复杂性为( )

数据结构实验一(完整版)

数据结构实验一(完整版)

数据结构实验一:线性表实验报告#include <string.h>#include <ctype.h>#include <malloc.h> // malloc()等#include <limits.h> // INT_MAX等#include <stdio.h> // EOF(=^Z或F6),NULL#include <stdlib.h> // atoi()#include <io.h> // eof()#include <math.h> // floor(),ceil(),abs()#include <process.h> // exi t()#include <iostream.h> // cout,cin// 函数结果状态代码#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1// #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK等typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSEtypedef int ElemType;#define LIST_INIT_SIZE 10 // 线性表存储空间的初始分配量#define LISTINCREMENT 2 // 线性表存储空间的分配增量struct SqListElemType *elem; // 存储空间基址int length; // 当前长度int listsize; // 当前分配的存储容量(以sizeof(ElemType)为单位)};/**********************************************************/ /* 顺序表示的线性表的基本操作(12个) *//**********************************************************/ Status InitList(SqList &L){ // 操作结果:构造一个空的顺序线性表---------------1L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L.elem)exit(OVERFLOW); // 存储分配失败L.length=0; // 空表长度为0L.listsize=LIST_INIT_SIZE; // 初始存储容量return OK;}Status DestroyList(SqList &L){ // 初始条件:顺序线性表L已存在。

石大数据结构实验报告1

石大数据结构实验报告1

⽯⼤数据结构实验报告1实验⼀1、题⽬:折半法查找有序数组中数据元素。

2、问题描述:分别设计折半查找问题的递归函数,循环结构函数,并设计测试主函数进⾏测试,⾄少包括⼀个查找成功例⼦和⼀个失败例⼦。

3、基本要求:1)将0~9999,10000个有序的整型数据元素放在数组a中。

2)设计折半查找问题的递归函数。

3)设计折半查找问题的循环结构函数。

4)设计测试主程序,4、测试数据:SLNode *head;//定义头指针变量int i,x;ListInitiate(&head);//初始化for(i=0;i<10;i++)//插⼊10个数据元素ListInsert(head,i,2*i);printf("原数据元素输出为:");Listprint(head);//调⽤输出函数,依次输出原数据元素ListDelete(head,4,&x);//删除第5个数据元素printf("\n删除后数据元素输出为:");Listprint(head);//调⽤输出函数,依次输出删除后的数据元素printf("\n");Destroy(&head);//撤销循环单链表5、算法思想:初始化函数:初始化操作前,头指针参数head没有具体的地址值,在初始化操作后,头指针参数head才得到了具体的地址值,⽽这个地址值要返回给调⽤函数,所以,此时头指针参数head要设计成指针类型的指针。

求当前数据元素个数函数:循环前,指针变量p指向头结点,计数变量size等于0;循环的结束条件为p->next!=head,循环中,每次让头指针p指向它的直接后继点,让计数数量size加1;最终函数循环返回数值size。

插⼊函数:使指针p指向第i-1个结点,动带申请⼀个结点存储空间并由指针q 指⽰,把数据元素x的值赋予新结点的数据元素域,最后修改新结点的指针域指向i个结点,并修改i-1结点的指针域使之指向新结点p;循环条件由条件逻辑与组成,其中⼦条件p->next!=head保证指针所指向结点存在,⼦条件j删除函数:使指针p指向第i-1个结点,然后让指针s指向i结点,并把数据元素的数据域值赋予x,最后把第i个结点脱链,并动态释放结点的存储空间;循环条件有三个⼦条件逻辑与组成,其中⼦条件p->next!=head保证第i-1个结点存在,⼦条件p->next->!=head保证第i个结点存在,⼦条件j取数据元素函数:和删除函数基本相同,主要差别是,取数据元素函数的循环的循环条件改为j6、模块划分:1)定义单链表结点的结构体。

国开数据结构(本)数据结构课程实验报告(一)

国开数据结构(本)数据结构课程实验报告(一)

国开数据结构(本)数据结构课程实验报告一、实验目的本实验旨在帮助学生掌握数据结构的基本概念,熟练掌握数据结构的基本操作,进一步提高学生的编程能力和数据处理能力。

二、实验内容1. 数据结构的基本概念在实验中,我们首先介绍了数据结构的基本概念,包括数据的逻辑结构和物理结构,以及数据结构的分类和应用场景。

2. 数据结构的基本操作接着,我们介绍了数据结构的基本操作,包括插入、删除、查找等操作,通过具体的案例和代码演示,让学生理解和掌握这些基本操作的实现原理和方法。

3. 编程实践在实验的第三部分,我们组织学生进行数据结构的编程实践,要求学生通过实际编写代码来实现各种数据结构的基本操作,加深对数据结构的理解和掌握。

三、实验过程1. 数据结构的基本概念在本部分,我们通过课堂讲解和案例分析的方式,向学生介绍了数据结构的基本概念,包括线性结构、树形结构、图形结构等,让学生对数据结构有一个整体的认识。

2. 数据结构的基本操作在这一部分,我们通过具体的案例和代码演示,向学生介绍了数据结构的基本操作,包括插入、删除、查找等操作的实现原理和方法,让学生掌握这些基本操作的具体实现。

3. 编程实践最后,我们组织学生进行数据结构的编程实践,要求他们通过实际编写代码来实现各种数据结构的基本操作,加深对数据结构的理解和掌握,同时也提高了他们的编程能力和数据处理能力。

四、实验结果与分析通过本次实验,学生们对数据结构有了更深入的理解和掌握,他们能够熟练地使用各种数据结构的基本操作,编写出高效、稳定的代码,提高了他们的编程能力和数据处理能力。

五、实验总结本实验对于学生掌握数据结构的基本概念和操作起到了很好的辅助作用,通过实际的编程实践,学生们不仅加深了对数据结构的理解和掌握,同时也提高了他们的编程能力和数据处理能力。

这对于他们今后的学习和工作都具有重要的意义。

六、参考文献1. 《数据结构与算法分析》2. 《数据结构(C语言版)》3. 《数据结构与算法》以上是我对“国开数据结构(本)数据结构课程实验报告”的详细报告,希望能够满足您的要求。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
{
system("cls");//清屏
ElemType i;
char a[1];//1个元素的数组
printf("线性表:\n");
for(i=0;i<La.length;i++)//输出操作循环语句
{
printf("%d\t",La.elem[i]);
}
printf("\n是否重新操作(y或n):");
其功能描述如下:
(1)主函数:统筹调用各个函数以实现相应功能
void main()
(2)
①初始化一个空的顺序表的函数
Status InitList_Sq(SqList &La)
{//构建一个新的的空的表
La.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
*(p+1)=*p;
*q=e;//插入e
++La.length;//表长加一
return OK;
}
⑤顺序表的删除函数:
Status ListDelete_Sq(SqList &La)
{//在顺序线性表中删除第i个元素,并用e返回其值
system("cls");//清屏
int i;
ElemType e;
Status InitList_Sq(SqList &La)
{//构建一个新的的空的表
La.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!La.elem)exit(OVERFLOW);//存储分配失败
La.length=0;//空表长度为0
ElemType *q,*p;
printf("请输入删除数据的位置:\n");
scanf("%d",&i);
if(i<1 || i>La.length) return ERROR;//i值位置删除得不合法
p=&(La.elem[i-1]);//p为删除元素的位置
e=*p;//被删除的元素的值赋给e
q=La.elem+La.length-1;//表尾元素的位置
{
system("cls");//清屏
ElemType e;
ElemType *newbase;
char a[1];//1个元素的数组
printf("请输入:");
scanf("%d",&e);
La.elem[La.length]=e;//给元素进行赋值
++La.length;//表长加一
if(La.length>=La.listsize)//当前存储空间已满,增加分配
{
newbase=(ElemType *)realloc(La.elem,(La.listsize+LISTINCREMENT)*sizeof(ElemType));
La.listsize=LIST_INIT_SIZE;//初始存储容量
return OK;
}//InitList_Sq
Status InitInput_Sq(SqList &La)
{
system("cls");//清屏
ElemType e;
ElemType *newbase;
char a[1];//1个元素的数组
if(!newbase) exit(OVERFLOW);//存储分配失败
La.elem=newbase;//新基址
La.listsize+=LISTINCREMENT;//增加存储容量
}//if
q=&(La.elem[i-1]);//q为插入位置
for(p=&(La.elem[La.length-1]);p>=q;--p)//循环操作,插入位置及之后的元素右移
if(!La.elem)exit(OVERFLOW);//存储分配失败
La.length=0;//空表长度为0
La.listsize=LIST_INIT_SIZE;//初始存储容量
return OK;
}//InitList_Sq
②输入并赋值的函数:
Status InitInput_Sq(SqList &La)
printf("请输入:");
scanf("%d",&e);
La.elem[La.length]=e;//给元素进行赋值
++La.length;//表长加一
if(La.length>=La.listsize)//当前存储空间已满,增加分配
{
newbase=(ElemType *)realloc(La.elem,(La.listsize+LISTINCREMENT)*sizeof(ElemType));
《数据结构》实验报告
学号
2015011512
姓名
胡明禹
专业
数学与应用数学
时间
2018.3.20
一、实验题目
实验1顺序表基本操作
二、实验目的
1. 熟练掌握线性表的顺序存储方式下,基本操作的实现算法,巩固和体会顺序表操作特点;
2. 理解动态内存分配;
3. 通过本次实验,熟练掌握C语言中函数ห้องสมุดไป่ตู้用、参数传递、结构体类型的使用。
for(i=0;i<La.length;i++)//输出操作循环语句
{
printf("%d\t",La.elem[i]);
}
printf("\n是否重新操作(y或n):");
scanf("%s",&a);
if(a[0]=='y')//条件判断语句
printf("\n重新选择\n");
if(a[0]=='n')
{
printf("\n该元素所在位置:%d",i);//找到,则返回其在L中的位序,否则返回0
break;
}
++i;
}
if(i>La.length)//如果i大于表长
printf("\n元素不存在!\n");
printf("\n是否继续查询(y或者n):");
scanf("%s",&a);
if(a[0]=='y')//条件判断语句
{
system("cls");//清屏
char a[2];
ElemType i=1;
ElemType e;
printf("请输入查找数字:\n");
scanf("%d",&e);
while(i<=La.length)//必须查找的位置要小于等于最后一个元素的位置
{
if(e==La.elem[i-1])//遍历查询
if(newbase==NULL) exit(OVERFLOW);//存储分配失败
La.elem=newbase;//新地址
La.listsize+=LISTINCREMENT;//增加存储容量
}
printf("\n创建成功。\n");
printf("\n是否继续创建(y或n):");//一个一个得进行赋值,会在截图里有所体现
printf("\n新表创建完成。\n");
return OK;
}
③顺序表的展示函数:
Status ListOutput_Sq(SqList &La)//展示顺序线性表的函数
{
system("cls");//清屏
ElemType i;
char a[1];//1个元素的数组
printf("线性表:\n");
typedef int ElemType;//元素数据类型
typedef int Status;
typedef struct
{
ElemType *elem;//存储空间基址
int length;//当前长度
int listsize;//当前分配的存储容量(以sizeof(ElemType)为单位)
}SqList;
exit(0);
return OK;
}
④顺序表的插入函数:
Status ListInsert_Sq (SqList &La)//新元素插入的函数
{
system("cls");//清屏
int i;
ElemType e;
ElemType *newbase;
ElemType *q,*p;
printf("请输入插入位置,数字:\n");
ElemType e;
ElemType *newbase;
ElemType *q,*p;
printf("请输入插入位置,数字:\n");
scanf("%d,%d",&i,&e);
if( i<1 || i>La.length +1 ) return ERROR;//i值插入的位置不合法
if(La.length>=La.listsize)//当前存储空间已满,增加分配
相关文档
最新文档