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

合集下载

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

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

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

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

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

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

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

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

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

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

二、实验要求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

《数据结构》实验报告学号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>

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

实验一单链表的基本操作（必做）一、实验目的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");}。

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

《数据结构》实验报告学号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 查找节点：可以根据节点的值来查找链表中的某一个节点。

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

数据结构实训实验报告

一、实验背景数据结构是计算机科学中一个重要的基础学科，它研究如何有效地组织和存储数据，并实现对数据的检索、插入、删除等操作。

为了更好地理解数据结构的概念和原理，我们进行了一次数据结构实训实验，通过实际操作来加深对数据结构的认识。

二、实验目的1. 掌握常见数据结构（如线性表、栈、队列、树、图等）的定义、特点及操作方法。

2. 熟练运用数据结构解决实际问题，提高算法设计能力。

3. 培养团队合作精神，提高实验报告撰写能力。

三、实验内容本次实验主要包括以下内容：1. 线性表（1）实现线性表的顺序存储和链式存储。

（2）实现线性表的插入、删除、查找等操作。

2. 栈与队列（1）实现栈的顺序存储和链式存储。

（2）实现栈的入栈、出栈、判断栈空等操作。

（3）实现队列的顺序存储和链式存储。

（4）实现队列的入队、出队、判断队空等操作。

3. 树与图（1）实现二叉树的顺序存储和链式存储。

（2）实现二叉树的遍历、查找、插入、删除等操作。

（3）实现图的邻接矩阵和邻接表存储。

（4）实现图的深度优先遍历和广度优先遍历。

4. 算法设计与应用（1）实现冒泡排序、选择排序、插入排序等基本排序算法。

（2）实现二分查找算法。

（3）设计并实现一个简单的学生成绩管理系统。

四、实验步骤1. 熟悉实验要求，明确实验目的和内容。

2. 编写代码实现实验内容，对每个数据结构进行测试。

3. 对实验结果进行分析，总结实验过程中的问题和经验。

4. 撰写实验报告，包括实验目的、内容、步骤、结果分析等。

五、实验结果与分析1. 线性表（1）顺序存储的线性表实现简单，但插入和删除操作效率较低。

（2）链式存储的线性表插入和删除操作效率较高，但存储空间占用较大。

2. 栈与队列（1）栈和队列的顺序存储和链式存储实现简单，但顺序存储空间利用率较低。

（2）栈和队列的入栈、出队、判断空等操作实现简单，但需要考虑数据结构的边界条件。

3. 树与图（1）二叉树和图的存储结构实现复杂，但能够有效地表示和处理数据。

数据结构教程上机实验指导第六版

数据结构教程上机实验指导第六版一、引言《数据结构教程上机实验指导》是数据结构课程的实践操作指南，旨在帮助学生通过实际操作加深对理论知识的理解，提高编程技能和解决问题的能力。

本书适用于高等院校计算机专业的学生，也可供数据结构爱好者参考。

二、实验内容本书包含了一系列实验，涵盖了各种常见的数据结构，如数组、链表、栈、队列、树、图等。

每个实验都包括实验目的、实验环境、实验步骤和实验报告四个部分。

1.实验目的：每个实验都有明确的目的，旨在帮助学生掌握特定数据结构的实现方法、操作技巧和性能分析。

2.实验环境：提供了实验所需的环境配置和软件版本，确保学生在合适的环境下进行实验。

3.实验步骤：详细说明了实验的步骤和方法，引导学生逐步完成实验。

4.实验报告：要求学生提交实验报告，包括对实验结果的总结和分析，以及遇到的问题和解决方案。

三、实验示例本书提供了多个实验示例，包括各种数据结构的实现和应用。

以下是一个简单的链表插入操作的示例：假设我们有一个简单的链表，包含节点A、B和C。

现在要求在B 节点后插入一个新的节点D。

按照链表插入操作的规则，我们需要找到B的下一个节点（即C），然后将D连接到C后面即可。

具体步骤如下：（1）创建一个新的节点D；（2）找到B的下一个节点C；（3）将D连接到C后面，即修改C的下一个节点指针指向D；（4）返回链表。

通过这个示例，学生可以更好地理解链表插入操作的原理和实现方法。

四、实验总结通过本书的实验，学生可以加深对数据结构理论知识的理解，提高编程技能和解决问题的能力。

同时，学生还可以通过实践发现自己的不足之处，及时调整学习策略，提高学习效果。

五、参考文献在本书的最后，列出了与数据结构相关的参考文献，包括教材、论文、网站等。

这些参考文献为学生提供了更多的学习资源，有助于他们进一步了解数据结构的相关知识。

六、结语《数据结构教程上机实验指导》是一本非常实用的实践指南，对于学习数据结构的学生来说非常有帮助。

数据结构实验6报告

数据结构实验报告第 6 次实验一、实验目的1．理解栈是操作受限（插入push, 删除pop）的线性表, 受限的是插入删除的位置。

2．在链式存储结构下实现：StackEmpty, Push,Pop, 几个基本操作。

3．通过调用基本操作实现括号匹配算法。

二、实验内容（问题）写一个算法, 识别依次读入的一个字符序列是否为形如‘序列1&序列2’模式的字符序列。

其中序列1和序列2中都不含字符‘&’, 且序列2是序列1的逆序列。

例如, ‘a+b&b+a’是属该模式的字符序列, 而’1+3&3-1’则不是。

测试数据: ’1+3&3-1’; ’a+b+c&c+b+a’; ’a+b+c&c+b’; ’b+c&c+b+a’;提示：利用栈 , 利用已实现的基本操作三、算法描述（给出自然语言描述的算法）1.向后依次扫描字符序列, 如果考察的字符不等于‘&’则入栈, 遇到‘&’则停止。

2.从‘&’后继续扫描, 考察字符的时候, 栈顶元素出栈, 若二者相等, 继续扫描；不等, 模式不成立。

3.扫描结束后, 栈空则模式成立四、详细设计（画流程图）五、程序代码#include<stdio.h>#include<stdlib.h>#define True 1#define False 0#define OK 1#define ERROR 0typedef int status;typedef char ElemType;typedef struct SNode{ElemType data;struct SNode *next;}SNode, *LinkStack;status InitStack(LinkStack &S);int StackEmpty(LinkStack S);status Push(LinkStack &S, ElemType e);status Pop(LinkStack &S, ElemType &e);status Is_Match(ElemType f[20]);main(){ElemType formula[20];int i;for(i=0;i<=3;i++){printf("\n请输入一个字符序列表达式: ");scanf("%s",formula);if(Is_Match(formula)==1) printf(" \n这个表达式符合‘序列1&序列2’模式！\n"); else printf("\n 这个表达式不符合‘序列1&序列2’模式！\n");}return(1);}status InitStack(LinkStack &S){S=NULL;return(OK);}int StackEmpty(LinkStack S){if(S==NULL) return(True);else return(False);}status Push(LinkStack &S, ElemType e){LinkStack p;p=(LinkStack)malloc(sizeof(SNode));if(!p) return(ERROR);p->data=e;p->next=S;S=p;return(OK);}status Pop(LinkStack &S, ElemType &e){LinkStack p;if(!S) return(ERROR);e=S->data;p=S;S=S->next;free(p);return(OK);}status Is_Match(ElemType f[20]){LinkStack St; ElemType *p,c;InitStack(St);p=f;for(;*p!='&';p++){ Push(St,*p);if(!Push(St, *p)) return(ERROR);}p++;for(;*p!='\0';p++){Pop(St,c);if(!Pop(St,c)) return(ERROR);else if(c!=*p) return(ERROR);}if(StackEmpty(St)) return(OK);else return(ERROR);}七、用户手册（教用户怎么用这个程序）用途: 判断字符串是否是“序列1&序列2’模式”用法：启动此程序, 屏幕会提示你输入数据, 输入数据并按下回车键即可。

数据结构上机实验报告

数据结构上机实验报告数据结构上机实验报告1. 实验目的数据结构是计算机科学中非常重要的一门课程，通过本次上机实验，旨在帮助学生巩固和应用所学的数据结构知识，培养学生分析和解决实际问题的能力。

2. 实验背景本次实验涉及到两个常用的数据结构：栈和队列。

栈是一种后进先出（Last In First Out，LIFO）的数据结构，而队列是一种先进先出（First In First Out，FIFO）的数据结构。

通过实验，我们将学习如何使用这两种数据结构来解决实际问题。

3. 实验内容本次实验分为两个部分：栈的应用和队列的应用。

3.1 栈的应用在栈的应用部分，我们将实现一个简单的括号匹配算法。

该算法可以判断一个字符串中的括号是否匹配。

具体实现步骤如下：3.1.1 创建一个栈来存储括号字符；3.1.2 遍历字符串中的每个字符；3.1.3 如果遇到左括号，则将其入栈；3.1.4 如果遇到右括号，则判断栈顶元素是否是对应的左括号；3.1.5 如果栈为空或栈顶元素不是对应的左括号，则括号不匹配；3.1.6 如果栈顶元素是对应的左括号，则将其出栈；3.1.7 遍历完字符串后，如果栈为空，则括号匹配，否则括号不匹配。

通过实现这个算法，我们可以学习到如何使用栈来解决实际问题，并且理解栈的后进先出的特性。

3.2 队列的应用在队列的应用部分，我们将实现一个简单的任务调度算法。

该算法可以模拟多个任务按照一定的优先级进行调度的过程。

具体实现步骤如下：3.2.1 创建一个队列来存储任务；3.2.2 每个任务包含两个属性：任务名称和优先级；3.2.3 向队列中添加任务，并按照优先级进行排序；3.2.4 从队列中取出优先级最高的任务，并执行；3.2.5 执行完任务后，继续从队列中取出下一个优先级最高的任务，并执行，直到队列为空。

通过实现这个算法，我们可以学习到如何使用队列来实现任务调度，并且理解队列的先进先出的特性。

4. 实验结果与分析通过实验，我们成功实现了括号匹配算法和任务调度算法，并得到了正确的结果。

中国石油大学数据结构上机实验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;｝｀｀｀性能比较：在插入和删除操作中，顺序表在表头或中间位置操作时需要移动大量元素，时间复杂度较高；而链表只需要修改指针，时间复杂度较低。

数据库实验上机答案整理-中国石油大学-龚安

数据库实验上机答案整理-中国石油大学-龚安实验四SQL练习2一、实验目的1．掌握索引的建立、删除及使用；2．掌握单表查询、连接查询、嵌套查询和集合查询；3．掌握插入数据、修改数据和删除数据语句的非常用形式。

二、实验学时2学时三、实验内容1．利用Query Analyzer完成以下操作：⑴在预算日期、结算日期和入账日期上分别建立索引，并在查询操作中体会索引的作用。

⑵在完成第2题的查询操作后，删除预算日期、结算日期和入账日期上的索引。

2．利用Query Analyzer完成以下操作：⑴采油一矿二队2016-5-1到2016-5-28有哪些项目完成了预算，列出相应明细。

⑵采油一矿二队2016-5-1到2016-5-28有哪些项目完成了结算，列出相应明细。

⑶采油一矿二队2016-5-1到2016-5-28有哪些项目完成了结算，列出相应的材料费消耗明细。

⑷采油一矿二队2016-5-1到2016-5-28有哪些项目完成了入账，列出相应明细。

⑸列出采油一矿二队2016-5-1到2016-5-28总的预算金额。

⑹列出采油一矿二队2016-5-1到2016-5-28总的结算金额。

⑺列出采油一矿二队2016-5-1到2016-5-28总的入账金额。

⑻列出采油一矿2016-5-1到2016-5-28总的入账金额。

⑼有哪些人员参与了入账操作。

⑽列出2016-5-1到2016-5-28进行了结算但未入账的项目。

⑾列出采油一矿二队的所有项目，按入账金额从高到低排列。

⑿列出有哪些施工单位实施了项目，并计算各单位所有项目结算金额总和。

⒀找出消耗了材料三且消耗超过了2000元的项目，列出相应消耗明细(利用子查询)。

⒁作业公司二队参与了哪些项目。

⒂作业公司一队和二队参与了哪些项目（利用union）。

⒃采油一矿的油井是哪些作业队参与施工的。

3．利用Query Analyzer完成以下操作：⑴建立数据表(包含3个属性列：★施工单位、★年月、◆结算金额)保存各个施工单位每月的结算金额总和。

中国石油大学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.二分法#include <iostream.h>double f(double x);void main(){double a,b,x,ep;a=0;b=5;ep=0.000001;while(b-a>=ep){x=(a+b)/2;if(f(a)*f(x)>0) a=x;else b=x;}x=(a+b)/2;cout<<"the root of f(x) is"<<" "<<x<<endl; }double f(double x){double f1;f1=x*x*x-6*x-1;return f1;}2.牛顿迭代法#include <iostream.h>#include <math.h>double f1(double x);double f2(double x);void main(){int flag,nmax,k;double x,ep,x0;x=2;ep=000001;nmax=200;flag=1;k=1;while(fabs(x-x0)>ep&&(k<nmax)){x0=x;if(fabs(f2(x0))<ep){flag=0;break;}x=x0-f1(x0)/f2(x0);k=k+1;}if(k>=nmax) flag=0;if(flag==0)cout<<"the newton method is failure"<<endl; elsecout<<"the root of f(x) is"<<" "<<x<<endl;}double f1(double x){double f1;f1=x*x*x-3*x-1;return f1;}double f2(double x){double f1;f1=3*x*x-3;return f1;}3.列主元消去法#include<iostream.h>#include<math.h>void main(){static double a[3][3]={{7,8,11},{5,1,-3},{1,2,3}};static double b[3]={-3,-4,1};double ep=0.001;int ip=1;int n=3;double dmax,temp,s;int m,i,j,k;for(k=0;k<=n-2;k++){dmax=fabs(a[k][k]);m=k;for(i=k+1;i<=n-1;i++){if(fabs(a[i][k])>dmax){dmax=fabs(a[i][k]);m=i;}}if(dmax<ep){ip=-1;break;}if(m!=k){for(j=k;j<=n-1;j++){temp=a[k][j];a[k][j]=a[m][j];a[m][j]=temp;}temp=b[k];b[k]=b[m];b[m]=temp;}for(i=k+1;i<=n-1;i++){a[i][k]=a[i][k]/a[k][k];for(j=k+1;j<=n-1;j++){a[i][j]=a[i][j]-a[i][k]*a[k][j];}b[i]=b[i]-a[i][k]*b[k];}}b[n-1]=b[n-1]/a[n-1][n-1];for(i=n-2;i>=0;i--){s=0;for(j=i+1;j<=n-1;j++){s=s+a[i][j]*b[j];}b[i]=(b[i]-s)/a[i][i];}if(ip==-1)cout<<"gauss method is failure"<<endl;elsecout<<"the solution of eqution is "<<b[0]<<","<<b[1]<<","<<b[2]<<endl; }4.LU分解法#include <iostream>#include <fstream>using namespace std;#define N 3int main(){float A[N][N],U[N][N],L[N][N],X[N],Y[N],B[N];float s=0;int i,j,k;cout<<"请输入将要分解的矩阵:"<<endl;for(i=0;i<N;i++) //输入待分解的矩阵for(j=0;j<N;j++)cin>>A[i][j];for(i=0;i<N;i++) //初始化for(j=0;j<N;j++){L[i][j]=0;U[i][j]=0;if(i==j)L[i][j]=1;}for(j=0;j<N;j++) //求U矩阵第一行U[0][j]=A[0][j];for(i=1;i<N;i++)L[i][0]=A[i][0]/U[0][0]; //求L矩阵的第一列for(k=1;k<N;k++) //用k记录化解的行列数，在行和列分解都完成时再进行下一行列的分解{for(j=k;j<N;j++) //本循环将完成行分解的工作{for(int u=0;u<=k-1;u++){s=s+L[k][u]*U[u][j];}U[k][j]=A[k][j]-s;s=0; //每行的和不一致，一行使用完后要置0}for(i=k+1;i<N;i++) //在行分解完成后进行列分解{for(int l=0;l<=k-1;l++){s=s+L[i][l]*U[l][k];}L[i][k]=(A[i][k]-s)/U[k][k];s=0; //每列的和不一致，一行使用完后要置0 }}cout<<endl<<"L"<<endl;for(i=0;i<N;i++){ //输出L Ufor(j=0;j<N;j++)cout<<L[i][j]<<"\t";cout<<endl;}cout<<endl<<"U"<<endl;for(i=0;i<N;i++){for(j=0;j<N;j++)cout<<U[i][j]<<"\t";cout<<endl;}cout<<"请输入矩阵B"<<endl;cout<<endl;for(i=0;i<N;i++)cin>>B[i];Y[0]=B[0]; //求Yfor(k=1;k<N;k++){for(j=0;j<k;j++){s=s+L[k][j]*Y[j];}Y[k]=B[k]-s;s=0;}cout<<endl<<"Y:"<<endl; //输出Yfor(i=0;i<N;i++)cout<<Y[i]<<"\t";cout<<endl;X[N-1]=Y[N-1]/U[N-1][N-1]; //求Xfor(k=N-2;k>=0;k--){for(j=k+1;j<N;j++){s=s+U[k][j]*X[j];}X[k]=(Y[k]-s)/U[k][k];s=0;}cout<<endl<<"X:"<<endl; //输出Xfor(i=0;i<N;i++)cout<<X[i]<<"\t";cout<<endl;system("pause");return 0;}5.追赶法#include <iostream>using namespace std;int main(){double a[15],b[15],c[15],d[15];double t;int i,n;cout<<"请输入 n= ";cin>>n;cout<<endl;cout<<"请输入 b[1],c[1],d[1]:"<<endl;cin>>b[1]>>c[1]>>d[1];cout<<endl;cout<<"输入2行到n-1行 :"<<endl;for(i=2;i<=n-1;i++){cin>>a[i]>>b[i]>>c[i]>>d[i];}cout<<endl;cout<<"请输入 a[n],b[n],d[n]:"<<endl;cin>>a[n]>>b[n]>>d[n];c[1]=c[1]/b[1];d[1]=d[1]/b[1];for(i=2;i<=n-1;i++){t=b[i]-c[i-1]*a[i];c[i]=c[i]/t;d[i]=(d[i]-d[i-1]*a[i])/t;}d[n]=(d[n]-d[n-1]*a[n])/(b[n]-c[n-1]*a[n]);for(i=n-1;i>=1;i--) d[i]=d[i]-c[i]*d[i+1];for(i=1;i<=n;i++)cout<<endl<<"x["<<i<<"]="<<d[i];cout<<endl;return 0;}6.平方根法#include <stdio.h>#include <stdlib.h>#include <math.h>#define EPS 1.0e-8#define N 20double a[N][N], b[N], x[N];int n;int zhuyuan(int row); /* 选主元*/void hangjiaohuan(int row1, int row2); /* 行交换*/ void xiaoyuan(int row); /*消元*/void huidai(); /* 回代*/void main(){printf("请输入方程的维数n!\n n = ");scanf("%d", &n);getchar();printf("\n输入%d行%d列矩阵\n", n, n);for (int i=0; i<n; i++){for (int j=0; j<n; j++)scanf("%lf", &a[i][j]);getchar();}printf("\n输入线性方程组右端项b[%d]: ", n); for (i=0; i<n; i++){scanf("%lf", &b[i]);}getchar();for (i=0; i<n-1; i++){double rowmark = zhuyuan(i); if (rowmark == -1){printf("多解!");system("pause");return;}if (rowmark != i){hangjiaohuan(i, rowmark);}xiaoyuan(i);}huidai();printf("\n线性方程组的解为: "); for (i=0; i<n; i++){printf("x%d=%lf ", i+1, x[i]); }printf("\n");system("pause");}int zhuyuan(int row){double elem = a[row][row];int rowmark = row;for (int i=row+1; i<n; i++){if (elem<a[i][row]){elem = a[i][row];rowmark = i;}}if(fabs(elem) <= EPS){return -1;return rowmark;}void hangjiaohuan(int row1, int row2) {double tmp;tmp = b[row1];b[row1] = b[row2];b[row2] = tmp;for (int j=0; j<n; j++){tmp = a[row1][j];a[row1][j] = a[row2][j];a[row2][j] = tmp;}}void xiaoyuan(int row){for (int i=row+1; i<n; i++){int j=row;double tmp = a[i][j]/a[row][row]; b[i] -= tmp*b[row];for (a[i][j++] = 0; j<n; j++){a[i][j] -= tmp*a[row][j];}}}void huidai(){x[n-1] = b[n-1]/a[n-1][n-1];for (int i=n-2; i>=0; i--){double sum = 0.0;for (int j=i+1; j<n; j++){sum -= a[i][j]*x[j];}x[i] = (b[i]+sum)/a[i][i];}7.G-S迭代法#include<iostream>#include<math.h>void main(){double ep=0.000001;int n=3,ip=1,nmax=200;double c[3][3]={{0,0.2,0.1},{0.2,0,0.1},{0.2,0.4,0}};static double d[3]={0.3,1.5,2};static double x[3]={0.3,1.5,2};int i,j,k;double emax,s;k=0;do{emax=0;for(i=0;i<n;i++){s=d[i];for(j=0;j<n;j++){s=s+c[i][j]*x[j];}if(fabs(s-x[i])>emax)emax=fabs(s-x[i]);x[i]=s;}k=k+1;}while((emax>ep)&&(k<nmax));if(k>=nmax)ip=-1;elseip=1;if(ip==1)printf("the soulation of eqution is %1.10f,%1.10f,%1.10f",x[0],x[1],x[2]);else printf("failure");}8.曲线拟合法#include <iostream>#include <cmath>#define gasvoid main(){static double x[10]={1.36,1.49,1.73,1.81,1.95,2.16,2.28,2.48};static double y[10]={14.094,15.069,16.844,17.378,18.435,19.949,20.963,22.495};int n=8;int m=2;double a[10][10],b[10],z[30];int i,j,k,ip;double s;z[0]=n;for(i=0;i<=2*m-1;i++){s=0;for(k=0;k<=n-1;k++){s=s+pow(x[k],(i+1));}z[i+1]=s;}for(i=0;i<=m;i++){s=0;for(k=0;k<=n-1;k++){s=s+y[k]*pow(x[k],(i));}b[i]=s;}for(i=0;i<=m;i++){for(j=0;j<=m;j++){a[i][j]=z[i+j];}}gas(a,b,m+1,ip,0.000001);if(ip!=-1)printf("%f+%fx+%fx*x",b[0],b[1],b[2]);elseprintf("failure"); }。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

《数据结构》实验报告学号2015011512 姓名胡明禹专业数学与应用数学时间2018.5.8一、实验题目实验6 二叉树的遍历二、实验目的1. 掌握二叉树的存储思想与建立算法2. 掌握二叉树各种遍历方法的实现思想3. 实现二叉链表的递归遍历算法与非递归遍历算法三、算法设计分析（一）实验内容1.从键盘输入数据，建立一颗含有n个结点的二叉树2.从对二叉树进行先序，中序和后序遍历的递归算法实现，输出遍历序列3.实现先序遍历或中序遍历的非递归算法实现（二）总体设计此处给出主要函数功能、及函数间调用关系的的描述。

例如：①先序创建二叉树函数②先序遍历函数③中序遍历函数④后序遍历函数⑤前序遍历非递归算法⑥中序遍历非递归算法其功能描述如下：（1）主函数：统筹调用各个函数以实现相应功能void main()（2）①先序创建二叉树Status CreateBiTree(BiTree &T){char ch;scanf("%c",&ch);if(ch==' ')T=NULL;else{if(!(T = (BiTNode *)malloc(sizeof(BiTNode))))exit(OVERFLOW); T->data = ch;CreateBiTree(T->lchild);CreateBiTree(T->rchild);}return OK;}②先序遍历Status PreOrderTraverse(BiTree T,Status(*Visit)(TElemType e)) {if(T){if(Visit(T->data))if(PreOrderTraverse(T->lchild,Visit))if(PreOrderTraverse(T->rchild,Visit)) return OK;return ERROR;}else return OK;}③中序遍历Status InOrderTraverse(BiTree T,Status(*Visit)(TElemType e)) {if(T){if(InOrderTraverse(T->lchild,Visit))if(Visit(T->data))if(InOrderTraverse(T->rchild,Visit)) return OK;return ERROR;}else return OK;}④后序遍历函数Status PostOrderTraverse(BiTree T,Status(*Visit)(TElemType e)) {if(T){if(PostOrderTraverse(T->lchild,Visit))if(PostOrderTraverse(T->rchild,Visit))if(Visit(T->data))return OK;return ERROR;}else return OK;}⑤先序遍历非递归算法Status IPreOrderTraverse(BiTree T,Status(*Visit)(TElemType e)) {BiTree p;p=T;int NUM=-1;BiTNode *stack[30];while(p||NUM>0){Visit(p->data);NUM++;stack[NUM]=p;p=p->lchild;while(!p&&NUM>-1){p=stack[NUM];NUM--;p=p->rchild;}}return OK;}⑥中序遍历非递归算法Status IInOrderTraverse(BiTree T,Status(*Visit)(TElemType e)) {BiTree p;p=T;int NUM=0;BiTNode *stack[30];while(p||NUM>0){if(p){stack[NUM++]=p;p=p->lchild;}else{NUM--;p=stack[NUM];if(!Visit(p->data)) return ERROR;p=p->rchild;}}return OK;四、实验测试结果及结果分析（一）测试结果（此处给出程序运行截图）（二）结果分析成功完成了题目的基本操作。

五、实验总结附录实验程序代码(该部分请加注释)#include "stdio.h"#include "stdlib.h"#include "malloc.h"#define OK 1#define ERROR 0#define OVERFLOW -1typedef char TElemType;typedef int Status;typedef struct BiTNode{//二叉树的二叉链表存储表示TElemType data; //结点数据struct BiTNode *lchild, *rchild;//左右孩子指针}BiTNode,*BiTree;Status CreateBiTree(BiTree &T){//先序创建二叉树，从键盘输入数据char ch;scanf("%c",&ch);if(ch==' ')T=NULL;else{if(!(T = (BiTNode *)malloc(sizeof(BiTNode))))exit(OVERFLOW); T->data = ch;CreateBiTree(T->lchild);CreateBiTree(T->rchild);}return OK;}Status Visit(TElemType e){putchar(e);return OK;}Status PreOrderTraverse(BiTree T,Status(*Visit)(TElemType e)) {//先序if(T){if(Visit(T->data))if(PreOrderTraverse(T->lchild,Visit))if(PreOrderTraverse(T->rchild,Visit)) return OK;return ERROR;}else return OK;}Status InOrderTraverse(BiTree T,Status(*Visit)(TElemType e)) {//中序if(T){if(InOrderTraverse(T->lchild,Visit))if(Visit(T->data))if(InOrderTraverse(T->rchild,Visit)) return OK;return ERROR;}else return OK;}Status PostOrderTraverse(BiTree T,Status(*Visit)(TElemType e)) {//后序if(T){if(PostOrderTraverse(T->lchild,Visit))if(PostOrderTraverse(T->rchild,Visit))if(Visit(T->data))return OK;return ERROR;}else return OK;}Status IPreOrderTraverse(BiTree T,Status(*Visit)(TElemType e)) {//先序遍历非递归算法BiTree p;p=T;int NUM=-1;BiTNode *stack[30];while(p||NUM>0) //p不为空或栈不为空时循环{Visit(p->data); //打印当前节点NUM++;stack[NUM]=p; //当前节点进栈p=p->lchild; //在左子树上移动while(!p&&NUM>-1) //若左子树为空，则让栈顶元素出栈，并在右子树上寻找直到pCur不为空{p=stack[NUM];NUM--;p=p->rchild;}}return OK;}Status IInOrderTraverse(BiTree T,Status(*Visit)(TElemType e)){ //中序遍历非递归算法BiTree p;p=T;int NUM=0;BiTNode *stack[30];while(p||NUM>0){if(p){stack[NUM++]=p;p=p->lchild;}else{NUM--;p=stack[NUM];if(!Visit(p->data)) return ERROR;p=p->rchild;}}return OK;}void mainmenu() //输出菜单,供用户进行操作选择{printf("1.创建二叉树\n");printf("2.先序遍历的递归\n");printf("3.中序遍历的递归\n");printf("4.后序遍历的递归\n");printf("5.先序遍历的非递归\n");printf("6.中序遍历的非递归\n");printf("0.退出\n");}void main() // 主函数{BiTree T;int choose;while(1){mainmenu();printf("\n请输入你的选择：");scanf("%d",&choose);switch(choose){case 1://在此插入创建二叉树函数system("cls");CreateBiTree(T);system("PAUSE");system("cls");break;case 2://在此插入递归先序遍历函数system("cls");fflush(stdin); PreOrderTraverse(T, Visit); printf("\n");system("PAUSE");system("cls");break;case 3://在此调用递归中序遍历函数system("cls");fflush(stdin); InOrderTraverse(T, Visit); system("PAUSE");system("cls");break;case 4://在此调用递归后序遍历函数system("cls");flush(stdin); PostOrderTraverse(T, Visit); system("PAUSE");system("cls");break;case 5://在此调用非递归先序遍历函数system("cls");fflush(stdin);IPreOrderTraverse(T,Visit);printf("\n");system("PAUSE");system("cls");break;case 6://在此调用非递归中序遍历函数system("cls");fflush(stdin);IInOrderTraverse(T,Visit);system("PAUSE");system("cls");break;case 0://退出exit(0);break;default://输入非法，提示用户重新输入printf("\n输入错误，重新输入！\n"); }}}。