数据结构实验指导书源代码

合集下载

数据结构上机实验源代码

数据结构上机实验源代码栈的应用十进制数转换为八进制数，逆序输出所输入的数实验代码：//stack.h，头文件class stack{public:stack();bool empty()const;bool full()const;error_code gettop(elementtype &x)const;error_code push(const elementtype x);error_code pop();private:int count;elementtype data[maxlen];};stack::stack(){count=0;}bool stack::empty()const{return count==0;}bool stack::full()const{return count==maxlen;}error_code stack::gettop(elementtype &x)const{if(empty())return underflow;else{x=data[count-1];return success;}}error_code stack::push(const elementtype x){if(full())return overflow;data[count]=x;count++;return success;}error_code stack::pop(){if(empty())return underflow;count--;return success;}//主程序#include<iostream.h>enum error_code{overflow,underflow,success};typedef int elementtype;const int maxlen=20;#include"stack.h"void read_write() //逆序输出所输入的数{stack s;int i;int n,x;cout<<"please input num int n:";cin>>n;for(i=1;i<=n;i++){cout<<"please input a num:";cin>>x;s.push(x);}while(!s.empty()){s.gettop(x);cout<<x<<" ";s.pop();}cout<<endl;}void Dec_to_Ocx(int n) //十进制转换为八进制{stack s1;int mod,x;while(n!=0){mod=n%8;s1.push(mod);n=n/8;}cout<<"the ocx of the dec is:";while(!s1.empty()){s1.gettop(x);cout<<x;s1.pop();}cout<<endl;}void main(){int n;// read_write();cout<<"please input a dec:";cin>>n;Dec_to_Ocx(n);}队列的应用打印n行杨辉三角实验代码：//queue.hclass queue{public:queue(){count=0;front=rear=0;}bool empty(){return count==0;}bool full(){return count==maxlen-1;}error_code get_front(elementtype &x){if(empty())return underflow;x=data[(front+1)%maxlen];return success;}error_code append(const elementtype x){if(full())return overflow;rear=(rear+1)%maxlen;data[rear]=x;count++;return success;}error_code serve(){if(empty())return underflow;front=(front+1)%maxlen;count--;return success;}private:int count;int front;int rear;int data[maxlen];};//主程序#include<iostream.h>enum error_code{overflow,underflow,success};typedef int elementtype;const int maxlen=20;#include"queue.h"void out_number(int n) //打印前n行的杨辉三角{int s1,s2;int i;int j;int k;queue q;for(i=1;i<=(n-1)*2;i++)cout<<" ";cout<<"1 "<<endl;q.append(1);for(i=2;i<=n;i++){s1=0;for(k=1;k<=(n-i)*2;k++)cout<<" ";for(j=1;j<=i-1;j++){q.get_front(s2);q.serve();cout<<s1+s2<<" ";q.append(s1+s2);s1=s2;}cout<<"1 "<<endl;q.append(1);}}void main(){int n;cout<<"please input n:";cin>>n;out_number(n);}单链表实验实验目的:实验目的（1）理解线性表的链式存储结构。

数据结构试验完整代码

数据结构实验完整代码目录一、顺序存储的线性表 (2)二、单链存储的线性表 (4)三、栈 (7)四、队列 (8)五、二叉树的建立和遍历 (10)六、霍夫曼树 (11)七、图的建立和遍历 (17)图的邻接矩阵表示 (17)图的邻接表表示 (20)八、图的最小生成树 (23)九、图的最短路径 (28)十、顺序查找表 (31)十一、二叉排序树的查找 (34)十二、哈希表 (36)十三、插入排序 (41)十四、交换排序-冒泡排序 (44)十五、交换排序-快速排序 (45)十六、简单选择排序 (45)十七、堆排序 (46)一、顺序存储的线性表typedef struct{char name[10];char no[10];double grade;}Student;typedef struct{Student *elem;int length;int listsize;}SqList;void Display(SqList *L){int i;for (i=0;i<L->length ;i++){cout<<i+1<<"：姓名"<<L->elem[i].name<<"，学号："<<L->elem[i].no<<"，成绩："<<L->elem[i].grade <<endl;}cout<<"请选择菜单项：";}SqList *CreateList(){SqList *L;L=(SqList*)malloc(sizeof(SqList));if(!L) cout<<"建立线性表失败！";else cout<<"建立线性表成功！";return(L);}int InitList(SqList *L){int i;char name[10],no[10];double grade;L->elem=(Student *)malloc(ListInitSize * sizeof(Student));if (!(L->elem)) cout<<"初始化表失败！";L->length = 0;L->listsize = ListInitSize;cout<<"请输入要录入信息的学生个数："<<endl;cin>>i;if (i>(L->listsize)){L->elem =(Student *)realloc(L->elem ,i*sizeof(Student));}for (int j=0;j<i;j++){cout<<"请输入第"<<j+1<<"个学生的信息："<<endl;cin>>name>>no>>grade;strcpy((L->elem+L->length)->name,name);strcpy((L->elem+L->length)->no,no);(L->elem+L->length)->grade =grade;L->length ++;}cout<<"信息录入完成！";return 0;}int Insert(SqList *l){Student e;int i,j;Student *newbase;cout<<"请输入要插入的位置：";cin>>j;j--;cout<<"请输入学生信息：";cin>>>>e.no>>e.grade;if(l->length==l->listsize){newbase=(Student*)realloc(l->elem,(l->listsize+ListIncreasement)*sizeof(Studen t));if(!newbase){cout<<"出错!";return 0;}l->elem=newbase;l->listsize+=ListIncreasement;}for(i=l->length;i>=j;i--){l->elem[i+1] = l->elem[i];}l->elem[j]=e;l->length++;cout<<"插入成功！";return 0;}int Delect(SqList *L){int i,j;cout<<"输入删除信息的位置:";cin>>j;j--;cout<<"删除的信息为:姓名："<<L->elem[j].name<<"，学号："<<L->elem[j].no<<"成绩："<<L->elem[j].grade<<endl;for(i=j+1;i<=L->length;i++){L->elem[i-1]=L->elem[i];}L->length--;cout<<"请按回车继续"<<endl;getchar();getchar();cout<<"删除成功！";return 0;}二、单链存储的线性表typedef struct Student{char name[10];char no[10];double grade;}Student;typedef struct LNode{Student data;LNode *next;}LNode,*LinkList;void CreateList(LinkList &l){l=(LinkList)malloc(sizeof(LNode));if (!l) cout<<"建立失败。

数据结构与算法实验源代码

数据结构与算法实验源代码数据结构与算法实验源代码1.实验目的本实验旨在通过实践，加深对数据结构与算法的理解与应用能力，掌握数据结构和算法的基本概念与原理，并能够运用所学知识解决实际问题。

2.实验材料●一台已安装好编译器的计算机●数据结构与算法实验源代码文件3.实验环境配置在实验开始之前，必须确保计算机上已安装好以下环境：●编译器（可以是C++、Java等）●数据结构与算法实验源代码文件4.实验内容及步骤4.1 实验一：线性表4.1.1 实验目的通过实现线性表的相关操作，加深对线性表及其操作的理解，并能够灵活应用。

4.1.2 实验步骤1.实现线性表的初始化函数2.实现线性表的插入操作3.实现线性表的删除操作4.实现线性表的查找操作5.实现线性表的排序操作6.实现线性表的输出操作7.编写测试代码，对线性表进行测试4.1.3 实验结果与分析进行若干测试用例，验证线性表的正确性，并分析算法的时间复杂度与空间复杂度。

4.2 实验二：栈与队列4.2.1 实验目的通过实现栈与队列的相关操作，加深对栈与队列的理解，并掌握栈与队列的应用场景。

4.2.2 实验步骤1.实现栈的初始化函数2.实现栈的入栈操作3.实现栈的出栈操作4.实现栈的查看栈顶元素操作5.实现队列的初始化函数6.实现队列的入队操作7.实现队列的出队操作8.实现队列的查看队首元素操作4.2.3 实验结果与分析进行若干测试用例，验证栈与队列的正确性，并分析算法的时间复杂度与空间复杂度。

（继续添加实验内容及步骤，具体根据实验项目和教学要求进行详细分析）5.实验附件本文档所涉及的实验源代码文件作为附件随文档提供。

6.法律名词及注释6.1 版权：著作权法所规定的权利，保护作品的完整性和原创性。

6.2 开源：指软件可以被任何人免费使用、分发和修改的一种软件授权模式。

（继续添加法律名词及注释）。

数据结构实验二的源代码

#include<stdio.h>#include<math.h>#include<string.h>#include<stdlib.h>#include<ctype.h>//判断是否为字符函数的头文件typedef int elemtype;//声明一个别名char ch[8] = { '+' , '-' , '*' , '/' ,'(' , ')' , '#' }; //把符号转换成字符数组int f1[7] = { 3,3,5,5,1,6,0 }; //栈内元素优先级int f2[7] = { 2,2,4,4,6,1,0 }; //栈外元素优先级int n = 0;typedef struct sqstack//顺序栈结构{elemtype stack[100];int top;}sqstsck;void Initstack(sqstack *s)//初始化{s->top = 0;}void Push(sqstack *s, elemtype x)//入栈{s->top++;s->stack[s->top] = x;}void Pop(sqstack *s, elemtype *x)//出栈{*x = s->stack[s->top];s->top--;}elemtype Gettop(sqstack s)//取栈顶元素{return s.stack[s.top];}elemtype cton(char c)//把操作符转换为相应数字{switch (c){case'+': return 0;case'-': return 1;case'*': return 2;case'/': return 3;case'(': return 4;case')': return 5;default: return 6;}}char Compare(char c1, char c2)//比较字符优先级{int i1 = cton(c1);int i2 = cton(c2); //把字符变成数字if (f1[i1] > f2[i2]) return'>'; //通过原来的设定找到优先级else if (f1[i1] < f2[i2]) return'<';else return'=';}int Operate(elemtype a, elemtype t, elemtype b)//四则运算{int sum;switch (t){case 0: sum = a + b; break;case 1: sum = a - b; break;case 2: sum = a * b; break;default: sum = a / b;}return sum;}int Expression()//主要表达式函数{char c;int i = 0, sum = 0;int k = 1, j = 1; //设置开关变量elemtype x, t, a, b;sqstack OPTR, OPND;Initstack(&OPTR);Push(&OPTR, cton('#')); //‘#’压入栈Initstack(&OPND);c = getchar();while (c != '#' || ch[Gettop(OPTR)] != '#'){if (isdigit(c)) //判断c是否为数字{sum = 0;while (isdigit(c)){if (!j) //j用来进行字符串转换判断，j为0转换{sum = sum * 10 - (c - '0');}else sum = sum * 10 + (c - '0'); //字符c转化成对应数字c = getchar();}Push(&OPND, sum);j = 1;}else if (k){switch (Compare(ch[Gettop(OPTR)], c)){case'<': Push(&OPTR, cton(c)); //把字符整型化，然后压入操作符栈c = getchar();break;case'=': Pop(&OPTR, &x); //操作符栈顶元素出栈c = getchar();break;case'>': Pop(&OPTR, &t); //操作符栈顶元素出栈Pop(&OPND, &b); //操作数栈顶元素出栈Pop(&OPND, &a); //操作数栈顶元素出栈Push(&OPND, Operate(a, t, b));break;}}}return (Gettop(OPND));}void main(){int result;printf("请输入'#'号结束：\n");result =Expression();printf("结果为：%d\n", result);system("color 6");system("pause");}。

《数据结构》实验指导书(源代码)

实验一线性表的链式存储结构一、实验目的：1．掌握线性表的链式存储结构。

2．熟练地利用链式存储结构实现线性表的基本操作。

3．能熟练地掌握链式存储结构中算法的实现。

二、实验内容：1．用头插法或尾插法建立带头结点的单链表。

2．实现单链表上的插入、删除、查找、修改、计数、输出等基本操作。

三、实验要求：1. 根据实验内容编写程序，上机调试、得出正确的运行程序。

2. 写出实验报告（包括源程序和运行结果）。

四、实验学时：2学时五、实验步骤：1．进入编程环境，建立一新文件；2. 参考以下相关内容，编写程序，观察并分析输出结果。

①定义单链表的数据类型，然后将头插法和尾插法、插入、删除、查找、修改、计数、输出等基本操作都定义成子函数的形式，最后在主函数中调用它，并将每一种操作前后的结果输出，以查看每一种操作的效果。

②部分参考程序//单链表的建立(头插法)，插入，删除，查找、修改、计数、输出#include<iostream.h>#define elemtype intstruct link{ elemtype data；//元素类型link *next； //指针类型，存放下一个元素地址};//头插法建立带头结点的单链表link *hcreat(){ link s,p;elemtype i;cout<<”输入多个结点数值(用空格分隔)，为0时算法结束”；cin>>i；p=new link；p->next=NULL；while(i) //当输入的数据不为0时，循环建单链表{s=new link；s->data=i；s->next=p->next；p->next=s；cin>>i； }return p；}//输出单链表void print(1ink *head){1ink *p；p=head->next；while(p->next!=NULL){cout<<p->data<<”->”； //输出表中非最后一个元素p=p->next；}cout<<p->data； //输出表中最后一个元素cout<<endl；}∥在单链表head中查找值为x的结点Link *Locate(1ink *head，elemtype x){Link *p；p=head->next；while((p!=NULL)&&(p->data!=x))p=p->next；return p； }//在head为头指针的单链表中，删除值为x的结点void deletel(1ink *head，elemtype x){1ink *p， *q；q=head；p=head->next；while((p!=NULL)&&(p->data!=x)){q=p；p=p->next；}If(p==NULL) cout<<“要删除的结点不存在”；elseq->next=p ->next；delete(p)；}}//在头指针head所指的单链表中，在值为x的结点之后插入值为y的结点void insert(1ink *head，elemtype x，elemtype y)｛ link *p， *s；s=new link；s->data=y；if(head->next==NULL) //链表为空{head->next=s；s->next=NULL：}p=Locate(head，x)；//调用查找算法‘if(p==NULL)cout<<”插入位置非法”：else(s->next=p->next；p->next=s；}}//将单链表p中所有值为x的元素修改成y void change(1ink *p,elemtype x,elemtype y) {link *q；q=p->next；while(q!=NULL){ if(q->data==x) q->data=y；q=q->next；}}void count(1ink *h) //统计单链表中结点个数{1ink *p；int n=0；p=h->next；while(p!=NULL){n++；p=p->next；}return n;}void main(){ int n；elemtype x，y；link *p， *q；p=hcreat()； //头插法建立链表print(p)； //输出刚建立的单链表cout<<”请输入要删除的元素”；cin>>y；deletel(p，y)；print(p)； //输出删除后的结果cout<<”请输入插入位置的元素值(将待插元素插入到它的后面)”; cin>>x；cout<<”请输入待插元素值”；cin>>y；insert(p，x，y)；print(p)； //输出插入后的结果cout<<”请输入要修改前、后的元素值”;cin>>x>>y；change(p，x，y)；print(p)；cout<<”请输入要查找的元素值”；cin>>x；q=Locate(p，x)；if(q==NULL)cout<<x<<”不在表中，找不到!”<<endl；else cout<<x<<”在表中，已找到!”<<endl；n=count(p)；cout<<”链表中结点个数为：”<<n<<endl：}//单链表的建立(尾插法)、插入、删除、查找、修改、计数、输出#include<iostream.h>#define elemtype intstruct link{ elemtype data；//元素类型link *next；//指针类型，存放下-个元素地址}；//尾插法建立带头结点的单链表link *rcreat(){link *s， *p， *r；elemtype i；cout<<”输入多个结点数值(用空格分隔)，为0时算法结束”； cin>>i;p=r=new link；p->next=NULL；while(i){s=new link；s->data=i；r->next=s；r=s；cin>>i； }r->next=NULL；return p；}//输出单链表void print(1ink *head){link *p；p=head->next；while(p->next!=NULL){cout<<p->data<<"->”; //输出表中非最后一个元素p=p->next；)cout<<p->data； //输出表中最后一个元素cout<<endl；}link *Locate(1ink *head，int x) ∥在单链表中查找第x个结点 {link *p；p=head；int j=0；while((p!=NULL)&&(j<x)){p=p->next; j++；}return p；}void delete I(1ink *head，elemtype x)//在head为头指针的单链表中，删除值为x的结点{link *p, *q；q=head；p=head->next；while((p!=NULL)&&(p->data!=x)){q=p；p=p->next；)if(p==NULL)cout<<”要删除的结点不存在“;else{q->next=p->next；delete(p)；} }void insert(1ink *head，int x,elemtype y)//在头指针head所指单链表中，在第x个结点之后插入值为y的结点{link *p， *s；s=new link；s->data=y；if(head->next==NULL)//链表为空{head->next=s；s->next=NULL：}p=Locate(head，x)； //调用查找算法if(p==NULL)cout<<”插入位置非法”;else{s->next=p->next；p->next=s；}}void change(1ink *p,elemtype x，elemtype y){∥将单链表P中所有值为x的元素改成值为ylink *q；q=p->next；while(q!=NULL){if(q->data==x)q->data=y；q=q->next；}}void count(1ink *h) //统计单链表中结点个数(1ink *p；int n=0；p=h->next；while(p!=NULL){n++；p=p->next；}retum n;}void main(){ int n;link p,q;p=rcreat()；//尾插法建立链表print(p)； //输出刚建立的单链表cout<<”请输入要删除的元素”；cin>>y；deletel(p，y)；print(p)； //输出删除后的结果cout<<”请输入插入位置”;cin>>x；cout<<”请输入待插元素值”；cin>>y；insert(p，x，y)；print(p)； //输出插入后的结果cout<<”请输入修改前、后的元素值”;cin>>x>>y；change(p，x，y)；print(p)；cout<<“请输入要查找的元素值”;cin>>x；q=Locate(p ,x)；if(q==NULL)cout<<x<<”不在表中,找不到!”<<endl；else cout<<x<<”在表中，已找到!”<<endl；n=count(p)；cout<<”链表中结点个数为：”<<n<endl;}六、选作实验试设计一元多项式相加（链式存储）的加法运算。

数据结构课本算法源代码

void Union(List &La, List Lb) { // 算法2.1// 将所有在线性表Lb中但不在La中的数据元素插入到La中int La_len,Lb_len,i;ElemType e;La_len = ListLength(La); // 求线性表的长度Lb_len = ListLength(Lb);for (i=1; i<=Lb_len; i++) {GetElem(Lb, i, e); // 取Lb中第i个数据元素赋给eif (!LocateElem(La, e, equal)) // La中不存在和e相同的数据元素ListInsert(La, ++La_len, e); // 插入}} // unionvoid MergeList(List La, List Lb, List &Lc) { // 算法2.2// 已知线性表La和Lb中的元素按值非递减排列。

// 归并La和Lb得到新的线性表Lc，Lc的元素也按值非递减排列。

int La_len, Lb_len;ElemType ai, bj;int i=1, j=1, k=0;InitList(Lc);La_len = ListLength(La);Lb_len = ListLength(Lb);while ((i <= La_len) && (j <= Lb_len)) { // La和Lb均非空GetElem(La, i, ai);GetElem(Lb, j, bj);if (ai <= bj) {ListInsert(Lc, ++k, ai);++i;} else {ListInsert(Lc, ++k, bj);++j;}}while (i <= La_len) {GetElem(La, i++, ai); ListInsert(Lc, ++k, ai);}while (j <= Lb_len) {GetElem(Lb, j++, bj); ListInsert(Lc, ++k, bj);}} // MergeListStatus InitList_Sq(SqList &L) { // 算法2.3// 构造一个空的线性表L。

数据结构实验指导书源程序附件

附录：实验源程序实验一、线性表操作程序1：顺序存储的线性表和运算#include<stdio.h>#define MAXSIZE 100int list[MAXSIZE];int n;/*insert in a seqlist*/int sq_insert(int list[], int *p_n, int i, int x){int j;if (i<0 || i>*p_n) return(1);if (*p_n==MAXSIZE) return(2);for (j=*p_n+1; j>i; j--)list[j]=list[j-1];list[i]=x;(*p_n)++;return(0);}/*delete in a seq list*/int sq_delete(int list[], int *p_n, int i){int j;if (i<0 || i>=*p_n) return(1);for (j = i+1; j<=*p_n; j++)list[j-1] = list[j];(*p_n)--;return(0);}void main(){int i,x,temp;printf("please input the number for n\n");printf("n=");scanf("%d",&n);for (i=0; i<=n; i++){printf("list[%d]=",i);scanf("%d",&list[i]);}printf("The list before insertion is\n");for (i=0; i<=n; i++) printf("%d ",list[i]);printf("\n");printf("please input the position where you want to insert a value\nposition=");scanf("%d",&i);printf("please input the value you want to insert.\nx=");scanf("%d",&x);temp=sq_insert(list,&n,i,x);switch(temp){case 0:printf("The insertion is successful!\n");printf("The list is after insertion is\n");for(i=0; i<=n; i++) printf("%d ",list[i]);printf("\n");printf("%d\n",n);break;case 1:case 2:printf("The insertion is not successful!\n");break;}/*deleting*/printf("The list before deleting is\n");for (i=0; i<=n; i++) printf("%d ",list[i]);printf("\n");printf("please input the position where you want to delete a value\nposition=");scanf("%d",&i);temp=sq_delete(list,&n,i);switch(temp){case 0:printf("The deleting is successful!\n");printf("The list is after deleting is\n");for(i=0; i<=n; i++) printf("%d ",list[i]);printf("\n");printf("%d",n);break;case 1:printf("The deleting is not successful!");break;}}程序2链式存储的线性表和运算#include<stdio.h>#include<malloc.h>struct node{char data;struct node *next;};typedef struct node NODE;/*This function creates a link_list with N nodes.*/NODE *create_link_list(int n){int i;NODE *head, *p, *q;if (n==0) return NULL;head = (NODE *) malloc(sizeof(NODE));p = head;printf("Please input %d chars for the link list\n",n);for (i=0; i<n; i++){scanf("%c ", &(p->data));q=(NODE *)malloc(sizeof(NODE));printf("test3\n");p->next=q;p=q;}scanf("%c ",&(p->data));getchar();p->next=NULL;return (head);}/*This function inserts a node whose value is b*//*before the node whose value is a, if the node is not exist,*/ /*then insert it at the end of the list*/void insert(NODE **p_head, char a, char b){NODE *p, *q;q = (NODE *)malloc(sizeof(NODE));q->data = b;q->next =NULL;if (* p_head == NULL) * p_head = q;else{p=(NODE*)malloc(sizeof(NODE));p = * p_head;while (p->data != a && p->next != NULL)p = p->next;q->next = p->next;p->next = q;}}/*The function deletes the node whose value is a,*//*if success, return 0, or return 1*/int deletenode(NODE **p_head, char a){NODE *p, *q;q=*p_head;if (q==NULL) return(1);if (q->data == a){* p_head = q->next;free(q);return (0);}else{while (q->data != a && q->next != NULL){p = q;q = q->next;}if (q->data == a){p->next = q->next;free(q);return(0);}else return(1);}}void main(){ NODE *my_head,*p;/* create a link list with m nodes */int m;char ch_a,ch_b;printf("please input the number of nodes for the link_list\nm=");scanf("%d",&m);getchar();printf("test1\n");my_head = (NODE *) malloc(sizeof(NODE));my_head=create_link_list(m);/*Output the link list*/printf("The link list is like:\n");p=my_head;while (p != NULL){printf("%c ",p->data);p=p->next;}printf("\n");/*insert a node whose value is b before a*/printf("Please input the position for a\n ch_a=");getchar();scanf("%c",&ch_a);getchar();printf("Please input the value that you want to insert\n ch_b=");scanf("%c",&ch_b);getchar();insert(&my_head,ch_a,ch_b);printf("The link list after insertion is like:\n");p=my_head;while (p != NULL){printf("%c ",p->data);p=p->next;}printf("\n");/*delete a node whose value is a*/printf("Please input the position for a a=");scanf("%c",&ch_a);getchar();deletenode(&my_head,ch_a);printf("The link list after deleting is like:\n");p=my_head;while (p != NULL){printf("%c ",p->data);p=p->next;}printf("\n");}实验二、栈和队列的应用程序1：顺序栈的实现和运算#include<stdio.h>#define MAXN 26char stack[MAXN];int top=0;int push(char x){if (top >= MAXN)return(1);stack[top++]=x;return(0);}int pop(char *p_y){if (top == 0)return(1);*p_y = stack[--top];return(0);}void main(){ int i;char ch_x,ch_y;printf("input the char you want to push\n");scanf("%c",&ch_x);while(ch_x!='0')if (push(ch_x)==1) printf("failure!\n");else{printf("success!\n");printf("input a char for ch_x to push\nch_x=");getchar();scanf("%c",&ch_x);}i=0;while(stack[i]!='\0'){printf("%c ", stack[i]);i++;}if (pop(&ch_y)==1) printf("failure!\n");else{printf("success!\n");printf("The pop char is %c\n",ch_y);} for (i=top-1; i>=0; i--)printf("%c ", stack[i]);}程序2：链栈的实现和运算#include <stdio.h>#include <malloc.h>struct node{char data;struct node *link;};typedef struct node NODE;NODE * top = NULL;void push_l(char x){NODE *p;p = (NODE * )malloc(sizeof(NODE));p->data = x;p->link = top;top = p;}int pop_l(char *p_y){NODE *p;if (top == NULL)return(1);* p_y = top->data;p = top;top = top->link;free(p);return(0);}void main(){ NODE *p;char ch_x,ch_y;printf("input the char you want to push\n");scanf("%c",&ch_x);while(ch_x!='0'){push_l(ch_x);getchar();scanf("%c",&ch_x);}p=(NODE*)malloc(sizeof(NODE));p=top;while(p!=NULL){printf("%c ",p->data);p=p->link;}printf("\n");if (pop_l(&ch_y)==1) printf("failure!\n");else{printf("success!\n");printf("The pop char is %c\n",ch_y);}p=(NODE*)malloc(sizeof(NODE));p=top;while(p!=NULL){printf("%c ",p->data);p=p->link;}printf("\n");}程序3：顺序队列的实现和运算#include<stdio.h>#define MAXN 26char q[MAXN];int head = -1, tail = -1;int en_queue(char x ){if (tail == MAXN-1)return(1);q[++tail] = x;return(0);}int de_queue(char *p_y ){if (head == tail)return(1);*p_y = q[++head];return(0);}void main(){ int i;char ch_x,ch_y;printf("input the char you want to enqueue\n");scanf("%c",&ch_x);while(ch_x!='0')if (en_queue(ch_x)==1) printf("failure!\n");else{printf("success!\n");printf("input a char for ch_x to enqueue\nch_x=");getchar();scanf("%c",&ch_x);}i=1;while(q[i]!='\0'){printf("%c ", q[i]);i++;}if (de_queue(&ch_y)==1) printf("failure!\n");else{printf("success!\n");printf("The dequeue char is %c\n",ch_y);}for (i=head+1; i<=tail; i++)printf("%c ", q[i]);}程序4：链式队列的实现和运算#include<stdio.h>#include<malloc.h>"struct node{char data;struct node * link;};typedef struct node NODE;NODE *head, *tail;void en_queue_l(char x){NODE *p;p = (NODE *)malloc(sizeof(NODE));p->data = x;p->link = NULL;if (head == NULL)head = p;elsetail->link = p;tail = p;}int de_queue_l(char *p_y){NODE *p;if (head == NULL)return(1);*p_y = head->data;p = head;head = head->link;free(p);return(0);}void main(){ NODE *p;char ch_x,ch_y;printf("input the char you want to enqueue\n");scanf("%c",&ch_x);while(ch_x!='0'){en_queue_l(ch_x);getchar();scanf("%c",&ch_x);}p=(NODE*)malloc(sizeof(NODE));p=head;while(p!=NULL){printf("%c ",p->data);p=p->link;}printf("\n");if (de_queue_l(&ch_y)==1) printf("failure!\n");else{printf("success!\n");printf("The dequeue char is %c\n",ch_y);} p=(NODE*)malloc(sizeof(NODE));p=head;while(p!=NULL){printf("%c ",p->data);p=p->link;}printf("\n");}程序5：循环队列的实现和运算#include<stdio.h>#include<string.h>#define MAXN 26char q[MAXN];int head = 0, tail = 0;int en_c_q(char x){tail = (tail + 1) % MAXN;if (tail == head){if (tail == 0) tail = MAXN-1;else tail--;return(1);}q[tail] = x;return(0);}int de_c_q(char *p_y){if (head == tail)return(1);head = (head+1) % MAXN;*p_y = q[head];return(0);}void main(){ int i;char ch_x,ch_y;printf("input the char you want to enqueue\n");scanf("%c",&ch_x);while(ch_x!='0')if (en_c_q(ch_x)==1) printf("failure!\n");else{printf("success!\n");printf("input a char for ch_x to enqueue\nch_x=");getchar();scanf("%c",&ch_x);}i=1;while(q[i]!='\0'){printf("%c ", q[i]);i++;}if (de_c_q(&ch_y)==1) printf("failure!\n");else{printf("success!\n");printf("The dequeue char is %c\n",ch_y);}for (i=head+1; i<=tail; i++)printf("%c ", q[i]);}实验三、多维数组和串程序1：稀疏矩阵的存储及转置运算#include <stdio.h>typedef struct {int row ;int col ;int val ;}THA ;#define MAX 20main( ){ int i, j, count=1 ;int col, row, val ;THA s[MAX];THA t[MAX];printf("input the number of row ,col and elements:"); scanf("%d,%d,%d",&s[0].row,&s[0].col,&s[0].val);if(s[0].val==0) return ;val =s[0].val;for(i=1;i<=val;i++);scanf("%d,%d,%d",&s[i].row,&s[i].col,&s[i].val);row = s[0].row ;col= s[0].col ;count=1 ;for( i=1; i<= col ; i++)for ( j=1; j<=val ; j++)if (s[j].col==i){t[count].row = s[j].col;t[count].col = s[j].row;t[count++].val = s[j].val;}t[0].row = col ;t[0].col = row ;t[0].val = val ;for(i=0;i<=val;i++)printf("%d,%d,%d\n",t[i].row,t[i].col,t[i].val); }程序2：串的实现和运算#include <stdio.h>#define MAXN 128typedef enum {fail,success} status;typedef enum {false,true} boolean;main(){ int strlen();void strass();boolean strcmp();status strcat( );status strins();void patmatch();int t,n,i;boolean b;status st;char s[MAXN],s1[MAXN],s2[MAXN];printf("\n1. The length of string\n");printf(" 2. The assignment of string\n");printf(" 3. A string compare with another string:\n");printf(" 4. A string connect with another string:\n");printf(" 5. A string to be inserted into another string\n"); printf(" 6. The pattern match of string :");printf(" Please input a opertation:");scanf("%d",&t);switch(t){ case 1:printf("please input a string:\n");getchar();gets(s);n=strlen(s);printf("the length is: %d",n);break;case 2:printf("please input the first string:\n");getchar();gets(s1);printf("please input the second string:\n");getchar();gets(s2);strass(s1,s2);break;case 3:printf("please input the first string:\n");getchar();gets(s1);printf("please input the second string: \n");gets(s2);b=strcmp(s1,s2);if (b==true)printf("equal\n");elseprintf("not equal\n");break;case 4:printf("please input the first string:\n");getchar();gets(s1);printf("please input the second string:\n");gets(s2);st=strcat(s1,s2);if(st==success)printf("answer is %s\n",s1);elseprintf("error!\n");break;case 5:printf("please input the first string:\n");getchar();gets(s1);printf("please input the second string:\n");gets(s2);printf("please input i:");scanf("%d",&i);st=strins(s1,i,s2);if(st==success)printf("answer is %s\n",s1);else printf("error!\n");break;case 6:patmatch();break;default: printf("There isn't this operation!"); }}int strlen(s)char s[];{ int i;for(i=0;s[i]!='\0';i++);return (i);}void strass(s1,s2)char s1[],s2[];{ int i=0;while(s1[i]!='\0'){ s2[i]=s1[i];i++;}s2[i]='\0';printf("s2 is %s",s2);}boolean strcmp(s1,s2)char s1[],s2[];{ int i=0;while (s1[i]==s2[i] && s1[i]!='\0' && s2[i]!='\0') i++;if (s1[i]=='\0' && s2[i]=='\0')return (true);elsereturn (false);}status strcat (s1,s2)char s1[],s2[];{ int i,j,k;i=strlen(s1);j=strlen(s2);if((i+j)>=MAXN)return(fail);for(k=0;k<=j;k++)s1[i+k]=s2[k];return (success);}status strins (s1,i,s2)char s1[],s2[];int i;{ int m,n,k;m=strlen(s1);n=strlen(s2);if (i<0||i>m||(m+n)>MAXN )return (fail) ;for(k=m;k>=i;k--)s1[k+n]=s1[k];for(k=0;k<n;k++)s1[i+k]=s2[k];return (success);}int smatch(ch,n,pat,m)char ch[],pat[];int n,m;{ int s,p,k;for(s=0;s<=n-m;s++){for(p=0,k=s;p<m&&ch[k]==pat[p];k++,p++);if(p==m)return(s+1);}return(-1);}void patmatch(){ char ch[MAXN],pat[MAXN];int n,m, result;printf("\ninput the primary string:\n");scanf("%s",ch);printf("input the pattern string:\n");scanf("%s",pat);n=strlen(ch);m=strlen(pat);result=smatch(ch,n,pat,m);if(result==-1)printf("\nNo matched found!");else if(result>=0) printf("\nMatched sub string found in position %d",result); }实验四、树和二叉树的操作程序1：二叉树的实现和运算#include <stdio.h>#include <stdlib.h>#include <malloc.h>typedef struct btnode{char data; /*suppose the data field's type is char*/struct btnode *lchild; /*left pointer field */struct btnode *rchild; /*right pointer field */}NODE;void main(){ NODE *root,*q,n;NODE *create(NODE *p);void preorder(NODE *root);void inorder(NODE *root);void postorder(NODE *root);int t;q=&n;root=create(q);printf("At the first,we create a tree\n");printf("Please input nodes of tree\n");if (root==NULL) printf("It's an empty tree!\n");else{printf("\n1.The preordetraverse \n");printf(" 2.The inordertraverse \n");printf(" 3.The postordertraverse \n");printf(" Please choose a kind of order\n");scanf("%d",&t);switch (t){case 1: preorder(root); break;case 2: inorder(root); break;case 3:postorder(root); break;default: printf(" The error!");}}}NODE * create(NODE *p) /*create the structure of binary tree */ { char ch;NODE *t;scanf("%c",&ch);if(ch==' ') p=NULL;else{p->data=ch;t=(NODE *)malloc(sizeof(NODE));p->lchild=create(t);t=(NODE*)malloc(sizeof(NODE));p->rchild=create(t);}return p;}void preorder(NODE *root) /*travel the tree using preorder */ { if (root!=NULL){ printf( " %c", root->data);preorder(root->lchild);preorder(root->rchild);}return;}void inorder (NODE *root) /*travel the tree using inorder */ { if (root!=NULL){ inorder(root->lchild);printf(" %c ", root->data);inorder(root->rchild);}return;}void postorder(NODE *root) /*travel the tree using postorder */{ if (root!=NULL){ postorder (root->lchild);postorder (root->rchild);printf(" %c ", root->data);}return;}程序2：线索二叉树的实现和运算#include <stdio.h>#include <stdlib.h>#include <malloc.h>struct btnode{ char data; /*data field*/int lbit; /*left flag field*/int rbit; /*right flag field*/struct btnode *lchild; /*left pointer field */struct btnode *rchild; /*right pointer fieldò**/ };typedef struct btnode NODE;NODE *pre;void main(){ NODE * create(NODE *p );void inthread(NODE *root );NODE *q,*root ;q=(NODE *)malloc(sizeof(NODE));printf("\nAt first,we create a tree!\n" );printf("Please input the data of the tree!\n" );root=create(q);inthread(root);}NODE * create(NODE *p) /*create a structure of binary tree */ { char ch;NODE *t; /*suppose the type of the data is int */scanf("%c",&ch);if(ch==' ')p=NULL;else{ p->data=ch;p->lbit=0;t=(NODE *)malloc(sizeof(NODE));p->lchild=create(t);t=(NODE*)malloc(sizeof(NODE));p->rchild=create(t);}return p;}void inthread(NODE *root ){void inthreading(NODE **p);void invodth(NODE **h);NODE *t;t=((NODE *)malloc(sizeof(NODE)));t->lbit=0; t->rbit=1;t->rchild=t;if (root==NULL)t->lchild=t;else{ pre=t;inthreading(&root); /*produce the thread tree using inorder */t->lchild=root; /* the last node form the thread */pre->rchild=t;pre->rbit=1;t->rchild=pre;}invodth(&t);}void inthreading(NODE **p){ if ((*p)!=NULL){inthreading(&((*p)->lchild)); /*left subtree form the thread */if(((*p)->lchild)==NULL){ (*p)->lbit=1;(*p)->lchild=pre;}if (pre->rchild==NULL){ pre->rbit=1;pre->rchild=*p;}pre=*p;inthreading(&((*p)->rchild));/*right subtree form the thread*/}}void invodth(NODE **h) /*travel the binary tree using the inorder thread */ { NODE *p;p=(*h)->lchild;while(p!=(*h)){ while (p->lbit==0)p=p->lchild;if (p->lbit==1)printf(" %c",p->data);while ( p->rbit==1 && p->rchild!=(*h)){ p=p->rchild;printf(" %c",p->data);}p=p->rchild;}}程序3：哈夫曼树的实现和运算#include<stdio.h>#include <stdlib.h>#include <malloc.h>#define m 100struct ptree /* define the type of binary tree*/ { int w;struct ptree * lchild;struct ptree * rchild;};struct pforest /*define the type of chain belt*/{ struct pforest *link;struct ptree *root;};int WTL=0;void main(){ struct ptree *hafm(int w[m],int n );void travel(struct ptree *head,int n );struct ptree *head;int n,i,w[m];printf("please input the sum of node\n");scanf("%d",&n);printf("please input weight of every node\n");for(i=1;i<=n;i++)scanf("%d",&w[i]);head=hafm(w,n);travel(head,0);printf("The length of the best path is WTL=%d",WTL); }void travel(struct ptree *head,int n){ struct ptree *p;p=head;if (p!=NULL){ if((p->lchild)==NULL&&(p->rchild)==NULL){ printf(" %d",p->w);printf(" the hops of the node is: %d\n",n);WTL=WTL+n*(p->w);}travel(p->lchild,n+1);travel(p->rchild,n+1);}}struct ptree *hafm(int w[m],int n){ struct pforest *inforest(struct pforest *f, struct ptree *t ); struct pforest *p1,*p2,*f;struct ptree *ti,*t,*t1,*t2;int i;f=(struct pforest*)malloc(sizeof(struct pforest));f->link=NULL;for (i=1;i<=n;i++) /*produce n trees that have only rootnode*/ {ti=(struct ptree *)malloc(sizeof(struct ptree));ti->w=w[i];ti->lchild=NULL;ti->rchild=NULL;f=inforest (f,ti);}while(((f->link)->link)!=NULL) /* at least have two binary trees*/ { p1=f->link;p2=p1->link;f->link=p2->link; /*take out frontal two trees*/t1=p1->root;t2=p2->root;free(p1);free(p2);t=(struct ptree *)malloc (sizeof(struct ptree));t->w=t1->w+t2->w; /*weight be added */t->lchild=t1;t->rchild=t2; /*produce the new binary tree */f=inforest(f,t);}p1=f->link;t=p1->root;return(t);}struct pforest * inforest(struct pforest *f, struct ptree *t) { struct pforest *p, *q, *r;struct ptree *ti;r=(struct pforest *) malloc(sizeof(struct pforest));r->root=t;q=f;p=f->link;while (p!=NULL) /*look for the position to be inserted*/ { ti=p->root;if( t->w>ti->w ){ q=p;p=p->link;}elsep=NULL; /*force exit the cycle*/}r->link=q->link;q->link=r;return (f);}实验五、图的操作程序1：图的实现和运算#include <stdio.h>#include <stdlib.h>#include <alloc.h>struct node{ int vertex;struct node *next;};struct headnode{ int vert;struct node *link;};main(){ int t,n,i,visit[100];int d[100];struct headnode *adjlist( );void dfs( );void wfs( );struct headnode *head ;printf("input the sum of nodes:\n");scanf("%d",&n);for(i=0;i<n;i++)scanf("%d",&d[i]);head=adjlist(d,n);printf("1 depth travel\n");printf("2 width travel\n");printf("please input the way of travelling\n");scanf("%d",&t);switch (t){ case 1:for(i=0;i<n;i++)visit[i]=0;dfs(head,1,visit);break;case 2:wfs(head,n);break;default:printf("The error!");}}struct headnode *adjlist(d,n)int n;int d[ ];{ struct headnode head[100] ;struct node *q,*p ;int i,v1;for(i=0; i<n;i++){ head[i].vert=d[i];head[i].link=NULL;printf("input linked list of\n");scanf("%d ",&v1);while(v1>=0){ p=(struct node *) malloc(sizeof(struct node));p->vertex=v1;p->next=head[i].link ;head[i].link=p;scanf("%d", &v1);}}return(head);}void dfs(head,k,visit)struct headnode head[1000];int k,visit [ ];{int i;struct node *p;printf(" v%d",k);visit[k]=1;p=head[k-1].link;while ( p!=NULL){if (visit[p->vertex]==0)dfs(head,p->vertex,visit);p=p->next;};return;}void wfs(head,n)struct headnode *head;int n;{int visit[1000],q[1000],f,r,k,u,m; struct node *p;for(k=0;k<n;k++)visit[k]=0;f=0;r=0;m=0;if (visit[m]==0)q[r]=(head+m)->vert;r=r+1;visit[m]=1;while (f!=r){ u=q[f];f=f+1;printf(" v%d",u);p=(head+u-1)->link;while (p!=NULL){ if (visit[p->vertex-1]==0){ q[r]=p->vertex;r=r+1;visit[p->vertex-1]=1;}p=p->next;}}}程序2：最小生成树#define M 30#define MAX 99#include <stdio.h>#include <stdlib.h>main(){void prim();int i,j,n,g[100][100];printf("input the sum of nodes:\n");scanf("%d",&n);printf("input the content of adjtrix:\n");for (i=1;i<=n;i++)for(j=1;j<=n;j++)scanf("%d",&g[i][j]);prim(g,1,n);}void prim(g,k,n)int g[100][100];int k,n;{int i,j,min,p;struct { int adjvex;int lowcost;}closedge[M];for(i=1;i<=n;i++)if(i!=k){closedge[i].adjvex=k;closedge[i].lowcost=g[k][i];}closedge[k].lowcost=0;for(i=1;i<=n;i++){p=1;min=MAX;for(j=1;j<=n;j++)if(closedge[j].lowcost!=0 && closedge[j].lowcost<min) {min=closedge[j].lowcost;p=j;}if (min!=MAX)printf("%d---%d %d\n",closedge[p].adjvex,p,min); closedge[p].lowcost=0;for(j=1;j<=n;j++)if (g[p][j]<closedge[j].lowcost){ closedge[j].lowcost=g[p][j];closedge[j].adjvex=p;}}}程序3：最短路径#define M 30#define MAX 99#include <stdio.h>#include <stdlib.h>main(){ void prim();int i,j,n,g[100][100];printf("input the sum of nodes:\n");scanf("%d",&n);printf("input the content of adjtrix:\n");for (i=1;i<=n;i++)for(j=1;j<=n;j++)scanf("%d",&g[i][j]);prim(g,1,n);}void prim(g,k,n)int g[100][100];int k,n;{int i,j,min,p;struct {int adjvex;int lowcost;}closedge[M];for(i=1;i<=n;i++)if(i!=k){ closedge[i].adjvex=k;closedge[i].lowcost=g[k][i];}closedge[k].lowcost=0;for(i=1;i<=n;i++){p=1;min=MAX;for(j=1;j<=n;j++)if(closedge[j].lowcost!=0 && closedge[j].lowcost<min) {min=closedge[j].lowcost;p=j;}if (min!=MAX)printf("%d---%d %d\n",closedge[p].adjvex,p,min); closedge[p].lowcost=0;for(j=1;j<=n;j++)if (g[p][j]<closedge[j].lowcost){ closedge[j].lowcost=g[p][j];closedge[j].adjvex=p;}}}程序4：每一对顶点之间的最短路径（Floyd方法）#define M 100#include <stdio.h>#include <stdlib.h>main(){ void floyd( );int i,j,n,ad[M][M],p[M][M];printf("input the sum of nodes\n"); scanf("%d",&n);for(i=0;i<n;i++)for(j=0;j<n;j++)scanf("%d",&ad[i][j]);floyd(ad,p,n);for(i=0;i<n;i++){ for(j=0;j<n;j++)printf(" %d ",p[i][j]);printf("\n");}}void floyd(ad,p,n )int ad[ ][M],p[][M],n;{int i,j,k;for(i=0;i<n;i++)for(j=0;j<n;j++){ if(i==j)p[i][j]=0;elseif (ad[i][j]<M)p[i][j]=i+1;else p[i][j]=0;}for(k=0;k<n;k++)for(i=0;i<n;i++)for(j=0;j<n;j++)if(ad[i][k]+ad[k][j]<ad[i][j]) { ad[i][j]=ad[i][k]+ad[k][j];p[i][j]=p[k][j];}}程序5；拓扑排序#define M 100#include<stdio.h>#include<stdlib.h>#include <alloc.h>struct node{ int vertex ;struct node *next ;。

数据结构与算法实验源代码

数据结构与算法实验源代码数据结构与算法实验源代码一、实验目的本实验旨在通过编写数据结构与算法的实验源代码，加深对数据结构与算法的理解，并提高编程能力。

二、实验环境本实验使用以下环境进行开发和测试：- 操作系统：Windows 10- 开发工具：IDEA（集成开发环境）- 编程语言：Java三、实验内容本实验包括以下章节：3.1 链表在本章节中，我们将实现链表数据结构，并实现基本的链表操作，包括插入节点、删除节点、查找节点等。

3.2 栈和队列在本章节中，我们将实现栈和队列数据结构，并实现栈和队列的基本操作，包括入栈、出栈、入队、出队等。

3.3 树在本章节中，我们将实现二叉树数据结构，并实现二叉树的基本操作，包括遍历树、搜索节点等。

3.4 图在本章节中，我们将实现图数据结构，并实现图的基本操作，包括广度优先搜索、深度优先搜索等。

3.5 排序算法在本章节中，我们将实现各种排序算法，包括冒泡排序、插入排序、选择排序、快速排序、归并排序等。

3.6 搜索算法在本章节中，我们将实现各种搜索算法，包括线性搜索、二分搜索、广度优先搜索、深度优先搜索等。

四、附件本文档附带实验源代码，包括实现数据结构和算法的Java源文件。

五、法律名词及注释5.1 数据结构（Data Structure）：是指数据对象中数据元素之间的关系。

包括线性结构、树形结构、图形结构等。

5.2 算法（Algorithm）：是指解决问题的一系列步骤或操作。

算法应满足正确性、可读性、健壮性、高效性等特点。

5.3 链表（Linked List）：是一种常见的数据结构，由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。

5.4 栈（Stack）：是一种遵循后进先出（LIFO）原则的有序集合，用于存储和获取数据。

5.5 队列（Queue）：是一种遵循先进先出（FIFO）原则的有序集合，用于存储和获取数据。

5.6 树（Tree）：是由节点组成的层级结构，其中一种节点作为根节点，其他节点按照父子关系连接。

数据结构实验四源代码

#include<iostream>#include<stdlib.h>#define MAX 20using namespace std;class ArcNode{public:int adjvex; //存储边的终止位置ArcNode*nextarc;};class VNode{public:char data; //结点信息ArcNode*firsarc;//第一个边的地址};//定义图的相关信息class Graph{public:VNode Node[MAX];int arcnum;//边的个数int vexnum;//顶点的个数};void dfs(Graph G, int v);void bfs(Graph G);int visited[MAX];//标记dfs的数组，看有没有被访问过int book[MAX]; //标记bfs的数组，看有没有被访问过void dfs(Graph G, int v){cout <<G.Node[v].data;visited[v] = 1;ArcNode*p = G.Node[v].firsarc;while (p){if (visited[p->adjvex] == 0)dfs(G, p->adjvex);elsep = p->nextarc;}}void bfs(Graph G){//定义队列，并且对队列进行初始化char queue[MAX] = { '\0' };int front = 0, rear = 1, i, j;ArcNode*ptr;j = 1;if (book[j] != 1){cout <<G.Node[j].data; //在其进队列之前对其进行访问输出book[j] = 1;queue[rear++] = G.Node[j].data;//从定点开始，不断进行出队，输出，将定点有关的终点入队，直到队列为空while (rear - 1 != front){for (i = 1; queue[front + 1] != G.Node[i].data; i++);front++;ptr = G.Node[i].firsarc;while (ptr){if (book[ptr->adjvex] != 1){cout <<G.Node[ptr->adjvex].data;book[ptr->adjvex] = 1;queue[rear++] = G.Node[ptr->adjvex].data;}ptr = ptr->nextarc;}}}}//主函数相关内容int main(){//存储图的相关信息Graph G;int i;for (i = 1; i <= MAX; i++){G.Node[i].firsarc = NULL;}cout <<"输入结点数和边数：\n";cin >> G.vexnum;cin >> G.arcnum;cout <<"输入结点的名称：";for (i = 1; i <= G.vexnum; i++){cin >> G.Node[i].data;}cout <<"输入相邻边：\n";char start, end; //储存边的起始点，终止点int s, t;//存储起始点，终止点的编号int j;ArcNode*ptr, *p;for (i = 1; i <= G.arcnum; i++){cin >> start;cin >> end;getchar();for (j = 1; j <= G.vexnum; j++){if (start == G.Node[j].data)s = j;if (end == G.Node[j].data)t = j;}ptr = new ArcNode;ptr->adjvex = t;if (G.Node[s].firsarc == NULL){G.Node[s].firsarc = ptr;}else{p = G.Node[s].firsarc;while (p->nextarc){p = p->nextarc;}p->nextarc = ptr;}ptr->nextarc = NULL;}cout <<"深度优先遍历：\n";for (i = 1; i <= G.vexnum; i++) //防止图是不连通的图{if (visited[i] != 1)dfs(G, i);}cout <<"\n广度优先遍历：\n";bfs(G);cout <<"\n";system("pause");return 0;}。

《数据结构》实验指导书(Java语言版).

《数据结构》课程实验指导《数据结构》实验教学大纲课程代码：0806523006 开课学期：3 开课专业：信息管理与信息系统总学时/实验学时：64/16 总学分/实验学分：3.5/0.5一、课程简介数据结构是计算机各专业的重要技术基础课。

在计算机科学中，数据结构不仅是一般程序设计的基础，而且是编译原理、操作系统、数据库系统及其它系统程序和大型应用程序开发的重要基础。

数据结构课程主要讨论各种主要数据结构的特点、计算机内的表示方法、处理数据的算法以及对算法性能的分析。

通过对本课程的系统学习使学生掌握各种数据结构的特点、存储表示、运算的原理和方法，学会从问题入手，分析研究计算机加工的数据结构的特性，以便为应用所涉及的数据选择适当的逻辑结构、存储机构及其相应的操作算法，并初步掌握时间和空间分析技术。

另一方面，本课程的学习过程也是进行复杂程序设计的训练过程，通过对本课程算法设计和上机实践的训练，还应培养学生的数据抽象能力和程序设计的能力。

二、实验的地位、作用和目的数据结构是一门实践性较强的基础课程，本课程实验主要是着眼于原理和应用的结合，通过实验，一方面能使学生学会把书上学到的知识用于解决实际问题，加强培养学生如何根据计算机所处理对象的特点来组织数据存储和编写性能好的操作算法的能力，为以后相关课程的学习和大型软件的开发打下扎实的基础。

另一方面使书上的知识变活，起到深化理解和灵活掌握教学内容的目的。

三、实验方式与基本要求实验方式是上机编写完成实验项目指定功能的程序，并调试、运行，最终得出正确结果。

具体实验要求如下：1.问题分析充分地分析和理解问题本身，弄清要求，包括功能要求、性能要求、设计要求和约束，以及基本数据特性、数据间联系等等。

2.数据结构设计针对要解决的问题，考虑各种可能的数据结构，并且力求从中选出最佳方案（必须连同算法实现一起考虑），确定主要的数据结构和全程变量。

对引入的每种数据结构和全程变量要详细说明其功用、初值和操作的特点。

数据结构c语言版实验及源代码

实验1 求两个多项式的相加运算（线性表）编写一个程序用单链表存储多项式，并实现两个多项式相加的函数。

/*文件名:实验1.cpp*/#include <stdio.h>#include <malloc.h>#define MAX 20 /*多项式最多项数*/typedef struct /*定义存放多项式的数组类型*/{float coef; /*系数*/int exp; /*指数*/} PolyArray[MAX];typedef struct pnode /*定义单链表结点类型*/{float coef; /*系数*/int exp; /*指数*/struct pnode *next;} PolyNode;void DispPoly(PolyNode *L) /*输出多项式*/{PolyNode *p=L->next;while (p!=NULL){printf("%gX^%d ",p->coef,p->exp);p=p->next;}printf("\n");}void CreateListR(PolyNode *&L,PolyArray a,int n) /*尾插法建表*/{PolyNode *s,*r;int i;L=(PolyNode *)malloc(sizeof(PolyNode)); /*创建头结点*/L->next=NULL;r=L; /*r始终指向终端结点,开始时指向头结点*/ for (i=0;i<n;i++){s=(PolyNode *)malloc(sizeof(PolyNode));/*创建新结点*/s->coef=a[i].coef;s->exp=a[i].exp;r->next=s; /*将*s插入*r之后*/r=s;}r->next=NULL; /*终端结点next域置为NULL*/}void Sort(PolyNode *&head) /*按exp域递减排序*/{PolyNode *p=head->next,*q,*r;if (p!=NULL) /*若原单链表中有一个或以上的数据结点*/ {r=p->next; /*r保存*p结点后继结点的指针*/p->next=NULL; /*构造只含一个数据结点的有序表*/p=r;while (p!=NULL){r=p->next; /*r保存*p结点后继结点的指针*/q=head;while (q->next!=NULL && q->next->exp>p->exp)q=q->next; /*在有序表中找插入*p的前驱结点*q*/ p->next=q->next; /*将*p插入到*q之后*/q->next=p;p=r;}}}void Add(PolyNode *ha,PolyNode *hb,PolyNode *&hc) /*求两有序集合的并*/ {PolyNode *pa=ha->next,*pb=hb->next,*s,*tc;float c;hc=(PolyNode *)malloc(sizeof(PolyNode)); /*创建头结点*/tc=hc;while (pa!=NULL && pb!=NULL){if (pa->exp>pb->exp){s=(PolyNode *)malloc(sizeof(PolyNode)); /*复制结点*/s->exp=pa->exp;s->coef=pa->coef;tc->next=s;tc=s;pa=pa->next;}else if (pa->exp<pb->exp){s=(PolyNode *)malloc(sizeof(PolyNode)); /*复制结点*/s->exp=pb->exp;s->coef=pb->coef;tc->next=s;tc=s;pb=pb->next;}else /*pa->exp=pb->exp*/{c=pa->coef+pb->coef;if (c!=0) /*系数之和不为0时创建新结点*/{s=(PolyNode *)malloc(sizeof(PolyNode)); /*复制结点*/s->exp=pa->exp;s->coef=c;tc->next=s;tc=s;}pa=pa->next;pb=pb->next;}}if (pb!=NULL) pa=pb; /*复制余下的结点*/while (pa!=NULL){s=(PolyNode *)malloc(sizeof(PolyNode)); /*复制结点*/s->exp=pa->exp;s->coef=pa->coef;tc->next=s;tc=s;pa=pa->next;}tc->next=NULL;}void main(){PolyNode *ha,*hb,*hc;PolyArray a={{1.2,0},{2.5,1},{3.2,3},{-2.5,5}};PolyArray b={{-1.2,0},{2.5,1},{3.2,3},{2.5,5},{5.4,10}};CreateListR(ha,a,4);CreateListR(hb,b,5);printf("原多项式A: ");DispPoly(ha);printf("原多项式B: ");DispPoly(hb);Sort(ha);Sort(hb);printf("有序多项式A: ");DispPoly(ha);printf("有序多项式B: ");DispPoly(hb);Add(ha,hb,hc);printf("多项式相加: ");DispPoly(hc);}实验2 求解迷宫问题的所有路径及最短路径程序（堆栈）改进教材中3.2.4节中的求解迷宫问题程序，要求输出如图所示的迷宫的所有路径，并求出最短路径成都及最短路径。

实验报告数据结构课程设计源代码

表达式类型的实现——实习报告一．需求分析1. 编写一个程序，通过前缀表达式来构造一个与之对应的算术表达式并存入二叉树中，通过中序遍历二叉树输出表达式及对其进行变量赋值，通过后序遍历二叉树计算表达式的值。

2. 本程序功能有：存储表达式、对表达式进行赋值计算、求偏导、计算三角函数、合并常数及接受原书写形式的表达式。

3. 测试数据（1）. 分别输入0 ; a ; -91 ; +a*bc ; +*5^x2*8x ; +++*3^x3*2^x2x6并输出。

（2）. 每输入一个表达式，对其中的变量进行赋值，再对表达式求值。

二．概要设计按照要求，需要以二叉树来存储表达式，但在构造过程中还需要用到栈来实现前缀表达式与二叉树之间的转换。

1. 抽象数据类型栈的定义：ADT SqStack{数据对象：D={ai |ai为整型或字符型}数据关系：R={<ai , ai-1> |ai ,ai-1∈D}基本操作：Status InitStack(SqStack&S);此函数用于创建一个空栈Status StackEmpty(SqStack S);此函数用于判断栈是否为空Status StackFull(SqStack S);此函数用于判断栈是否已满Status Push(SqStack&S, SElemType e);将数据元素e入栈Status Pop(SqStack&S, SElemType&e);出栈，并以e返回出栈的元素Status GetTop(SqStack S, SElemType&e);若栈不空，则以e返回栈顶元素}ADT SqStack2. 二叉树表达式数据类型ATD BiTNode{数据对象：D= { a i | a i∈SqStack}数据关系：R= {<ai , ai-1> |ai ,ai-1∈D}基本操作：Status InputExpr(char*string,int flag);以字符串形式读取输入void JudgeValue(BiTree*E,char*string,int i);判断字符string[i]，如果是'0'-'9'常量之间，二叉树结点存为整型；否则，存为字符型 Status ReadExpr(BiTree*E,char*exprstring);以正确的前缀表示式并构造表达式EStatus PriCmp(char c1,char c2);如果两个字符是运算符，比较两个运算符的优先级，c1比c2优先，返回OK，否则返回ERRORvoid WriteExpr(BiTree E);用带括弧的中缀表达式输出表达式void Assign(BiTree*E,char V,int c,int*flag);实现对表达式中的所有变量V的赋值(V=c)，参数flag为表示是否赋值过的标志long Operate(int opr1,char opr,int opr2);运算符运算求值，参数opr1,opr2为常量，opr为运算符，根据不同的运算符，实现不同的运算，返回运算结果double Operate1(char opr,double opr1);三角函数运算求值，参数opr为常量，opr1为运算符，根据不同的运算符，实现不同的运算，返回运算结果Status Check(BiTree E);检查表达式是否还存在没有赋值的变量，以便求算数表达式的值long Value(BiTree E);对算术表达式求值void CompoundExpr(char P,BiTree&E1,BiTree E2);构造一个新的复合表达式Status ReadInorderExpr(char*string,char*pre_expr);以表达式的原书写形式输入，表达式的原书写形式字符串string变为字符串pre_expr，后调用reversal_string()函数反转得到前缀表达式pre_exprvoid ReversalString(char*exprstring);将字符串exprstring反转过来void MergeConst(BiTree*E);常数合并操作函数，合并表达式E中所有常数运算int IsOperator(char c);判断是否操作符void Diff(BiTree&E,char v);求偏导数}ADT BiTNode3. 主程序int main() {while(TRUE) {判断用户选择的操作；执行所选操作，并适时提示用户输入及输出运算结果；若用户选择退出，则执行exit(0)退出程序；}；4. 程序调用关系：主程序模块三．详细设计1. 数据类型：二叉树数据类型：typedef enum{INT,CHAR}ElemTag;/*INT为整型数据num，CHAR为字符型数据c*/typedef struct TElemType{ElemTag tag;/*{INT,CHAR}指示是整型还是字符型*/int num;/*tag=INT时，为整型*/char c;/*tag=CHAR时，为字符型*/}TElemType;二叉树节点类型：typedef struct BiTNode{TElemType data;/* 二叉树存储的数据*/struct BiTNode*lchild,*rchild; /* 左右孩子指针*/}BiTNode,*BiTree;2. 函数实现：（以伪码表示）Status InputExpr(char *string,int flag) //此函数用于表达式的输入与存储{if(flag==0)cout<<"\n请输入正确的前缀表示式：";else cout<<"\n请以表达式的原书写形式输入正确表示式：";fflush(stdin);/*清理缓冲区*/gets(string);/*从键盘输入一串字符串作为表达式*/if(strlen(string)==1)/*输入的表达式字符串长度为1*/if(string[0]=='+'||string[0]=='-'||string[0]=='*'||string[0]=='/'||string[0]=='^')/*输入的表达式只有一个运算符*/{cout<<"\n表达式只有一个字符，为运算符，错误！";return ERROR;}else if((string[0]>='0'&&string[0]<'9')||(string[0]>='a'&&string[0]<='z')||(string[0]>='A'&&string[0]<='Z')) /*输入的表达式只有一个数字或字符*/{cout<<"\n表达式只有一个字符！";return OK;}else {cout<<"\n输入的字符不是运算符也不是变量常量，错误！";return ERROR;}return OK;}void JudgeValue(BiTree *E,char *string,int i) //此函数用于判断字符string[i]，如果是'0'-'9'常量之间，二叉树结点存为整型；否则，存为字符型{if(string[i]>='0'&&string[i]<='9') {(*E)->data.tag=INT;(*E)->data.num=string[i]-'0';}//string[i]为常量else if(string[i]>='10'&&string[i]<='20') {(*E)->data.tag=INT;(*E)->data.num=SaveNumber[string[i]];} //string[i]为常量，存于数组save_number中else {(*E)->data.tag=CHAR;(*E)->data.c=string[i];} /*string[i]为变量,对数据进行变量标记}/*以正确的前缀表示式并构造表达式E*/Status ReadExpr(BiTree *E,char *exprstring){定义栈；为树的根结点分配空间；len=strlen(exprstring);/*len赋值为表达式的长度*/if(len==1) JudgeValue(E,exprstring,0);/*将exprstring[0]存入二叉树的结点中*/else {JudgeValue(E,exprstring,0);/*将exprstring[0]存入二叉树的结点中*/InitStack(S);/*初始化栈*/q=(*E);Push(S,q);/*入栈*/Push(S,q);/*入栈，根结点入栈两次是为判断先序输入的表达式是不是正确的表达式*/for(i=1;i<len&&!StackEmpty(S);i++){p=(BiTree)malloc(sizeof(BiTNode));JudgeValue(&p,exprstring,i);/*将exprstring[i]存入二叉树的结点中*/p->lchild=NULL;p->rchild=NULL;if(exprstring[i]=='+'||exprstring[i]=='-'||exprstring[i]=='*'||exprstring[i]=='/'||exprstring[i]=='^'){/*为运算符，运算符入栈，左孩子不空，向左孩子走，否则，如果右孩子不空，向右孩子走*/if(!q->lchild) {q->lchild=p;Push(S,p);q=p;}else {q->rchild=p;Push(S,p);q=p;}}else /*不是运算符，运算符出栈*/{if(!q->lchild) {q->lchild=p;Pop(S,q);}else {q->rchild=p;Pop(S,q);}}}if(StackEmpty(S)&&i>=len) return OK;/*栈空且i>=len，说明输入的表达式是正确的*/ else /*输入的表达式是错误的*/{cout<<"\n输入的表达式有误！";return ERROR;}}}//此函数用于比较两个运算符的优先级，若c1比c2优先，返回OK，否则返回ERROR Status PriCmp(char c1,char c2){if((c1=='^'||c1=='*'||c1=='-'||c1=='+'||c1=='/')&&(c2=='^'||c2=='*'||c2=='-'||c2=='+'||c2=='/')){/*c1和c2为运算符*/if(c1=='^'){/*c1为指数运算符，则当c2不为'^'时，c1比c2优先*/if(c2!='^') return OK;else return ERROR;}else if(c1=='*'||c1=='/'){/*c1为乘法或除法运算符，则当c2为'+'或'-'，c1比c2优先*/if(c2=='^'||c2=='*'||c2=='/') return ERROR;else return OK;}else return ERROR;/*其余，c1不比c2优先*/}else return ERROR;/*c1和c2不是运算符*/}此函数递归实现用带括弧的中缀表达式输出表达式void WriteExpr(BiTree E){if(E)/*树不为空*/{ //先递归左子树if(E->lchild&&E->lchild->data.tag==CHAR)/*E的左孩子不为空，且左孩子为字符*/{if(PriCmp(E->data.c,E->lchild->data.c)){cout<<"(";WriteExpr(E->lchild);cout<<")";}/*带括弧输出左子树*/else WriteExpr(E->lchild);/*否则，不带括弧输出左子树*/}else WriteExpr(E->lchild);/*否则，输出左子树*//*访问输出根结点的值*/if(E->data.tag==INT){cout<<E->data.num;}else cout<<E->data.c;//后递归右子树if(E->rchild&&E->rchild->data.tag==CHAR){//E的右孩子不为空，且右孩子为字符if(PriCmp(E->data.c,E->rchild->data.c)){cout<<"(";WriteExpr(E->rchild);cout<<")";}/*带括弧输出右子树*/else WriteExpr(E->rchild);/*否则，不带括弧输出右子树*/}else WriteExpr(E->rchild);/*否则，输出右子树*/}}此函数递归实现对表达式中的所有变量V的赋值(V=c)，参数flag为表示是否赋值过的标志void Assign(BiTree *E,char V,int c,int *flag){if(*E){if((*E)->data.tag==CHAR&&(*E)->data.c==V) {(*E)->data.tag=INT;(*E)->data.num=c;*flag=1;} /*如果找到要赋值的变量，赋值*/Assign(&((*E)->lchild),V,c,flag);/*递归左子树*/Assign(&((*E)->rchild),V,c,flag);/*递归左子树*/}}/*运算符运算求值，参数opr1,opr2为常量，opr为运算符，根据不同的运算符，实现不同的运算，返回运算结果*/long Operate(int opr1,char opr,int opr2){switch(opr){case '+':/*加法*/result=opr1+opr2;return result;break;case '-':/*减法*/result=opr1-opr2;return result;break;case '*':/*乘法*/result=opr1*opr2;return result;break;case '/':/*除法，除法是在整型类型上的除法*/result=opr1/opr2;return result;break;case '^':/*指数运算*/result=pow(opr1,opr2);return result;break;default:break;}}/*三角函数运算求值，参数opr为常量，opr1为运算符，根据不同的运算符，实现不同的运算，返回运算结果*/double Operate1(char opr,double opr1){switch(opr){case 's'://正弦运算result1=sin(opr1);return result1;break;case 'c'://余弦运算result1=cos(opr1);return result1;break;case 't'://正切运算result1=tan(opr1);return result1;break;default:break;}}/*检查表达式是否还存在没有赋值的变量，以便求算数表达式的值*/Status Check(BiTree E){if(E&&E->data.tag==CHAR){/*树不为空*/if(E->data.c!='*'&&E->data.c!='^'&&E->data.c!='-'&&E->data.c!='+'&&E->data.c!='/'){cout<<"\n表达式中仍存在变量没有赋值！没法求出表达式的值！";return ERROR;}/*存在变量，提示信息，后返回ERROR*/if(Check(E->lchild)) Check(E->rchild);}}/*对算术表达式求值*/long Value(BiTree E){if(E){/*树不为空*/if(!E->lchild&&!E->rchild&&E->data.tag==INT) return (E->data.num);/*结点的左孩子和右孩子为空，为叶子结点，返回结点的值*/return Operate(Value(E->lchild),E->data.c,Value(E->rchild));/*运算求值，后根遍历的次序对表达式求值，其中参数递归调用了Value()函数求左子树的值和右子树的值*/}}/*构造一个新的复合表达式*/void CompoundExpr(char P,BiTree &E1,BiTree E2){为结点E申请空间；E->data.tag=CHAR;E->data.c=P;/*申请到的结点值为P*/E->lchild=E1;/*结点的左孩子为E1*/E->rchild=E2;/*结点的右孩子为E2*/E1=E;/*(*E1)为根结点*/cout<<"\n表达式E复合成功！其表达式变为：\n";WriteExpr(E);/*输出复合好的表达式*/}/*此函数以表达式的原书写形式输入，表达式的原书写形式字符串string变为字符串pre_expr*//*后调用reversal_string()函数反转得到前缀表达式pre_expr*/Status ReadInorderExpr(char *string,char *PreExpr){int i,j,len,CharNumber=1;/*len表示字符串string的长度，char_number是记录数组save_number[]的个数*/int number;/*保存大于9的常量*/InitStack1(S);/*初始栈*/Push1(S,'#');/*先将字符'#'入栈，用来表示作为栈的最底一个元素*/len=strlen(string);/*len为字符串string的长度*/c=string[len-1];/*从字符串的最后一个字符开始向前扫描*/i=len-1;while(!StackEmpty1(S)&&i>=0){/*栈不为空且i大于等于0*/if(c=='('){/*字符为'('*/Pop1(S,c);/*出栈，赋值给c*/while(c!=')'){/*假如c不为')',出栈*/*PreExpr++=c;if(!StackEmpty1(S)&&GetTop1(S,c1)&&c1!='#') Pop1(S,c);else {cout<<"\n输入的表达式有误!";return ERROR;}}}else if(c==')'){Push1(S,c);} /*字符为')'，入栈*/else if(c>='0'&&c<='9'){/*字符为'0'-'9'之间，循环扫描string前一个字符，后确定常量的大小*/number=c-'0';/*number为第一个常量字符的ASCII码-48*/for(c1=string[i-1],j=1;(c1>='0'&&c1<='9')&&i>=0;j++,i--){/*循环扫描string前一个字符，求出常量后赋给number*/number=(c1-'0')*pow(10,j)+number;/*number为扫描到的常量*/c1=string[i-2];}SaveNumber[CharNumber]=number;/*将number存入到数组save_number中，下标为char_number*/*PreExpr++=c;CharNumber++;}else if((c>='a'&&c<='z')||(c>='A'&&c<='Z')){//string下一个字符不能为常量或变量，否则，出错if((string[i-1]>='0'&&string[i-1]<='9')||(string[i-1]>='A'&&string[i-1]<='Z')||(string[i-1]>='a'&&string[i-1]<='z')) {cout<<("\n输入的表达式有误！");return ERROR;}else *PreExpr++=c;}else if(c=='*'||c=='/'){/*字符为运算符'*'或'/'*/while(GetTop1(S,c1)&&(c1=='^')){Pop1(S,c1);*PreExpr++=c1;}/*如果c1比c优先，出栈*/Push1(S,c);/*入栈字符c*/}else if(c=='+'||c=='-'){/*字符为运算符'+'或'-'*/while(GetTop1(S,c1)&&(c1=='^'||c1=='*'||c1=='/')){Pop1(S,c1);*PreExpr++=c1;}/*如果c1比c优先，出栈*/Push1(S,c);/*入栈运算符c*/}else if(c=='^'){Push1(S,c);/*入栈运算符'^'*/}else {cout<<"\n输入的表达式有误！";return ERROR;}/*其他字符，错误，返回ERROR*/i--;/*下一个字符*/if(i>=0) c=string[i];/*i不小于0，c=string[i]循环下一个字符*/else /*否则，将清空栈*/while(!StackEmpty1(S)&&GetTop1(S,c1)&&c1!='#') {Pop1(S,c);*PreExpr++=c;} }Pop1(S,c);/*将'#'出栈*/*PreExpr='\0';/*字符串结束符*/if(i<0&&StackEmpty1(S)) return OK;else return ERROR;}/*将字符串exprstring反转过来*/void ReversalString(char *exprstring){len=strlen(exprstring);/*len为exprstring的长度*/for(i=0,j=len-1;i<j;i++,j--){/*字符串前后两个字符对换*/temp=exprstring[i];exprstring[i]=exprstring[j];exprstring[j]=temp;}}/*常数合并操作函数，合并表达式E中所有常数运算*/void MergeConst(BiTree *E){while((*E)->lchild&&(*E)->rchild){/*左右孩子不为空*/if((*E)->lchild->data.tag==INT&&(*E)->rchild->data.tag==INT){//假如左右孩子为常量，合并result=Operate((*E)->lchild->data.num,(*E)->data.c,(*E)->rchild->data.num);/*常数合并运算，调用Operate()函数求值*/(*E)->data.tag=INT;(*E)->data.num=result;/*修改之前的运算符为常量*/free((*E)->lchild);/*释放左孩子*/free((*E)->rchild);/*释放右孩子*/(*E)->lchild=(*E)->rchild=NULL;/*左右孩子置空*/}else{MergeConst(&((*E)->lchild));/*递归左孩子*/MergeConst(&((*E)->rchild));/*递归右孩子*/}}}//判断是否操作符int IsOperator(char c){switch(c){case '+': return TRUE;case '-': return TRUE;case '*': return TRUE;case '/': return TRUE;case '^': return TRUE;default: return FALSE;}}void Diff(BiTree &E,char v)//求偏导数{if((E->lchild)&&(E->rchild))//树不为空{if((E->rchild->data.c=='^')&&(E->rchild->lchild->data.c==v) )//若该变量为要求偏导的变量，则对其求偏导{E->lchild->data.num=(E->lchild->data.num)*(E->rchild->rchild->data.num);E->lchild->data.tag=INT;E->rchild->rchild->data.num=E->rchild->rchild->data.num-1;}else if(E->rchild->data.tag==INT&&(E->data.c=='+'||E->data.c=='-'))//若该变量不是要求偏导的变量，且为整数，则以0替换其中数据{E->rchild->data.num=0;E->rchild->data.tag=INT;}else if((E->rchild->data.c==v)&&(IsOperator(E->lchild->data.c)))//否则以1替换其中数据{E->rchild->data.num=1;E->rchild->data.tag=INT;}else if((E->rchild->data.c==v)&&E->lchild->data.tag==INT){E->data.num=E->lchild->data.num;E->data.tag=INT;free(E->lchild);free(E->rchild);E->lchild=E->rchild=NULL;}Diff(E->lchild,v);//递归执行左子树Diff(E->rchild,v);//递归执行右子树}else return;}3.主程序和其他函数：char menu()//主菜单{char choice;cout<<"\n\t****************************************";cout<<"\n\t***********9.表达式类型的实现***********";cout<<"\n\t 1 >>>输入正确的前缀表达式";cout<<"\n\t 2 >>>带括弧的中缀表示式输出";cout<<"\n\t 3 >>>对变量进行赋值";cout<<"\n\t 4 >>>对算数表达式求值";cout<<"\n\t 5 >>>构造一个新的复合表达式";cout<<"\n\t 6 >>>以表达式的原书写形式输入(选作)";cout<<"\n\t 7 >>>合并表达式中所有常数运算(选作)";cout<<"\n\t 8 >>>三角函数操作 (选作)";cout<<"\n\t 9 >>>求偏导数 (选作)";cout<<"\n\t 0 >>>退出";cout<<"\n\t****************************************";cout<<"\n\t请输入你的选择(数字)>>>>>";cin >> choice;return choice;}int main(){BiTree E,E1;//两个表达式E和E1int flag=0;//表达式E构造标志，为0表示未构造，为1表示已构造char V,P;//V被赋值，P为符合表达式运算符char string[30],ExprString[30];//字符串while(TRUE){system("cls");//清屏switch(menu()) {case '1':/*1 >>>输入正确的前缀表达式*/cout<<"\n\t*************************输入提示信息************************";cout<<"\n\t输入正确的前缀表达式的要求：";cout<<"\n\t\t【变量】 a-z或A-Z";cout<<"\n\t\t【常量】 0-9，不能超过9";cout<<"\n\t\t【运算符】 +,-,*,/,^";cout<<"\n\t请输入正确的前缀表达式，后按回车键存入缓冲区，否则可能会出错！";cout<<"\n\t*************************************************************";if(InputExpr(ExprString,0))//在flag=0时，初始输入if(ReadExpr(&E,ExprString)){//前缀读入并构造Eflag=1;cout<<"\n表达式构造成功！请按任意键返回菜单";}getchar();break;case '2':/*2 >>>带括弧的中缀表示式输出*/if(flag==1){cout<<("\n\t带括弧的中缀表达式为：");WriteExpr(E);}else cout<<("\n\t表达式未构造成功！请重新构造成功的表达式！");getchar();getchar();break;case '3':/*3 >>>对变量进行赋值*/cout<<("\n\t********************赋值操作说明信息***********************************");cout<<("\n\t赋值操作：实现对表达式中的某一个变量V的赋值，即使V=C，C为一整数");cout<<("\n\t 【1】根据输出的表达式，输入要赋值的变量V，只能输入一个字符，否则出错");cout<<("\n\t 【2】输入要将变量V赋值为的整数C，只能是整数，否则出错");cout<<("\n\t 【注】如果表达式未构造，请回到主菜单选择构造表达式");cout<<("\n\t***********************************************************************");if(flag==1){int AssignFlag=0;cout<<"\n表达式E为：";WriteExpr(E);fflush(stdin);/*清理缓冲区*/cout<<"\n请输入要赋值的字符：";V=getchar();cout<<"请输入要将赋值为：";cin>>c;Assign(&E,V,c,&AssignFlag);//赋值并改变标志if(AssignFlag){cout<<"\n赋值成功！\n赋值后的表达式为：";WriteExpr(E);}else cout<<"\n表达式里没有%c这个变量！",V;}else cout<<"\n表达式未构造成功！请构造成功的表达式！";getchar();getchar();break;case '4':/*4 >>>对算数表达式求值*/cout<<"\n\t********************算数表达式求值说明信息************************";cout<<"\n\t 【注】如果表达式还有变量未赋值，即表达式不是算数表达式";cout<<"\n\t 不能求出表达式的值，请回到主菜单选择赋值操作，后再求值";cout<<"\n\t******************************************************************";if(flag==1){cout<<"\n算数表达式：";WriteExpr(E);if(Check(E)){ //检查是否全赋值result=Value(E);cout<<"\n求算数表达式的值:\t";WriteExpr(E);cout<<"="<<result;}}else cout<<"\n表达式未构造成功！请构造成功的表达式！";getchar();getchar();break;case '5':/*5 >>>构造一个新的复合表达式*/cout<<"\n\t*****************构造新的复合表达式说明信息***************************";cout<<"\n\t 【1】构造一个新的表达式E1，采用表达式的原书写形式输入";cout<<"\n\t 【2】构造表达式E1成功后，输入要复合表达式E和E1的操作运算符(+,-,*,/,^)";cout<<"\n\t 【注】如表达式E未构造，不能复合表达式；如构造表达式E1错误，复合失败";cout<<"\n\t***********************************************************************";if(flag==1){cout<<"\n表达式E1为：";WriteExpr(E);cout<<"\n请构造新的表达式E2:";fflush(stdin);/*清理缓冲区*/if(InputExpr(string,1)){//标志为1，输入字符串if(ReadInorderExpr(string,ExprString)){//入栈ReversalString(ExprString);//反转if(ReadExpr(&E1,ExprString)){flag=1;cout<<("\n表达式E2构造成功！");WriteExpr(E1);cout<<("\n请输入要构造新的复合表达式的操作运算符>>>");P=getchar();while(P!='*'&&P!='/'&&P!='+'&&P!='-'&&P!='^'){fflush(stdin);/*清理缓冲区*/cout<<"\n输入的操作运算符有误！请重新输入>>>";P=getchar();}CompoundExpr(P,E,E1);}else cout<<"\n复合新的表达式失败！请按任意键返回主菜单！";}}}else cout<<"\n表达式未构造成功！请构造成功的表达式！";getchar();getchar();break;case '6':/*6 >>>以表达式的原书写形式输入*/cout<<"\n\t*************以表达式的原书写形式输入说明信息************************";cout<<"\n\t输入正确的原书写形式表达式";cout<<"\n\t 【变量】 a-z或A-Z";cout<<"\n\t 【常量】大于等于0的正整数";cout<<"\n\t 【运算符】 +,-,*,/,^(乘幂)";cout<<"\n\t 【括弧】左括弧 ( ,右括弧 ) ";cout<<"\n\t 【注】表示式中常量最多只能是30个，超过30个，出错！";cout<<"\n\t按原书写形式输入中，请按照正确的方式输入，否则可能会出错！";cout<<"\n\t**********************************************************************";if(InputExpr(string,1))if(ReadInorderExpr(string,ExprString)){ReversalString(ExprString);if(ReadExpr(&E,ExprString)){flag=1;cout<<"\n表达式构造成功！\n输入的带括弧的中缀表达式：";WriteExpr(E);}}getchar();getchar();break;case '7':/*7 >>>合并表达式中所有常数运算*/cout<<"\n***************合并表达式中的所有常数运算*******************************";cout<<"\n 【注】合并表达式中的所有常数运算并不能一次性将常数都合并！";cout<<"\n例如：表达式'1+2*(3+3*4+9/3)'的常数合并，选择7进行合并，结果变为\n'1+2*(3+12+3)'，";cout<<"根据优先级先后合并的，如果要合并到最后，需多次选择7\n进行合并，又合并一次'1+2*(15+3)'，";cout<<"再次合并'1+2*18',再次合并'1+36'，\n再次合并'37'，后无法合并！";cout<<"\n************************************************************************";if(flag==1) {cout<<"\n原表达式为：";WriteExpr(E);MergeConst(&E);//常数合并操作cout<<"\n合并表达式中所有的常数运算后的表达式：";WriteExpr(E);}else cout<<"\n表达式未构造成功！请构造成功的表达式！";getchar();getchar();break;case '8'://三角函数操作cout<<"\t***************************三角函数操作(选作)***************************";cout<<"\n";cout<<"\n\t[注] 请按要求输入其中 s代表sin c代表cos t代表tan ";cout<<"\n\t角度用弧度表示，例如~1 即表示sin 1";cout<<"\n\t本操作只可求三角函数值，如需其他操作请将结果带入其它操作中";cout<<"\n\t输入一个字符请按回车，确保正确录入";cout<<"\n\t************************************************************************";double opr1,result1;char opr;cout<<"\n请按要求输入";cin>>opr;cin>>opr1;result1=Operate1(opr,opr1);cout<<"结果为:"<<result1;getchar();getchar();break;case '9'://求导getchar();char h;cout<<"输入需要求偏导的变量字符\n";cin>>h;Diff(E,h);WriteExpr(E);getchar();getchar();break;case '0':/*0 >>>退出*/cout<<"\n请按任意键退出！";getchar();getchar();exit(0);break;default :cout<<"\n输入有误！请按任意键回到主菜单重新选择！";getchar();getchar();getchar();//Sleep(5000);break;}}return 0;}（部分代码较长，故在word文档中较难整理格式，请参见附录源代码查看）函数调用关系：四．调试分析1.合并表达式所有常数运算功能一开始只能实现一次合并，即：1+4*6=1+24 或者8+3*2^4=8+3*16。

数据结构与算法实验源代码

实验二#include<stdio.h>#include<stdlib.h>#define Maxlen 100typedef struct{int data[Maxlen];int last;}Sequenlist;Sequenlist *SqLsetnull(){ //建立一个空的顺序表Sequenlist *L;L=(Sequenlist *)malloc(sizeof(Sequenlist));L->last=-1;return L;}void *SqLset(Sequenlist *L){ //对顺序表输入数据int n;printf("请输入要输入的元素数量：");scanf("%d",&n);printf("请输入要输入的元素：");for(int i=0;i<n;i++){scanf("%d",&L->data[i]);}L->last=i;return L;}int SqLdelete(Sequenlist *L,int i){ //删除顺序表中的元素//因为只是调用该函数删除顺序表中多余的元素省略的一些数据判断int j;for(j=i;j<=L->last+1;j++)L->data[j]=L->data[j+1];L->last--;return 1;}void SqLdel(Sequenlist *L){ //寻找顺序表中多余的元素并删除int i,j;if(L->last<0){printf("\n顺序表为空\n");}else{for(i=0;i<=L->last;i++){for(j=i+1;j<=L->last;j++)if(L->data[j]==L->data[i]){SqLdelete(L,j); //调用函数删除下标为j的结点}}}}void SqLsc(Sequenlist *L){ //输出顺序表中的数据int i;if(L->last<0)printf("\n顺序表为空\n");else{printf("顺序表中的元素：");for(i=0;i<L->last;i++){printf("%d ",L->data[i]);}}printf("\n");}int main(void){Sequenlist *L;L=SqLsetnull();int choice;printf("1,输入数据2，删除重复多余的数据3,输出数据0，退出\n");do{printf("请输入选择：");scanf("%d",&choice);switch(choice){case 1:SqLset(L);printf("\n");break;case 2:SqLdel(L);printf("\n");break;case 3:SqLsc(L);printf("\n");break;default:printf("请输入正确的选择!\n");break;case 0:break;}}while(choice!=0);return 0;}实验三#include<stdio.h>#include<stdlib.h>#define SIZE 15typedef struct{int data[SIZE];int last;}RecordList;RecordList *shuru(){ //向顺序表中输入数据int s,i=0;RecordList *L;L=(RecordList *)malloc(sizeof(RecordList));printf("请输入要输入到顺序表中数据的数量：");scanf("%d",&s);if(s>15){printf("超过最大的数据长度");}else{printf("请输入要输入的数据：");for(i=0;i<s;i++)scanf("%d",&L->data[i]);}printf("成功输入%d个数据\n\n",i);L->last=i-1;return L;}void paixu(RecordList *L){ //冒泡排序法对顺序表中的数据进行排序int x,change=1,i,j;for(i=0;i<L->last&&change!=0;i++){change=0;for(j=0;j<L->last-i;j++){if(L->data[j]>L->data[j+1]){x=L->data[j+1];L->data[j+1]=L->data[j];L->data[j]=x;change=1;}}}}int BinSrch(RecordList *L,int k){ //二分查找int low=0,i=-1,high,mid;high=L->last;while(low<=high){mid=(low+high)/2;if(k==L->data[mid]){i=mid;break;}else if(k<L->data[mid])high=mid-1;elselow=mid+1;}return i;}int main(void){RecordList *L=NULL;int i,choice,data1;printf("1,输入数据2，二分法查找0,退出\n");do{printf("请输入选择：");scanf("%d",&choice);switch(choice){case 1:L=shuru(); //输入数据paixu(L); //数据排序break;case 2:if(L==NULL||L->last==-1){ //查找前检验表中是否有数据printf("\n顺序表为空\n\n");break;}else{printf("请输入要查找的数据：");scanf("%d",&data1);i=BinSrch(L,data1);printf("数据%d的序号(下标)是%d \n\n",data1,i);break;}default:printf("\n请输入正确的选择\n\n");break;case 0:break;}}while(choice!=0);return 0;}实验四#include<stdio.h>#include<stdlib.h>#define SIZE 15typedef struct{int data[SIZE];int last;}RecordList;RecordList *shuru(){ //向顺序表中输入数据int s,i=0;RecordList *L;L=(RecordList *)malloc(sizeof(RecordList));printf("请输入要输入到顺序表中数据的数量：");scanf("%d",&s);if(s>15){printf("超过最大的数据长度");}else{printf("请输入要输入的数据：");for(i=0;i<s;i++)scanf("%d",&L->data[i]);}printf("成功输入%d个数据\n\n",i);L->last=i-1;return L;}void paixu(RecordList *L){ //冒泡排序法对顺序表中的数据进行排序int x,change1=1,change2=1,i,j;for(i=0;change1!=0||change2!=0;i++){change1=0;change2=0;if(i%2==0){for(j=1;j<L->last;j=j+2){if(L->data[j]>L->data[j+1]){x=L->data[j+1];L->data[j+1]=L->data[j];L->data[j]=x;change1=1;}}}else{for(j=0;j<L->last;j=j+2){if(L->data[j]>L->data[j+1]){x=L->data[j+1];L->data[j+1]=L->data[j];L->data[j]=x;change2=1;}}}}}void shuchu(RecordList *L){int i;for(i=0;i<=L->last;i++){printf("%d ",L->data[i]);}}int main(void){RecordList *L=NULL;int choice;printf("1,输入数据2，冒泡排序3,输出0,退出\n");do{printf("请输入选择：");scanf("%d",&choice);switch(choice){case 1:L=shuru(); //输入数据break;case 2:paixu(L); //数据排序printf("排序成功\n\n");break;case 3:shuchu(L);printf("\n");break;default:printf("\n请输入正确的选择\n\n");break;case 0:break;}}while(choice!=0);return 0;}实验五#include<stdio.h>#include<stdlib.h>typedef struct node{int data;struct node *next;}LinkList;LinkList *CreatList(){LinkList *head,*r,*s; //建立带头结点的链表，head为链表的头结点int n;head=(LinkList *)malloc(sizeof(LinkList));head->next=NULL;r=head;printf("请输入要输入的数据的个数:");scanf("%d",&n);printf("请输入要输入的数据:");for(int i=0;i<n;i++){s=(LinkList *)malloc(sizeof(LinkList));scanf("%d",&s->data);s->next=NULL;r->next=s;r=s; //r指向链表的尾节点}return head;}void Add(LinkList *head,int x){LinkList *s,*r,*t;t=(LinkList *)malloc(sizeof(LinkList));r=head;s=head->next;for(;s!=NULL&&x>=s->data;s=s->next){ //要寻找要插入节点的位置r=r->next;}t->data=x;if(s==NULL){ //插入在链表的表尾r->next=t;t->next=NULL;}else{ //插入在链表的中间t->next=r->next;r->next=t;}}void Out(LinkList *head){ //输出表中的数据LinkList *L;L=head->next;printf("表中的数据:");for(;L;L=L->next){printf("%d ",L->data);}printf("\n");}int main(void){LinkList *head;int x;head=CreatList();Out(head);printf("请输入要插入的数据:");scanf("%d",&x);Add(head,x);Out(head);return 0;}实验七#include<stdio.h>#include<stdlib.h>typedef struct node{int data;struct node *next;}LinkList;typedef struct{LinkList *rear;}LinkQueue;LinkQueue *SetQueue(){ //建立空的队列LinkQueue *Q;LinkList *head;Q=(LinkQueue *)malloc(sizeof(LinkQueue));head=(LinkList *)malloc(sizeof(LinkQueue));head->data=-1;head->next=head;Q->rear=head;return Q;}int QueueEmpty(LinkQueue *Q){ //检验对列是否为空LinkList *p;p=Q->rear;if(p->data==-1){return 1;}elsereturn 0;}LinkQueue *Add(LinkQueue *Q,int x){ //数据入队LinkList *p;p=(LinkList *)malloc(sizeof(LinkList));p->data=x;p->next=Q->rear->next;Q->rear->next=p;Q->rear=p;return Q;}void Out(LinkQueue *Q){ //数据出队LinkList *p1,*p2;p1=Q->rear;p2=Q->rear;p2=p2->next;p1=p2->next;if(p1->data==-1){printf("队列为空");return;}printf("出队的数据是%d\n",p1->data);p2->next=p1->next;}LinkQueue *SetNull(LinkQueue *Q){ //队列置空Q->rear=Q->rear->next;Q->rear->next=Q->rear;return Q;}int main(void){LinkQueue *Q=NULL;int choice,x,i;printf("1，建立空队列2，数据入队3，数据出队4，置队空5，检验队空0,退出\n");do{printf("\n请输入选择:");scanf("%d",&choice);switch(choice){case 1:Q=SetQueue();printf("已建立空队列\n");break;case 2:printf("请输入要入队的数据:");scanf("%d",&x);Q=Add(Q,x);break;case 3:Out(Q);break;case 4:Q=SetNull(Q);printf("队列已置空");break;case 5:i=QueueEmpty(Q);if(i==1)printf("队列为空\n");elseprintf("队列未空\n");break;case 0:break;}}while(choice!=0);return 0;}实验八#include<stdio.h>#define SIZE 100void zhuanzhi(int sa[],int n){ //转置函数int m,t;for(int i=0;i<3*n-2;i++){if(i%3!=0){m=i+1;t=sa[i];sa[i]=sa[m]; //交换对称的两个数据sa[m]=t;i++; //跳过矩阵的下三角数据} //矩阵对角线上的数据不进行操作}}void JPrintf(int sa[],int n){ //输出函数int i,j;for(i=1;i<=n;i++){for(j=1;j<=n;j++){if(i==j-1||i==j||i==j+1){ //i==j-1 对角线下方的元素i==j对角线上的元素i==j+1对角线上方的元素printf(" %d",sa[2*i+j-3]);//非零元素在数据中的下标为2*i+j-3}elseprintf(" 0");}printf("\n");}}int main(void){int n,sa[SIZE];printf("请输入三对角矩阵的阶数:");scanf("%d",&n);printf("请依次输入三对角矩阵中的非零数据:");for(int i=0;i<3*n-2;i++){ //三对角矩阵共有3*n-2g个非零元素scanf("%d",&sa[i]);}JPrintf(sa,n);zhuanzhi(sa,n);printf("转置后的矩阵：\n");JPrintf(sa,n);return 0;}实验九#include<stdio.h>#include<stdlib.h>#define maxsize 10typedef struct node{char data;struct node *lchild,*rchild;}Bitree;Bitree *Q[maxsize]; //使用队列临时记录节点地址Bitree *Creatree(){ //建立一个二叉树char ch;int front,rear;Bitree *T,*s;T=NULL;front=1;rear=0;printf("请输入一个二叉树(以#号结束):");ch=getchar();while(ch!='#'){ //以输入“#”结束输入s=NULL;if(ch!='@'){ //输入“@”表示虚节点s=(Bitree *)malloc(sizeof(Bitree)); //如果不是虚节点就建立新节点s->data=ch;s->lchild=s->rchild=NULL;}rear++;Q[rear]=s;if(rear==1) //输入的第一个节点为根节点T=s;else{if(s!=NULL&&Q[front]!=NULL)if(rear%2==0) //若rear为偶数则该节点为父节点的左孩子，否则为右孩子Q[front]->lchild=s;elseQ[front]->rchild=s;if(rear%2==1)front++;}ch=getchar();}return T;}void visite(Bitree *T,int *m){if(T->lchild==NULL&&T->rchild==NULL){ //没有左孩子也没有右孩子就是叶子节点(*m)++;}}void Preorder(Bitree *T,int *m){ //使用递归遍历二叉树if(T){visite(T,m); //访问根节点Preorder(T->lchild,m);Preorder(T->rchild,m);}}int main(void){int *m,n=0;m=&n; //使用一个指针用于记录叶子节点的个数Bitree *T;T=Creatree();Preorder(T,m);printf("该二叉树的叶子节点数：%d\n",n);return 0;}实验十#include<stdio.h>#include<stdlib.h>#define maxsize 10typedef struct node{char data;struct node *lchild,*rchild;}Bitree;Bitree *Q[maxsize]; //使用队列临时记录节点地址Bitree *Creatree(){ //建立一个二叉树char ch;int front,rear;Bitree *T,*s;T=NULL;front=1;rear=0;printf("请输入一个二叉树(以#号结束):");ch=getchar();while(ch!='#'){ //以输入“#”结束输入s=NULL;if(ch!='@'){ //输入“@”表示虚节点s=(Bitree *)malloc(sizeof(Bitree)); //如果不是虚节点就建立新节点s->data=ch;s->lchild=s->rchild=NULL;}rear++;Q[rear]=s;if(rear==1) //输入的第一个节点为根节点T=s;else{if(s!=NULL&&Q[front]!=NULL)if(rear%2==0) //若rear为偶数则该节点为父节点的左孩子，否则为右孩子Q[front]->lchild=s;elseQ[front]->rchild=s;if(rear%2==1)front++;}ch=getchar();}return T;}void visite(Bitree *T,char m[]){ //把中序遍历的数据保存到数据m中int i=0;while(m[i]!='*'){ // * 是数组的结束标志i++;}m[i]=T->data;m[i+1]='*';}void Inorder(Bitree *T,char m[]){ //中序遍历递归算法if(T){Inorder(T->lchild,m);visite(T,m);Inorder(T->rchild,m);}}int Pan(char m[]){int i=0,j=0; //j==0是表示是二叉树while(m[i+1]!='*'){if(m[i]>m[i+1]){j=1; //j==1是表示不是二叉树break;}i++;}return j;}int main(void){Bitree *T;int j;T=Creatree();char m[50];m[0]='*';Inorder(T,m);j=Pan(m);if(j==1){printf("该二叉树不是二叉排序树\n");}elseprintf("该二叉树是二叉排序树\n");return 0;}实验十一#include<stdio.h>#include<stdlib.h>#include<iostream.h>#define MAX_VERTEX_NUM 100/* 临接表的数据类型定义*/typedef struct node{int adjvex; //邻接点位置struct node *nextarc; //指向下一个结点char info; //边得信息}ARCNODE;typedef struct VEXNODE{char vexdata; //顶点信息ARCNODE *firstarc; //指向第一个邻接点}VEXNODE,AdjList[MAX_VERTEX_NUM];typedef struct{ //邻接表类型AdjList vextices;int vexnum,arcnum; //顶点数目，边数目}ALGraph;ALGraph create_AdjListGraph(){ //建立邻接表int n,e,i,j,k;ALGraph alg;ARCNODE *p,*q;printf("请输入顶点数:");scanf("%d",&n);for(i=0;i<=n;i++){ //初始化邻接表alg.vextices[i].vexdata=(char)i;alg.vextices[i].firstarc=NULL;}printf("请输入边数:");scanf("%d",&e);printf("请输入图的信息：\n");for(i=0;i<e;i++){ //建立无向图的邻接表scanf("%d%d",&j,&k); //输入边的信息p=(ARCNODE *)malloc(sizeof(ARCNODE));p->adjvex=k;p->info=' ';p->nextarc=alg.vextices[j].firstarc; //把节点接到链表上alg.vextices[j].firstarc=p;q=(ARCNODE *)malloc(sizeof(ARCNODE));q->adjvex=j;q->info=' ';q->nextarc=alg.vextices[k].firstarc; //把节点接到链表上alg.vextices[k].firstarc=q;}alg.vexnum=n;alg.arcnum=e;return alg;}/* 邻接矩阵的数据类型定义*/typedef struct{int num; //顶点序号char data; //顶点数据}VERTEX;typedef struct{ //邻接矩阵类型int n; //顶点数目int e; //边的数目VERTEX vexs[MAX_VERTEX_NUM]; //存储顶点int edges[MAX_VERTEX_NUM][MAX_VERTEX_NUM];//邻接矩阵，存储边}MGraph;MGraph *ALG_MG(ALGraph alg){ //邻接表转化为邻接矩阵MGraph *mg;ARCNODE *arc;mg=(MGraph *)malloc(sizeof(MGraph));mg->n=alg.vexnum;mg->e=alg.arcnum;int i,j;for(i=0;i<=alg.vexnum;i++) //初始化邻接矩阵for(j=0;j<=alg.vexnum;j++){mg->edges[i][j]=0;}for(i=1;i<=alg.vexnum;i++){mg->vexs[i].num=i; //依次从邻接表中把顶点信息读入到邻接矩阵中mg->vexs[i].data=alg.vextices[i].vexdata;arc=alg.vextices[i].firstarc;for(;arc!=NULL;arc=arc->nextarc){ //从邻接表中把边得信息读入到邻接矩阵中mg->edges[i][arc->adjvex]=1;}}return mg;}void Palg(ALGraph G){ //输出邻接表int i,j;ARCNODE *p;printf("输出图为:\n");for(i=1;i<=G.vexnum;i++){p=G.vextices[i].firstarc;j=0;while(p!=NULL){printf("(%d,%d)",i,p->adjvex);p=p->nextarc;j=1;}if(j==1)cout<<endl;}}void Pmg(MGraph *mg){ //输出邻接矩阵for(int i=1;i<=mg->n;i++){ //遍历邻接矩阵for(int j=1;j<=mg->n;j++){printf("%d ",mg->edges[i][j]);}printf("\n");}}int main(void){ALGraph alg;MGraph *mg;alg=create_AdjListGraph();Palg(alg);mg=ALG_MG(alg);printf("转化为邻接矩阵为:\n");Pmg(mg);return 0;}实验十二#include<stdio.h>#include<string.h>#define MAX 50typedef struct{ //学生信息结构char name[20];char id[10];int age;char address[20];char tel[15];}PersonInfo;typedef struct{ //班级信息结构PersonInfo person[MAX];char classid[10];int count;}ClassInfo;int xCinfo(ClassInfo Cinfo[]){ //寻找班级号对应的下标char cid[10];printf("请输入班级号:");scanf("%s",cid);strcpy(Cinfo[0].classid,cid);for(int i=1;Cinfo[i].count>0;i++);i--;for(;i>0;i--){if(strcmp(Cinfo[i].classid,cid)==0)break;}if(i==0){printf("不存在该班级\n");return -1;}elsereturn i;}void inSinfo(ClassInfo Cinfo[]){PersonInfo si;int i;i=xCinfo(Cinfo);if(i==-1)return;printf("请输入学生姓名:");scanf("%s",);printf("请输入学生学号:");scanf("%s",si.id);printf("请输入学生年龄:");scanf("%d",&si.age);printf("请输入学生宿舍号:");scanf("%s",si.address);printf("请输入学生电话:");scanf("%s",si.tel);for(int j=1;Cinfo[i].person[j].age>0;j++);Cinfo[i].person[j]=si;Cinfo[i].person[j+1].age=-1;Cinfo[i].count++;printf("信息已插入\n");}void CreateClass(ClassInfo Cinfo[]){ //建立班级ClassInfo ci;printf("请输入班号:");scanf("%s",ci.classid);printf("请输入班级成员总数:");scanf("%d",&ci.count);for(int i=1;Cinfo[i].count>0;i++);Cinfo[i]=ci;for(int j=1;j<=Cinfo[i].count;j++){ //输入学生信息printf("请输入学生姓名:");scanf("%s",Cinfo[i].person[j].name);printf("请输入学生学号:");scanf("%s",Cinfo[i].person[j].id);printf("请输入学生年龄:");scanf("%d",&Cinfo[i].person[j].age);printf("请输入学生宿舍号:");scanf("%s",Cinfo[i].person[j].address);printf("请输入学生电话:");scanf("%s",Cinfo[i].person[j].tel);printf("\n");}Cinfo[i+1].count=-1;}int xSinfo(ClassInfo Cinfo[],int i){//寻找学号对应的下标char sid[10];printf("请输入学生的学号:");scanf("%s",sid);int j;for(j=Cinfo[i].count;j>0;j--){if(strcmp(Cinfo[i].person[j].id,sid)==0)break;}if(j==0){printf("不存在该学号的学生");return -1;}elsereturn j;}void OutSinfo(ClassInfo Cinfo[]){ //输入学生的信息int i;i=xCinfo(Cinfo);if(i==-1)return;int j;j=xSinfo(Cinfo,i);if(j==-1)return;else{printf("该学生的信息:\n");printf("学号:%s\n",Cinfo[i].person[j].id);printf("姓名:%s\n",Cinfo[i].person[j].name);printf("年龄:%d\n",&Cinfo[i].person[j].age);printf("宿舍:%s\n",Cinfo[i].person[j].address);printf("电话:%s\n",Cinfo[i].person[j].tel);}}void OutCinfo(ClassInfo Cinfo[]){//输入班级信息int i;i=xCinfo(Cinfo);if(i==-1)return;else{printf("班级号:%s\n",Cinfo[i].classid);printf("成员总数:%d\n",Cinfo[i].count);printf("学生信息:\n");for(int j=1;j<=Cinfo[i].count;j++){ //输入班级中学生的信息printf("学号:%s\n",Cinfo[i].person[j].id);printf("姓名:%s\n",Cinfo[i].person[j].name);printf("年龄:%d\n",&Cinfo[i].person[j].age);printf("宿舍:%s\n",Cinfo[i].person[j].address);printf("电话:%s\n",Cinfo[i].person[j].tel);printf("\n");}}}void DelCinfo(ClassInfo Cinfo[]){ //删除班级信息int i;i=xCinfo(Cinfo);if(i==-1)return;else{for(;Cinfo[i].count>0;i++){Cinfo[i]=Cinfo[i+1];}printf("信息已删除\n");}}void DelSinfo(ClassInfo Cinfo[]){ //删除学生信息int i,j;i=xCinfo(Cinfo);if(i==-1){return;}else{j=xSinfo(Cinfo,i);if(j==-1)return;else{for(;j<=Cinfo[i].count;j++){Cinfo[i].person[j]=Cinfo[i].person[j+1];}Cinfo[i].count--;printf("信息已删除\n");}}}void UpdataCinfo(ClassInfo Cinfo[]){ //修改班级信息int i;i=xCinfo(Cinfo);if(i==-1)return;printf("请输入修改后的班号:");scanf("%s",Cinfo[i].classid);printf("信息已修改\n");}void UpdataSinfo(ClassInfo Cinfo[]){ //修改学生信息int i,j;i=xCinfo(Cinfo);if(i==-1){return;}j=xSinfo(Cinfo,i);if(j==-1){return;}printf("请输入学生姓名:");scanf("%s",Cinfo[i].person[j].name);printf("请输入学生学号:");scanf("%s",Cinfo[i].person[j].id);printf("请输入学生年龄:");scanf("%d",&Cinfo[i].person[j].age);printf("请输入学生宿舍号:");scanf("%s",Cinfo[i].person[j].address);printf("请输入学生电话:");scanf("%s",Cinfo[i].person[j].tel);printf("信息已修改\n");}void Infile(ClassInfo Cinfo[]){ //把信息写入文件FILE *fp;int i=1;if((fp=fopen("Cinfo1.txt","wb"))==NULL){printf("打开文件失败\n");return;}for(;Cinfo[i].count>0;i++){if(fwrite(&Cinfo[i],sizeof(ClassInfo),1,fp)!=1)printf("文件写入失败\n");}fclose(fp);}void Outfile(ClassInfo Cinfo[]){ //把文件中的信息写入到程序FILE *fp;int i=1;if((fp=fopen("Cinfo1.txt","rb"))==NULL){printf("打开文件失败\n");return;}for(;!feof(fp);i++){fread(&Cinfo[i],sizeof(ClassInfo),1,fp);}fclose(fp);}int main(void){int choice;ClassInfo Cinfo[MAX];printf("--------------------菜单----------------------\n");printf("1,建立班级 2，插入学生信息3，显示班级信息\n");printf("4，显示学生信息5，删除班级6，删除学生信息\n");printf("7,修改班级信息 8，修改学生信息9,写入文件\n");printf("10,载入文件0，退出\n");do{printf("\n请输入选择:"); //分别调用不同的函数实现不同的功能scanf("%d",&choice);switch(choice){case 1:CreateClass(Cinfo);break;case 2:inSinfo(Cinfo);break;case 3:OutCinfo(Cinfo);break;case 4:OutSinfo(Cinfo);break;case 5:DelCinfo(Cinfo);break;case 6:DelSinfo(Cinfo);break;case 7:UpdataCinfo(Cinfo);break;case 8:UpdataSinfo(Cinfo);break;case 9:Infile(Cinfo);printf("保存文件成功\n");break;case 10:Outfile(Cinfo);printf("载入成功\n");break;case 0:break;}}while(choice!=0);return 0;}。

《数据结构》实验指导书(有代码)

数据结构实验指导书东华大学计算机科学与技术学院2009年9月目录前言 (1)一、概述 (1)二、实验步骤 (2)三、实验报告规范 (5)四、算法书写规范 (6)五、参考书目 (9)实验〇顺序表与链表 (10)实验〇实验报告示例 (12)实验一线性表 (25)实验报告示例：集合的并、交和差运算 (28)实验二栈和队列 (42)实验报告示例：迷宫问题 (45)实验三树和二叉树 (57)实验四图 (60)实验五查找 (63)实验六排序 (65)实验七综合设计性实验——航班信息的查询与检索 (67)前言一、概述上机实验是对学生的一种全面综合训练，是与课堂听讲、自学和练习相辅相成的必不可少的一个教学环节。

通常，实验题中的问题比平时的习题复杂得多，也更接近实际。

实验着眼于原理与应用的结合点，使读者学会如何把书上学到的知识用于解决实际问题，培养软件工作所需要的动手能力；另一方面，能使书上的知识变“活”，起到深化理解和灵活掌握教学内容的目的。

平时的练习较偏重于如何编写功能单一的“小”算法，而实验题是软件设计的综合训练，包括问题分析、总体结构设计、用户界面设计、程序设计基本技能和技巧，多人合作，以至一整套软件工作规范的训练和科学作风的培养。

此外，还有很重要的一点是：机器是比任何教师都严厉的检查者。

为了达到上述目的，本指导书安排了七个主实验单元（其中除实验0作为预备练习，训练数组和链表的编程方法和编程技巧），其它各单元的训练重点在于基本的数据结构，而不强调面面俱到。

各实验单元与教科书的各章只具有粗略的对应关系，一个实验题常常涉及几部分教学内容。

在每个实验单元中安排有难度不等的实验题，经验表明，如果某题的难度略高于自己过去所对付过的最难题目的难度，则选择此题能够带来最大的收益。

切忌过分追求难题或者容易的题目。

一些实验题采取了统一的格式（其余的实验题由于比较简单，没有这么详细列出来，读者可举一反三），由问题描述、基本要求、测试数据、实现提示和选做内容五个部分组成。

数据结构实验与实训教程源代码

i
第一部分预备知识
预备知识
例 1．1 #include <stdio.h> int sumabc(int a, int b, int c) /* 求三个整数之和*/ { int s; a=b+c; s=a+b+c; return s; } void displayLine(void) { printf(”----------------------\n“); } void main( ) { int x,y, z ,sabc; x=y=z=8; display(); /* 画一条线 */ printf(“\n sum=%d”,sumabc(x,y,z)); /* 在输出语句中直接调用函数 sumabc( ) */ printf(“\n %6d%6d%6d”,x,y,z); display();/* 画一条线 */ x=2; y=4; z=6; sabc =sumabc(x, y, z); /* 在赋值语句中调用函数 sumabc( ) */ printf(“\n “ sum=%d”, sabc); printf(“\n %6d%6d%6d”,x,y,z); display();/* 画一条线 */ } 例 1.2 int sumabc(int *a, int b, int c) { int s; *a=b+c; s=*a+b+c;
2
}//while（1） }//main
3
第二部分基础实验
实验 1 线性表的基本操作
四、参考程序
程序 1：题 1 线性表基本操作函数 #include<stdio.h> #include<stdlib.h> #include<alloc.h> struct LinearList ／*定义线性表结构*/ { int *list; /* 存线性表元素 */ int size; /* 存线性表长度 */ int MaxSize; /* 存 list 数组元素个数 */ }; typedef struct LinearList LIST; void InitList( LIST *L, int ms ) /* 初始化线性表 */ { if( (L->list = 1 ) == NULL ) { printf( "内存申请错误!\n" ); exit( 1 ); } 2 L->MaxSize = ms; } int InsertList( LIST *L, int /* item:记录值 rc:插入位置 { int i; if( 3 ) return -1; if( rc < 0 ) item, int rc ) */备知识实验

数据结构实验源代码

数据结构实验源代码第二章线性表标题：约瑟夫环约瑟夫环编号为 1，2， 3，⋯⋯， n 的 n 个人按顺时针方向围坐一圈。

任选一个正整数作为报数上限m，从第一个人开始按顺时针方向自 1 开始顺序报数，描述：报到 m时停止报数。

报 m的人出列，从他在顺时针方向上的下一个人开始重新从 1 报数，如此下去，直至所有人全部出列为止。

设计程序输出出列顺序。

人数 n 报数上限m人员记录 1 ( 格式为：姓名学号性别年龄班级健康状况)输入：人员记录2输出：⋯人员记录n第 1 次报数出列的人员记录第 2 次报数出列的人员记录⋯第 n 次报数出列的人员记录5 3安弥邵 10000001女28计43一般宰觅 10000002男23计79健康输入样例：顾健 10000003男27计29一般宓顽芳 10000004女20计17健康能纸垄 10000005男18计11健康顾健10000003男27计 29一般安弥邵10000001女28计 43一般输出样例：能纸垄10000005男18计 11健康宰觅10000002男23计 79健康宓顽芳10000004女20计 17健康提示：循环表#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> // exit()//函数结果状态代码#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 typedef int Boolean; // Boolean 是函数的类型 ,其值是函数结果状态代码，如是布尔类型 ,其值是 TRUE 或 FALSEOK等struct stud{char name[12];char num[12];char sex[4];int age;char clas[10];char health[16];};typedef stud ElemType;typedef struct LNode{ElemType date;struct LNode *next;}LNode,*LinkList;void CreateList2(LinkList &L,int n){ // 正位序 (插在表尾 )输入 n 个元素的值，建立带表头结构的单链线性表int i;LinkList p,q;L=(LinkList)malloc(sizeof(LNode)); // 生成头结点 q=L;scanf("%s%s%s%d%s%s",L->,L->date.num,L->date.sex,&L->date .age,L->date.clas,L->date.health);for(i=1;i < n;i++){p=(LinkList)malloc(sizeof(LNode));scanf("%s%s%s%d%s%s",p->,p->date.num,p->date.sex,&p->date .age,p->date.clas,p->date.health);q->next=p;q=q->next;}p->next=L;}void run(LinkList L,int m){int i;LinkList p,q;p = L;while (p){for(i = 1 ;i < m;i++){q = p;p = p->next;}printf("%s %s %s %d %s %s\n",p->,p->date.num,p->date.sex,p->d ate.age,p->date.clas,p->date.health);q->next=p->next;free(p);p = q->next;if(p==p->next){break;}}printf("%s %s %s %d %s %s",p->,p->date.num,p->date.sex,p->dat e.age,p->date.clas,p->date.health);printf("\n");free(p);// 要将 P 释放掉，应为在前面L 已经被释放掉}int main(){int n,m;LinkList La;标题学生信息管理：描用链式存储结构实现对一个班级学生信息管理。

数据结构实验源代码

数据结构实验源代码【附】数据结构实验源代码范本一、实验背景与目的1.1 实验背景在计算机科学中，数据结构是指数据元素之间的关系，以及为操作这些数据元素所提供的方法。

数据结构对于程序的设计和性能优化具有重要影响。

1.2 实验目的本实验旨在通过编写和实现不同的数据结构，加深学生对数据结构的理解，掌握基本的数据结构操作方法。

二、实验内容2.1 线性表2.1.1 顺序表2.1.1.1 初始化顺序表2.1.1.2 插入元素到顺序表2.1.1.3 删除顺序表中的元素2.1.1.4 遍历顺序表2.1.1.5 查找指定元素在顺序表中的位置2.1.2 链表2.1.2.1 初始化链表2.1.2.2 插入元素到链表2.1.2.3 删除链表中的元素2.1.2.4 遍历链表2.1.2.5 查找指定元素在链表中的位置2.2 栈2.2.1 初始化栈2.2.2 进栈操作2.2.3 出栈操作2.2.4 获取栈顶元素2.2.5 判断栈是否为空2.3 队列2.3.1 初始化队列2.3.2 入队操作2.3.3 出队操作2.3.4 获取队首元素2.3.5 判断队列是否为空三、实验步骤3.1 线性表实现在实现顺序表和链表时，首先需要定义数据结构和所需的操作函数。

然后进行初始化、添加元素、删除元素等操作。

最后进行遍历和查找操作，并检验实验结果是否符合预期。

3.2 栈实现栈的实现过程与线性表类似，需要定义栈的数据结构和所需的函数，然后进行初始化、进栈、出栈等操作。

3.3 队列实现队列的实现也与线性表类似，需要定义队列的数据结构和函数，进行初始化、入队、出队等操作。

四、数据结构实验源代码以下是实验代码的源代码范本，包括线性表、栈和队列的实现。

（代码略，如需获取，请查看附件）五、附件本文档附带的附件为数据结构实验源代码。

六、法律名词及注释6.1 数据结构：计算机科学中，数据结构是指数据元素之间的关系，以及为操作这些数据元素所提供的方法。

6.2 顺序表：一种物理上相邻的存储结构，元素按照顺序依次存放。

数据结构图实验实验代码

1.邻接矩阵作为存储结构：#include <stdio.h>#include <stdlib.h>#define MaxVertexNum 100typedef struct{char verxs[MaxVertexNum];int edges[MaxV ertexNum][MaxVertexNum];int n,e;}MGraph;void creatMGraph(MGraph *G){int i,j,k;char a;printf("Input VertexNum(n)andEdgesNum(e):");scanf("%d,%d",&G->n,&G->e);scanf("%c",&a);printf("Input Vertex string");for(i=0;i<G->n;i++){scanf("%c",&a);G->verxs[i]=a;}for(i=0;i<G->n;i++)for(j=0;j<G->n;j++)G->edges[i][j]=0;printf("Input edges,Creat Adjacency Matrix\n");for(k=0;k<G->e;k++){scanf("%d%d",&i,&j);G->edges[i][j]=1;G->edges[j][i]=1;}}typedef enum{FALSE,TRUE}Boolean;Boolean visited[MaxVertexNum];void DFSM(MGraph*G,int i){int j;printf("%c",G->verxs[i]);visited[i]=TRUE;for(j=0;j<G->n;j++)if(G->edges[i][j]==1&&!visited[j])DFSM(G,j);}void DFS(MGraph*G){int i;for(i=0;i<G->n;i++)visited[i]=FALSE;for(i=0;i<G->n;i++)if(!visited[i])DFSM(G,i);}void BFS(MGraph*G,int k){int i,j,f=0,r=0;int cq[MaxVertexNum];for(i=0;i<G->n;i++)visited[i]=FALSE;for(i=0;i<G->n;i++)cq[i]=-1;printf("%c",G->verxs[k]);visited[k]=TRUE;cq[r]=k;while(cq[f]!=-1){ i=cq[f];f=f+1;for(j=0;j<G->n;j++)if(G->edges[i][j]==1&&!visited[j]){printf("%c",G->verxs[j]);visited[j]=TRUE;r=r+1;cq[r]=j;}}}void main(){int i;MGraph*G;G=(MGraph*)malloc(sizeof(MGraph));creatMGraph(G);printf("Print Graph DFS:");DFS(G);printf("\n");printf("Print Graph BFS:");BFS(G,3);printf("\n");}2.邻接链表作为存储结构：#include"stdio.h"#include"stdlib.h"#define MaxVertexNum 50 /*定义最大顶点数*/typedef struct node{ /*边表结点*/int adjvex; /*邻接点域*/struct node *next; /*链域*/}EdgeNode;typedef struct vnode{ /*顶点表结点*/char vertex; /*顶点域*/EdgeNode *firstedge; /*边表头指针*/}VertexNode;typedef VertexNode AdjList[MaxVertexNum]; /*AdjList是邻接表类型*/ typedef struct {AdjList adjlist; /*邻接表*/int n,e; /*图中当前顶点数和边数*/} ALGraph; /*图类型*//* 建立图的邻接表*/void CreatALGraph(ALGraph *G){int i,j,k;char a;EdgeNode *s; /*定义边表结点*/printf("Input VertexNum(n)andEdgesNum(e): ");scanf("%d,%d",&G->n,&G->e); /*读入顶点数和边数*/scanf("%c",&a);printf("Input Vertex string:");for(i=0;i<G->n;i++) /*建立边表*/{scanf("%c",&a);G->adjlist[i].vertex=a; /*读入顶点信息*/G->adjlist[i].firstedge=NULL; /*边表置为空表*/}printf("Input edges,Creat Adjacency Matrix\n");for(k=0;k<G->e;k++) { /*建立边表*/scanf("%d%d",&i,&j); /*读入边（Vi，Vj）的顶点对序号*/s=(EdgeNode *)malloc(sizeof(EdgeNode)); /*/生成边表结点*/s->adjvex=j; /*邻接点序号为j*/s->next=G->adjlist[i].firstedge;G->adjlist[i].firstedge=s; /*将新结点*S插入顶点Vi的边表头部*/s=(EdgeNode *)malloc(sizeof(EdgeNode));s->adjvex=i; /*邻接点序号为i*/s->next=G->adjlist[j].firstedge;G->adjlist[j].firstedge=s; /*将新结点*S插入顶点Vj的边表头部*/}}/* 定义标志向量，为全局变量*/typedef enum{FALSE,TRUE} Boolean;Boolean visited[MaxVertexNum];/* DFS：深度优先遍历的递归算法*/void DFSM(ALGraph *G,int i){ /*以Vi为出发点对邻接链表表示的图G进行DFS搜索*/ EdgeNode *p;printf("%c ",G->adjlist[i].vertex); /*访问顶点Vi*/visited[i]=TRUE; /*标记Vi已访问*/p=G->adjlist[i].firstedge; /*取Vi边表的头指针*/while(p) { /*依次搜索Vi的邻接点Vj，这里j=p->adjvex*/if(! visited[p->adjvex]) /*若Vj尚未被访问*/DFSM(G,p->adjvex); /*则以Vj为出发点向纵深搜索*/ p=p->next; /*找Vi的下一个邻接点*/}}void DFS(ALGraph *G){int i;for(i=0;i<G->n;i++)visited[i]=FALSE; /*标志向量初始化*/for(i=0;i<G->n;i++)if(!visited[i]) /*Vi未访问过*/DFSM(G,i); /*以Vi为源点开始DFS搜索*/}/* BFS：广度优先遍历*/void BFS(ALGraph *G,int k){ /*以Vk为源点对用邻接链表表示的图G进行广度优先搜索*/int i,f=0,r=0;EdgeNode *p;int cq[MaxVertexNum]; /*定义FIFO队列*/for(i=0;i<G->n;i++)visited[i]=FALSE; /*标志向量初始化*/for(i=0;i<=G->n;i++)cq[i]=-1; /*初始化标志向量*/printf("%c ",G->adjlist[k].vertex); /*访问源点Vk*/visited[k]=TRUE;cq[r]=k; /*Vk已访问，将其入队。

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

实验一线性表的链式存储结构一、实验目的：1．掌握线性表的链式存储结构。

2．熟练地利用链式存储结构实现线性表的基本操作。

3．能熟练地掌握链式存储结构中算法的实现。

二、实验内容：1．用头插法或尾插法建立带头结点的单链表。

2．实现单链表上的插入、删除、查找、修改、计数、输出等基本操作。

三、实验要求：1. 根据实验内容编写程序，上机调试、得出正确的运行程序。

2. 写出实验报告（包括源程序和运行结果）。

四、实验学时：2学时五、实验步骤：1．进入编程环境，建立一新文件；2. 参考以下相关内容，编写程序，观察并分析输出结果。

②部分参考程序//单链表的建立(头插法)，插入，删除，查找、修改、计数、输出#include<iostream.h>#define elemtype intstruct link{ elemtype data；//元素类型link *next；//指针类型，存放下一个元素地址};//头插法建立带头结点的单链表link *hcreat(){ link s,p;elemtype i;cout<<”输入多个结点数值(用空格分隔)，为0时算法结束”；cin>>i；p=new link；p->next=NULL；while(i) //当输入的数据不为0时，循环建单链表{s=new link；s->data=i；s->next=p->next；p->next=s；cin>>i；}return p；}//输出单链表void print(1ink *head){1ink *p；p=head->next；while(p->next!=NULL){cout<<p->data<<”->”；//输出表中非最后一个元素p=p->next；}cout<<p->data；//输出表中最后一个元素cout<<endl；}∥在单链表head中查找值为x的结点Link *Locate(1ink *head，elemtype x){Link *p；p=head->next；while((p!=NULL)&&(p->data!=x))p=p->next；return p；}//在head为头指针的单链表中，删除值为x的结点void deletel(1ink *head，elemtype x){1ink *p，*q；q=head；p=head->next；while((p!=NULL)&&(p->data!=x)){q=p；p=p->next；}If(p==NULL) cout<<“要删除的结点不存在”；elseq->next=p ->next；}}//在头指针head所指的单链表中，在值为x的结点之后插入值为y的结点void insert(1ink *head，elemtype x，elemtype y)｛link *p，*s；s=new link；s->data=y；if(head->next==NULL) //链表为空{head->next=s；s->next=NULL：}p=Locate(head，x)；//调用查找算法‘if(p==NULL)cout<<”插入位置非法”：else(s->next=p->next；p->next=s；}}//将单链表p中所有值为x的元素修改成yvoid change(1ink *p,elemtype x,elemtype y){link *q；q=p->next；while(q!=NULL){ if(q->data==x) q->data=y；q=q->next；}}void count(1ink *h) //统计单链表中结点个数{1ink *p；int n=0；p=h->next；while(p!=NULL){n++；p=p->next；}return n;}void main()elemtype x，y；link *p，*q；p=hcreat()；//头插法建立链表print(p)；//输出刚建立的单链表cout<<”请输入要删除的元素”；cin>>y；deletel(p，y)；print(p)；//输出删除后的结果cout<<”请输入插入位置的元素值(将待插元素插入到它的后面)”;cin>>x；cout<<”请输入待插元素值”；cin>>y；insert(p，x，y)；print(p)；//输出插入后的结果cout<<”请输入要修改前、后的元素值”;cin>>x>>y；change(p，x，y)；print(p)；cout<<”请输入要查找的元素值”；cin>>x；q=Locate(p，x)；if(q==NULL)cout<<x<<”不在表中，找不到!”<<endl；else cout<<x<<”在表中，已找到!”<<endl；n=count(p)；cout<<”链表中结点个数为：”<<n<<endl：}//单链表的建立(尾插法)、插入、删除、查找、修改、计数、输出#include<iostream.h>#define elemtype intstruct link{ elemtype data；//元素类型link *next；//指针类型，存放下-个元素地址}；//尾插法建立带头结点的单链表link *rcreat(){link *s，*p，*r；elemtype i；cout<<”输入多个结点数值(用空格分隔)，为0时算法结束”；p=r=new link；p->next=NULL；while(i){s=new link；s->data=i；r->next=s；r=s；cin>>i；}r->next=NULL；return p；}//输出单链表void print(1ink *head){link *p；p=head->next；while(p->next!=NULL){cout<<p->data<<"->”; //输出表中非最后一个元素p=p->next；)cout<<p->data；//输出表中最后一个元素cout<<endl；}link *Locate(1ink *head，int x) ∥在单链表中查找第x个结点{link *p；p=head；int j=0；while((p!=NULL)&&(j<x)){p=p->next; j++；}return p；}void delete I(1ink *head，elemtype x)//在head为头指针的单链表中，删除值为x的结点{link *p, *q；q=head；p=head->next；while((p!=NULL)&&(p->data!=x)){q=p；p=p->next；)if(p==NULL)cout<<”要删除的结点不存在“;else{q->next=p->next；delete(p)；} }void insert(1ink *head，int x,elemtype y)//在头指针head所指单链表中，在第x个结点之后插入值为y的结点{link *p，*s；s=new link；s->data=y；if(head->next==NULL)//链表为空{head->next=s；s->next=NULL：}p=Locate(head，x)；//调用查找算法if(p==NULL)cout<<”插入位置非法”;else{s->next=p->next；p->next=s；}}void change(1ink *p,elemtype x，elemtype y){∥将单链表P中所有值为x的元素改成值为ylink *q；q=p->next；while(q!=NULL){if(q->data==x)q->data=y；q=q->next；}}void count(1ink *h) //统计单链表中结点个数(1ink *p；int n=0；p=h->next；while(p!=NULL){n++；p=p->next；}retum n;}void main(){ int n;link p,q;p=rcreat()；//尾插法建立链表print(p)；//输出刚建立的单链表cout<<”请输入要删除的元素”；cin>>y；deletel(p，y)；print(p)；//输出删除后的结果cout<<”请输入插入位置”;cin>>x；cout<<”请输入待插元素值”；cin>>y；insert(p，x，y)；print(p)；//输出插入后的结果cout<<”请输入修改前、后的元素值”;cin>>x>>y；change(p，x，y)；print(p)；cout<<“请输入要查找的元素值”;cin>>x；q=Locate(p ,x)；if(q==NULL)cout<<x<<”不在表中,找不到!”<<endl；else cout<<x<<”在表中，已找到!”<<endl；n=count(p)；cout<<”链表中结点个数为：”<<n<endl;}六、选作实验试设计一元多项式相加（链式存储）的加法运算。

A（X）=7+3X+9X8+5X9B（X）=8X+22X7-9X81．建立一元多项式；2．输出相应的一元多项式；3．相加操作的实现。

数据结构实验指导书源代码

数据结构上机实验源代码

数据结构试验完整代码

数据结构与算法实验源代码

数据结构实验二的源代码

《数据结构》实验指导书(源代码)

数据结构课本算法源代码

数据结构实验指导书源程序附件

数据结构与算法实验源代码

数据结构实验四源代码

《数据结构》实验指导书(Java语言版).

数据结构c语言版实验及源代码

实验报告数据结构课程设计源代码

数据结构与算法实验源代码

《数据结构》实验指导书(有代码)

数据结构实验与实训教程源代码

数据结构实验源代码

数据结构实验源代码

数据结构 图实验 实验代码

数据结构图实验实验代码