中国石油大学数据结构上机实验8
数据结构上机指导书_实验一
数据结构与算法实验指导书中国石油大学(北京)计算机科学与技术系前言《数据结构》是计算机及相关专业的一门核心基础课程，也是很多高校考研专业课之一。
它主要介绍线性结构、树结构、图结构三种逻辑结构元素的存储实现，在此基础上介绍一些典型算法及时、空效率分析。
这门课程的主要任务是培养学生的算法设计能力及良好的程序设计习惯。
通过学习，要求学生能够掌握典型算法的设计思想及程序实现，能够根据实际问题选取合适的存储方案，设计出简洁、高效、实用的算法，为后续课程的学习及软件开发打下良好的基础。
学习这门课程，习题和实验是两个关键环节。
学生理解算法，上机实验是最佳的途径之一。
因此，实验环节的好坏是学生能否学好《数据结构》的关键。
为了更好地配合学生实验，特编写实验指导书。
一、实验目的更好的理解算法的思想、培养编程能力。
二、实验要求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;}四、实验测试结果及结果分析（一）测试结果（此处给出程序运行截图）（二）结果分析成功完成了题目所要求的插入，删除，查找等基本操作。
数据结构上机实验报告
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 查找节点：可以根据节点的值来查找链表中的某一个节点。
查找节点的操作包括：从链表的头节点开始，依次比较每个节点的值，直到找到目标节点或者链表结束。
中国石油大学数据结构上机实验6
《数据结构》实验报告学号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;四、实验测试结果及结果分析（一）测试结果（此处给出程序运行截图）（二）结果分析成功完成了题目的基本操作。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《数据结构》实验报告学号2015011512 姓名胡明禹专业数学与应用数学时间2018.6.5一、实验题目: 实验八最短路径二、实验目的1. 掌握杰斯特拉算法2. 利用迪杰斯特拉算法计算途中一点到其他各顶点的最短路径三、算法设计分析实验由4个函数共同组成。
其功能描述如下：（1）主函数：统筹调用各个函数以实现相应功能void main()（2）创建有向图的邻接矩阵函数Status CreateDG(MGraph &G){int i,j,k,w;char v1,v2;printf("请输入顶点数和边数：");scanf("%d%d",&G.vexnum,&G.arcnum);printf("\n请按次序输入%d个顶点字母标号(如ABCD等)：",G.vexnum);getchar(); //弹出缓冲区中上次最后出入的换行符，即最后按下的回车键for (i=0;i<G.vexnum;i++)scanf("%c",&G.vexs[i]);getchar(); //弹出缓冲区中上次最后出入的换行符，即最后按下的回车键for (i=0;i<G.vexnum;++i) //初始化邻接矩阵for (j=0;j<G.vexnum;++j){G.arcs[i][j].adj=INFINITY;G.arcs[i][j].info=NULL;}printf("\n输入边的顶点和权值(如A B 1):\n"); //构造邻接矩阵for (k=0;k<G.arcnum;k++){scanf("%c %c %d",&v1,&v2,&w); //输入一条有向边的起点终点和权值i = LocateVex(G,v1); //确定顶点在G中的位置j = LocateVex(G,v2);G.arcs[i][j].adj = w;getchar();//弹出缓冲区中上次最后出入的换行符，即最后按下的回车键 }return OK;}（3）输出邻接矩阵函数Status PrintArcs( MGraph &G){int i;int j;printf("邻接矩阵\n"); //按行序依次输出for ( i = 0; i < G.vexnum; i++ ){for ( j = 0; j < G.vexnum; j++ ){if ( INFINITY == G.arcs[i][j].adj)printf("%6s%","INF");elseprintf("%6d",G.arcs[i][j]);}printf("\n");}return OK;}（4）最短路径函数Status ShortestPath_DIJ(MGraph G, int v0, int p[], int D[]){//求有向网G的V0到其余顶点的最短路径P[v]及其带权长度D[v]//若p[v][w]为TRUE，则w是从v0到v当前求得最短路径上的顶点//final[v]为TRUE当且仅当v∈S，即已经求得从v0到v的最短路径int m,v,i,w,j,k;int min;int final[MAX_VERTEX_NUM];char a[MAX_VERTEX_NUM];for(v=0; v<G.vexnum; ++v){final[v] = FALSE;p[v]=FALSE;D[v] = G.arcs[v0][v].adj;}//forD[v0]=0; final[v0] = TRUE; //初始化，v0属于S//开始主循环，每次求得v0到某个v顶点的最短路径，并加v到S集for(i=1;i<G.vexnum;++i){min = INFINITY;for(w=0;w<G.vexnum;++w)if(!final[w]) //w顶点在V-S中if(D[w]<min) {k=w; min = D[w];} //w离v0更近final[k] = TRUE;for(w=0; w<G.vexnum; ++w) //更新当前最短路径及距离if(!final[w]&&(min+G.arcs[k][w].adj <D[w])){D[w] = min + G.arcs[k][w].adj;p[w] =k;}//if}//forprintf("dijkstra(%c): \n", G.vexs[v0]);for (i = 0; i < G.vexnum; i++){printf(" 最短路径长度(%c, %c)=%d\n", G.vexs[v0], G.vexs[i], D[i]);printf(" 最短路径为：");m=i;j=0;while (m!=v0){a[j]=G.vexs[m];m=p[m];j++;}a[j]=G.vexs[v0];for (m=j;m>=0;m--){printf("%c ", a[m]);}printf("\n");}return OK;}四、实验测试结果及结果分析（一）测试结果（此处给出程序运行截图）四、实验程序代码(该部分请加注释)#include "stdio.h"#include "stdlib.h"#include "malloc.h"#include <limits.h>#define OK 1#define TRUE 1#define FALSE 0#define INFINITY 65535 //最大值无穷#define MAX_VERTEX_NUM 40 //最大顶点个数typedef int InfoType;typedef int VRType;typedef char VertexType;typedef int Status;typedef struct ArcCell{VRType adj;InfoType *info; //该边相关信息的指针}ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];typedef struct{VertexType vexs[MAX_VERTEX_NUM]; //顶点向量AdjMatrix arcs; //邻接矩阵int vexnum,arcnum; //图的顶点数和有向边数}MGraph;int LocateVex(MGraph &G,VertexType ch){//返回顶点在G中顶点向量中的下标值int i;for ( i = 0; G.vexnum; i++ )if ( ch == G.vexs[i] )return i;return -1;}Status CreateDG(MGraph &G){//创建有向图的邻接矩阵int i,j,k,w;char v1,v2;printf("请输入顶点数和边数：");scanf("%d%d",&G.vexnum,&G.arcnum);printf("\n请按次序输入%d个顶点字母标号(如ABCD等)：",G.vexnum); getchar(); //弹出缓冲区中上次最后出入的换行符，即最后按下的回车键for (i=0;i<G.vexnum;i++)scanf("%c",&G.vexs[i]);getchar(); //弹出缓冲区中上次最后出入的换行符，即最后按下的回车键for (i=0;i<G.vexnum;++i) //初始化邻接矩阵for (j=0;j<G.vexnum;++j){G.arcs[i][j].adj=INFINITY;G.arcs[i][j].info=NULL;}printf("\n输入边的顶点和权值(如A B 1):\n"); //构造邻接矩阵for (k=0;k<G.arcnum;k++){scanf("%c %c %d",&v1,&v2,&w); //输入一条有向边的起点终点和权值i = LocateVex(G,v1); //确定顶点在G中的位置j = LocateVex(G,v2);G.arcs[i][j].adj = w;getchar();//弹出缓冲区中上次最后出入的换行符，即最后按下的回车键 }return OK;}Status PrintArcs( MGraph &G){//输出邻接矩阵int i;int j;printf("邻接矩阵\n"); //按行序依次输出for ( i = 0; i < G.vexnum; i++ ){for ( j = 0; j < G.vexnum; j++ ){if ( INFINITY == G.arcs[i][j].adj)printf("%6s%","INF");elseprintf("%6d",G.arcs[i][j]);}printf("\n");}return OK;}Status ShortestPath_DIJ(MGraph G, int v0, int p[], int D[]){//求有向网G的V0到其余顶点的最短路径P[v]及其带权长度D[v]//若p[v][w]为TRUE，则w是从v0到v当前求得最短路径上的顶点//final[v]为TRUE当且仅当v∈S，即已经求得从v0到v的最短路径int m,v,i,w,j,k;int min;int final[MAX_VERTEX_NUM];char a[MAX_VERTEX_NUM];for(v=0; v<G.vexnum; ++v){final[v] = FALSE;p[v]=FALSE;D[v] = G.arcs[v0][v].adj;}//forD[v0]=0; final[v0] = TRUE; //初始化，v0属于S//开始主循环，每次求得v0到某个v顶点的最短路径，并加v到S集for(i=1;i<G.vexnum;++i){min = INFINITY;for(w=0;w<G.vexnum;++w)if(!final[w]) //w顶点在V-S中if(D[w]<min) {k=w; min = D[w];} //w离v0更近final[k] = TRUE;for(w=0; w<G.vexnum; ++w) //更新当前最短路径及距离if(!final[w]&&(min+G.arcs[k][w].adj <D[w])){D[w] = min + G.arcs[k][w].adj;p[w] =k;}//if}//forprintf("dijkstra(%c): \n", G.vexs[v0]);for (i = 0; i < G.vexnum; i++){printf("最短路径长度(%c, %c)=%d\n", G.vexs[v0], G.vexs[i], D[i]);printf(" 最短路径为：");m=i;j=0;while (m!=v0){a[j]=G.vexs[m];m=p[m];j++;}a[j]=G.vexs[v0];for (m=j;m>=0;m--){printf("%c ", a[m]);}printf("\n");}return OK;}void mainmenu() //输出菜单,供用户进行操作选择{printf("\n菜单");printf(" *1.创建有向图邻接矩阵 *\n");printf(" *2.输出邻接矩阵 *\n");printf(" *3.从某点开始到各点的最短路径*\n");printf(" *0.退出 *\n");}void main() // 主函数{MGraph G;int choose;int v0;int p[MAX_VERTEX_NUM]={0};int D[MAX_VERTEX_NUM]={0};while(1){mainmenu();printf("\n请输入你的选择：");scanf("%d",&choose);switch(choose){case 1://在此插入创建有向图邻接矩阵函数system("cls");CreateDG(G);system("PAUSE");system("cls");break;case 2://在此插入输出邻接矩阵函数system("cls");PrintArcs(G);printf("\n");system("PAUSE");system("cls");break;case 3://在此调用从某点开始从某点开始到各点的最短路径求解函数system("cls");printf("请输入开始结点：");scanf("%d",&v0);ShortestPath_DIJ(G,v0,p,D);system("PAUSE");system("cls");break;case 0://退出exit(0);break;default://输入非法，提示用户重新输入printf("\n输入错误，重新输入！\n");}}}。