★数据结构实验源代码william改后

合集下载

数据结构实验代码2

数据结构实验代码2第一点：数据结构实验代码2的背景与意义数据结构是计算机科学中至关重要的一个领域，它研究如何有效地存储、组织和管理数据，以及如何高效地执行相关操作。

在现代软件开发和计算机科学教育中，理解和掌握数据结构是不可或缺的。

数据结构实验代码2，作为一个具体的实践案例，旨在帮助学生深化对数据结构理论知识的理解，通过亲自动手编写和调试代码，增强对数据结构在实际应用中的认识。

实验代码2通常涉及到复杂的数据结构，比如图（Graph）、树（Tree）的高级算法实现，比如深度优先搜索（DFS）、广度优先搜索（BFS）、最短路径算法（如Dijkstra或Bellman-Ford算法）、最小生成树算法（如Prim或Kruskal算法）等。

通过对这些算法的实验实现，学生不仅能够掌握算法的工作原理，还能够理解其在解决实际问题时的效率和适用场景。

此外，数据结构实验代码2也是对学生编程能力和问题解决能力的一种锻炼。

在编写代码的过程中，学生需要考虑到算法的效率、空间复杂度，以及代码的可读性和可维护性。

这对于学生将来从事软件开发工作，具有重要的现实意义。

在当前的数字经济时代，数据结构的掌握程度直接关系到软件质量的高低和开发效率的快慢，因此，数据结构实验代码2在计算机科学与技术教育中占有举足轻重的地位。

第二点：数据结构实验代码2的关键技术与实现步骤数据结构实验代码2在技术实现上，涉及多个关键的步骤和考虑因素。

首先，学生需要选择合适的编程语言和开发环境，这对于代码的编写和调试都是非常重要的。

常见的编程语言如C/C++、Java、Python等，都具备实现复杂数据结构和算法的性能和灵活性。

接下来，是数据结构的具体实现。

这要求学生不仅要熟悉类和对象的概念，还需要能够设计出既符合数据结构特性，又能够有效实现算法逻辑的类和对象。

例如，在实现图的数据结构时，学生需要定义图的节点（Vertex）和边（Edge），并且提供添加节点、添加边、查找节点等基础操作。

数据结构上机实验源代码

数据结构上机实验源代码栈的应用十进制数转换为八进制数，逆序输出所输入的数实验代码：//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<<"建立失败。

数据结构实验系统源代码(期末作业)

/* 树子系统*/#include <stdio.h>#include <malloc.h> #define MAX 100int count=0; /* 定义计算结点个数的变量*/ typedef struct tnode{char data;struct tnode *lchild,*rchild;}BT;BT *CreateBTree(){BT *t;char ch;scanf("%c",&ch);getchar();if(ch=='0')t=NULL;else{t=(BT *)malloc(sizeof(BT));t->data=ch;printf("请输入％c结点的左孩子结点:t->lchild=CreateBTree();printf("请输入％c结点的右孩子结点:t->rchild=CreateBTree();}return t;}void ShowBTree(BT *T){ if (T!=NULL){ printf("%c",T->data);if(T->lchild!=NULL){ printf("(");ShowBTree(T->lchild);if(T->rchild!=NULL){ printf(",");ShowBTree(T->rchild);}printf(")");}else",t->data);",t->data/* 用广义表表示法显示二叉树*//*当二叉树非空时*//*输入该结点数据域*//* 若其左子树非空*//* 输入左括号*//* 递归调用该函数输出其左子树各结点*/ /* 若其右子树非空*//* 输出逗号*//* 递归调用该函数输出其右子树各结点*//* 二叉树左子树为空，右子树不为空时*/ if(T->rchild!=NULL){printf("(");ShowBTree(T->lchild);if(T->rchild!=NULL){ printf(",");ShowBTree(T->rchild);} printf(")");}}}void PreOrder(BT *T){ if(T==NULL) return;else{ printf("%c",T->data);PreOrder(T->lchild);PreOrder(T->rchild);}}void InOrder(BT *T){ if(T==NULL) return;else{ InOrder(T->lchild);printf("%c",T->data);InOrder(T->rchild);}}void PostOrder(BT *T){ if (T==NULL) return;else{ PostOrder(T->lchild);PostOrder(T->rchild);printf("%c",T->data);}}void LevelOrder(BT *T){ int f,r;BT *p,*q[MAX];p=T;/* 输入左括号*//* 递归调用该函数输出其左子树各结点*/ /* 若其右子树非空*//* 输出逗号*//*递归调用该函数输出其右子树各结点*//* 先序遍历二叉树T*//*递归调用的结束条件*//* 输出结点的数据域*//*先序递归遍历左子树*//*先序递归遍历右子树*//* 中序遍历二叉树T*//* 递归调用的结束条件*//* 中序递归遍历左子树*//* 输出结点的数据域*//* 中序递归遍历右子树*//* 后序遍历二叉树T*//* 递归调用的结束条件*//* 后序递归遍历左子树*//* 后序递归遍历右子树*//* 输出结点的数据域*//* 按层次遍历二叉树T*//* 定义队头队尾指针*//* 定义循环队列，存放结点指针*if(p!=NULL){ f=1; q[f]=p; r=2; } while(f!=r) { p=q[f];printf("%c",p->data); if(p->lchild!=NULL) { q[r]=p->lchild; r=(r+1)%MAX; }if(p->rchild!=NULL) { q[r]=p->rchild; r=(r+1)%MAX; }f=(f+1)%MAX; }}/* 若二叉树非空，则根结点地址入队*//* 队列不空时 *//* 访问队首结点的数据域 */ /* 将队首结点的左孩子入队 *//* 将队首结点的右孩子入队 */void Leafnum(BT *T) /* 求二叉树叶子结点数 */ { if(T)/* 若树不为空 */{ if(T->lchild==NULL && T->rchild==NULL)count++; Leafnum(T->lchild); Leafnum(T->rchild);} }/* 全局变量 count 为计数值，其初值为 0*/ /* 递归统计 T 的左子树叶子结点数 */ /* 递归统计 T 的右子树叶子结点数 */return rdep+1;void Nodenum(BT *T) { if(T) { count++;Nodenum(T->lchild); Nodenum(T->rchild);}} int TreeDepth(BT *T) { int ldep=0,rdep=0; 的深度 */ if(T==NULL) return 0; else { ldep=TreeDepth(T->lchild); rdep=TreeDepth(T->rchild); if(ldep>rdep)return ldep+1; else /* 若树不为空 *//* 全局变量 c ount 为计数值，其初值为0*/ /* 递归统计 T 的左子树结点数 */ /* 递归统计 T 的右子树结点数 *//* 求二叉树深度 *//* 定义两个整型变量，用以存放左、右子树/* 递归统计 T 的左子树深度 */ /* 递归统计 T 的右子树深度 */二叉树子系统");printf （"\n ================================================="）; printf （"\n| 1——建立一个新二叉树 |"）; printf （"\n| 2 --- 广义表表示法显示 |"）; printf （"\n| 3 --- 先序遍历 |"）; printf （"\n| 4 --- 中序遍历 |"）; printf （"\n| 5 --- 后序遍历 |"）; printf （"\n| 6 --- 层次遍历 |"）; printf （"\n| 7 --- 求叶子结点数目 |"）; printf （"\n| 8 --- 求二叉树总结点数目 |"）; printf （"\n| 9——求树深度 |"）; printf （"\n|0 --- 返回|"）;printf （"\n ================================================"）; printf （"\n 请输入菜单号（0-9 ）:"）;btree （）（BT *T=NULL; char ch1,ch2,a; ch1='y';while （ch1=='y'||ch1=='Y'） { MenuTree （）;scanf （"%c",&ch2）; getchar （）; switch （ch2） {case '1':printf （"请按先序序列输入二叉树的结点： \n"）;printf （"说明：输入结点后按回车（’0'表示后继结点为空）：\n"）; printf （"请输入根结点："）； T=CreateBTree （）;printf （"二叉树成功建立！ "）;break; case '2':printf （"二叉树广义表表示法如下： "）; ShowBTree （T ）;break; case '3':printf （"二叉树的先序遍历序列为： "）; PreOrder （T ）;break; case '4':printf(" 二叉树的中序遍历序列为： ");void （MenuTree （）/*显示菜单子函数*/printf （"\nInOrder(T);break;case '5':printf(" 二叉树的后序遍历序列为：");PostOrder(T);break;case '6':printf(" 二叉树的层次遍历序列为：");LevelOrder(T);break;case '7':count=0;Leafnum(T);printf("该二叉树有％~个叶子。

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

数据结构与算法实验源代码数据结构与算法实验源代码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 开源：指软件可以被任何人免费使用、分发和修改的一种软件授权模式。

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

数据结构课程设计代码

数据结构课程设计代码根据提供的输入输出需求，下面是一个示例的数据结构课程设计代码。

```pythonclass Node:def __init__(self, data):self.data = dataself.next = Noneclass LinkedList:def __init__(self):self.head = Nonedef add(self, data):new_node = Node(data)if self.head is None:self.head = new_nodeelse:current = self.headwhile current.next is not None:current = current.nextcurrent.next = new_nodedef remove(self, data):current = self.headprev = Nonewhile current is not None:if current.data == data:if prev is None:self.head = current.next else:prev.next = current.next returnprev = currentcurrent = current.nextdef display(self):current = self.headwhile current is not None:print(current.data, end=" ")current = current.nextprint()if __name__ == "__main__":linked_list = LinkedList()while True:print("1. Add element")print("2. Remove element")print("3. Display elements")print("4. Quit")choice = input("Enter your choice: ")if choice == "1":data = input("Enter element to add: ")linked_list.add(data)elif choice == "2":data = input("Enter element to remove: ")linked_list.remove(data)elif choice == "3":linked_list.display()elif choice == "4":breakelse:print("Invalid choice")```这个代码示例实现了一个简单的链表数据结构，在命令行中提供了添加元素、删除元素和显示元素的选项。

数据结构与算法实验源代码(2023最新版)

数据结构与算法实验源代码本文档为数据结构与算法实验源代码的范本，旨在帮助读者深入理解和实践数据结构和算法的相关知识。

下文将详细介绍各个章节的内容。

⒈引言- 简要介绍数据结构与算法的重要性和应用场景。

- 说明本文档的结构和目的。

⒉数据结构概述- 介绍数据结构的基本概念和分类。

- 详细介绍各种常见数据结构，如数组、链表、栈、队列、树等。

- 提供每种数据结构的定义、操作和应用示例。

⒊算法基础- 介绍算法的基本思想和特性。

- 详细讲解常见的算法设计方法，如递归、分治、贪心、动态规划等。

- 提供每种算法的原理、示例和分析。

⒋排序算法- 介绍各种排序算法的原理和实现方式。

- 包括冒泡排序、选择排序、插入排序、归并排序、快速排序等。

- 提供每种排序算法的时间复杂度和空间复杂度分析。

⒌查找算法- 介绍常用的查找算法，如顺序查找、二分查找、哈希查找等。

- 提供每种查找算法的原理和实现方式。

- 分析每种查找算法的时间复杂度和空间复杂度。

⒍图算法- 介绍图的基本概念和表示方法。

- 详细讲解图的遍历算法，如深度优先搜索和广度优先搜索。

- 介绍最短路径算法，如Dijkstra算法和Floyd-Warshall算法。

- 提供每种图算法的实现示例和应用场景。

⒎高级数据结构与算法- 介绍高级数据结构，如堆、红黑树、AVL树等。

- 详细讲解高级算法，如动态规划、并查集等。

- 提供每种高级数据结构和算法的原理、实现方式和应用示例。

⒏结语- 对数据结构与算法的重要性进行总结。

- 强调学习和实践的重要性。

本文档涉及附件：⒈源代码示例附件，包含了本文中提到的各种数据结构和算法的实现代码。

法律名词及注释：⒈数据结构：指一组数据的存储结构和相应的操作。

⒉算法：指解决特定问题的一系列有序步骤或规则。

⒊时间复杂度：用来度量算法执行时间随输入规模增长时的增长率。

⒋空间复杂度：用来度量算法执行过程中所需存储空间随输入规模增长时的增长率。

哈弗曼编码数据结构实验报告

数据结构实验报告----约瑟夫环一、需求分析：约瑟夫环是程序的一道经典例题，可以使用数据结构的单链表进行编写。

二、概要设计：大体上可以使用单链表通过节点的创建和删除来达到人数出列的效果，可以大大缩短程序量。

三、详细设计：1、首先定义一个单链表，然后分别做创建链表、以及对应的输入数据，删除节点对应的删除数据，以及输出功能。

最后用主函数实现上述功能。

下为程序源代码：#include<stdio.h>#include<malloc.h>typedef struct Lnode //创建一个单链表{int num;int key;struct Lnode *next;}Joseph;struct Lnode *head,*p,*p1;int creatlinklist(int n) //为节点分配内存，创建节点{int i=0;head = (struct Lnode*)malloc(sizeof(struct Lnode));if(!head){return 0;}p=head;for(i = 0;i<n-1;i++){p1=(struct Lnode*)malloc(sizeof(struct Lnode));if(!p1){return 0;}p->next=p1;p=p1;}p->next=head;p1=head;return 0;}int input(int n) //在分配的节点上输入数据{int i=0;int j=0;printf("please input the keys:\n");for(i =1;i<n+1;i++){scanf("%d",&j);p1->num=i;p1->key=j;p1=p1->next;}p1=p;return j;}int output(int m,int n) \\在约瑟夫环的规定上输出数据删除节点{int i=0;int a=0;for(i =0;i <n;i++){for(a=0;a<m-1;a++){p1=p1->next;}p=p1->next;m=p->key;printf("%d\n",p->num);p1->next=p->next;free(p);}return 0;}void main(){int m=0;int n=0;printf("请输入上限值和人数值：\n");scanf("%d%d",&m,&n);creatlinklist(n);input(n);printf("出对的人：\n");output(m,n);}四、调试分析：程序仅能使用一次，并且输入格式没有提示，容易犯错。

数据结构完整代码简版

数据结构完整代码数据结构完整代码1. 简介数据结构是计算机科学中的一个重要概念，用于组织和管理数据的方式。

在许多实际应用中，我们需要根据不同的需求选择合适的数据结构来存储和操作数据。

本文将介绍常见的数据结构，包括数组、链表、栈、队列和树，并提供完整的代码实现示例。

2. 数组（Array）数组是一种线性数据结构，用于存储固定大小的相同类型元素的集合。

数组的元素通过索引进行访问，索引是从0开始的整数。

以下是一个简单的数组实现示例代码：```pythonclass Array:def __init__(self, size):self.size = sizeself.data = [None] sizedef get(self, index):if index < 0 or index >= self.size:return Nonereturn self.data[index]def set(self, index, value):if index < 0 or index >= self.size:return Noneself.data[index] = value```3. 链表（Linked List）链表是一种常见的动态数据结构，它由多个节点组成，每个节点包含数据和指向下一个节点的指针。

链表的特点是在内存中不连续存储，而是通过指针将各个节点连接起来。

以下是一个简单的链表实现示例代码：```pythonclass Node:def __init__(self, value):self.value = valueself.next = Noneclass LinkedList:def __init__(self):self.head = Nonedef append(self, value):new_node = Node(value)if not self.head:self.head = new_nodeelse:curr_node = self.headwhile curr_node.next:curr_node = curr_node.next curr_node.next = new_nodedef remove(self, value):curr_node = self.headif curr_node.value == value:self.head = curr_node.nextreturnwhile curr_node.next:if curr_node.next.value == value:curr_node.next = curr_node.next.nextreturncurr_node = curr_node.next```4. 栈（Stack）栈是一种基于后进先出（LIFO）原则的数据结构，只能在一端进行插入和删除操作。

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

实验一线性表的链式存储结构一、实验目的：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;}六、选作实验试设计一元多项式相加（链式存储）的加法运算。

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

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

二、实验环境本实验使用以下环境进行开发和测试：- 操作系统：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）：是由节点组成的层级结构，其中一种节点作为根节点，其他节点按照父子关系连接。

数据结构实验代码

《数据结构》实验代码实验一：针对链式或顺序存储的线性表实现指定的操作题1 问题描述：有两个指数递减的一元多项式，写一程序先求这两个多项式的和，再求它们的积。

基本要求：用带表头结点的单链表作为多项式的存储表示；要建立两个单链表；多项式相加就是要把一个单链表中的结点插入到另一个单链表中去，要注意插入、删除操作中指针的正确修改。

题2 问题描述：编号为1，2，···，n的n个人围坐在一圆桌旁，每人持有一个正整数的密码。

从第一个人开始报数，报到一个预先约定的正整数m时，停止报数，报m的人退席，下一个人又重新从1开始报数，依此重复，直至所有的人都退席。

编一程序输出他们退席的编号序列。

例如，设m=20，n=7，7个人的密码依次是3，1，7，2，4，8，4，则退席的人的编号依次为6，1，4，7，2，3，5。

基本要求：用不带表头结点的循环单链表表示围成圆圈的n个人；要求建立此循环单链表；某人离席相当于删除一个结点，要正确设置程序中循环终止的条件和删除结点时指针的修改变化。

//实验1.1代码#include<iostream>using namespace std;struct poNode{float coef;int expn;poNode *next;};class Polynomail{public:Polynomail(int m=0);~Polynomail();int Print();int PolynLength();Polynomail &AddPolyn(Polynomail &P2,Polynomail &P3);Polynomail &MultiplyPolyn(Polynomail &P2,Polynomail &P4);private:int InsertpoNode();poNode *first;};int main(){int m;cout<<"输入多项式P1项数"<<endl;cin>>m;Polynomail P1(m);if(P1.PolynLength()!=m){cout<<"error!"<<endl;return -1;}cout<<"输入多项式P2项数"<<endl;cin>>m;Polynomail P2(m);if(P2.PolynLength()!=m){cout<<"error!"<<endl;return -1;}cout<<"多项式P1:";P1.Print();cout<<"多项式P2:";P2.Print();Polynomail P3;P3=P1.AddPolyn(P2,P3);cout<<"P1+P2:";P3.Print();Polynomail P4;P4=P1.MultiplyPolyn(P2,P4);cout<<"P1*P2:";P4.Print();return 0;}int Polynomail::InsertpoNode() { if(first==NULL){first=new poNode;cout<<"输入系数和指数："<<endl;cin>>first->coef;cin>>first->expn;first->next=NULL;}else{poNode *p=new poNode;poNode *q=first;cout<<"输入系数和指数："<<endl; cin>>p->coef;cin>>p->expn;poNode *r;while(q->next!=NULL&&q->expn<p->expn) {r=q;q=q->next;}if(q==first&&q->next!=NULL){if(q->expn==p->expn){return -1;}p->next=q;first=p;}else if(q==first&&q->next==NULL){if(p->expn<q->expn){p->next=q;first=p;}else if(p->expn>q->expn){q->next=p;p->next=NULL;}else{return -1;}}else if(q->next==NULL&&q!=first&&p->expn>q->expn) {q->next=p;p->next=NULL;}else{if(q->expn==p->expn){return -1;}r->next=p;p->next=q;}}return 0;}Polynomail::Polynomail(int m){first=NULL;int i;for(i=0;i<m;i++){int r=InsertpoNode();if(r==-1) break;}}int Polynomail::Print(){poNode *p=first;cout<<"f(x)=";if(first==NULL) cout<<"NULL"<<endl;while(p!=NULL){cout<<p->coef<<"*x^"<<p->expn;if(p->next==NULL) cout<<endl;else cout<<"+";p=p->next;}return 0;}Polynomail::~Polynomail(){poNode *p=first;while(p!=NULL){p=p->next;delete first;first=p;}}int Polynomail::PolynLength(){int i=0;poNode *p=first;while(p!=NULL){p=p->next;i++;}return i;}Polynomail &Polynomail::AddPolyn(Polynomail &P2,Polynomail &P3) {poNode *p=first;poNode *q=P2.first;P3.first=new poNode;poNode *r=P3.first;while(p!=NULL&&q!=NULL){if(p->expn==q->expn){r->coef=p->coef+q->coef;r->expn=p->expn;p=p->next;q=q->next;}else if(p->expn<q->expn){r->coef=p->coef;r->expn=p->expn;p=p->next;}else{r->coef=q->coef;r->expn=q->expn;q=q->next;}if(p!=NULL||q!=NULL){r->next=new poNode;r=r->next;}else r->next=NULL;}while(p!=NULL||q!=NULL) {if(p!=NULL){r->coef=p->coef;r->expn=p->expn;p=p->next;}else{r->coef=q->coef;r->expn=q->expn;q=q->next;}if(p!=NULL||q!=NULL){r->next=new poNode;r=r->next;}else r->next=NULL;}return P3;}Polynomail &Polynomail::MultiplyPolyn(Polynomail &P2,Polynomail &P4){poNode *p=first;while(p!=NULL){Polynomail P3;poNode *q=P2.first;P3.first=new poNode;poNode *r=P3.first;r->coef=p->coef*q->coef;r->expn=p->expn+q->expn;q=q->next;while(q!=NULL){r->next=new poNode;r=r->next;r->coef=p->coef*q->coef;r->expn=p->expn+q->expn;q=q->next;}r->next=NULL;P4=P4.AddPolyn(P3,P4);p=p->next;}return P4;}//实验1.2代码#include<iostream>using namespace std;struct numNode{int key;int num;numNode *next;};int CreatCircleList(numNode *now,int length); int Loop(numNode *now,int m);int main(){int m;int n;numNode *now=new numNode;cout<<"请输入人数："<<endl;cin>>n;cout<<"请输入初始数m:"<<endl;cin>>m;CreatCircleList(now,n);Loop(now,m);return 0;}int CreatCircleList(numNode *now,int length){if(length<=0){cout<<"error!"<<endl;return -1;}now->num=1;cout<<"请输入编号为1的人拥有的密码。

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

实验二#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;}。

数据结构实验代码

单链表的操作#include "myhead.h"#include <iostream.h>typedef struct LNode {ElemType data; // 数据域struct LNode *next; // 后继指针} LNode, *LinkList;Status GetElem_L(LinkList &L, int i, ElemType &e) {// L为带头结点的单链表的头指针，e为返回值、int j;struct LNode *p;p = L->next; j=1; // p指向第一个结点while (p && j<i+1) {p = p->next; j++;} // 顺链后移,j计数if (!p || j>i+1) return ERROR; // 第i元素不存在e = p->data; // 取第i元素值return OK;} // GetElem_LStatus ListInsert_L(LinkList &L, int i, ElemType e) {// 在带头结点的单链表L中第i个位置之前插入元素e, 1≤i≤n+1struct LNode *p , *s; int j = 0;p = L;while (p && j<i-1) {p = p->next; j++;} // 寻找i-1结点if (!p || j>i-1) return ERROR;s = (LinkList) malloc(sizeof(LNode)); // 生成新结点s->data = e;s->next = p->next;p->next = s; // 插入L中return OK;} // ListInsert_Lvoid Listshow(LinkList &L){struct LNode *p; p=L->next;while(p){cout<<p->data<<" ";p=p->next;}cout<<endl;}void create(LinkList &L,int n,int a[])// 逆序输入n 个数据元素，建立带头结点的单链表{cout<<"请输入单链表的"<< n <<"个元素："<<endl;int i;struct LNode *p;L = (LinkList) malloc (sizeof (LNode));L->next = NULL; // 先建立一个带头结点的单链表for (i = n; i > 0; --i) {p = (LinkList) malloc (sizeof (LNode));cin>>p->data; // 输入元素值p->next = L->next; L->next = p; // 插入}cout<< endl;}Status ListDelete_L(LinkList &L, int i, ElemType &e) {// 在带头结点的单链表L中，删除第i个位置的元素, 1≤i≤n struct LNode *p,*q; int j;p = L; j = 0;while (p->next && j<i-1) {p = p->next; j++;} // 寻找i-1结点if (!p->next || j>i-1) return ERROR;q = p->next; p->next = q->next; // 删除i结点e = q->data; free(q); // 取值并释放结点return OK;} // ListDelete_Lvoid Listdestroy(LinkList &L) //销毁L，保留头结点{// 将单链表重新置为一个空表struct LNode *p;while (L->next) {p=L->next; L->next=p->next;free(p);}}void mergelist(LinkList &la,LinkList &lb,LinkList &lc)//将有序链表la和lb合并为lc，lc的头结点借用原来la的头结点，lb的头结点销毁{struct LNode *pa,*pb,*pc;pa=la->next; pb=lb->next; lc=pc=la;while (pa&&pb) {if(pa->data<=pb->data) {pc=pa;pa=pa->next; }else {pc->next=pb;pc=pb;pb=pb->next;}}pc->next=pa?pa:pb;free(lb);}void main(){LinkList mylist,listb,listc;ElemType e;int a[]={1,12,23,34,45,56,67,78,89,90};int b[]={-6,6,16,26,36,46,96};create(mylist,10,a);create(listb,7,b);GetElem_L(mylist,5,e);cout<<"单链表的第5个元素是："<<e<<endl;cout<<"单链表的所有元素是：";Listshow(mylist);ListInsert_L(mylist,7,60);cout<<"插入第7个元素后单链表中的所有元素是：";Listshow(mylist);ListDelete_L(mylist,5,e);cout<<"删除了第五个元素后的单链表中的所有元素是：";Listshow(mylist);cout<<"删除的第五个元素是：";cout<<e<<endl;cout<<"listb中的元素有：";Listshow(listb);mergelist(mylist,listb,listc);cout<<"合并之后listc中的元素有：";Listshow(listc);Listdestroy(mylist);cout<<"销毁后单链表的元素是：";Listshow(mylist)；}串实验1.采用定长顺序显示表示串长的结构来存储串(结构定义见课件第15张幻灯片)2.实现BF算法(即朴素算法),BF函数头如下:(参见课件第21张幻灯片)int Index_BF(SString S, SString T) {}// 返回子串T在主串S中第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.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 顺序表：一种物理上相邻的存储结构，元素按照顺序依次存放。

数据结构实验内容及代码

数据结构实验内容及代码实验内容和目的：掌握几种基本的数据结构：集合、线性结构、树形结构等在求解实际问题中的应用，以及培养书写规范文档的技巧。

学习基本的查找和排序技术。

让我们在实际上机中具有编制相当规模的程序的能力。

养成一种良好的程序设计风格。

实验教材：数据结构题集（C语言版）清华大学出版社2007年实验项目：实验一、栈和循环队列㈠、实验内容：①栈掌握栈的特点(先进后出FILO)及基本操作,如入栈、出栈等，栈的顺序存储结构和链式存储结构，以便在实际问题背景下灵活应用。

本程序采用的是链栈结构，具有初始化一个栈、PUSH、POP、显示所有栈里的元素四个功能。

②循环队列掌握队列的特点(先进先出FIFO)及基本操作,如入队、出队等，学会循环队列的实现，以便在实际问题背景下灵活运用。

本程序具有初始化一个队列、入队、出队、显示队列的所有元素、队列长度五个功能。

㈡、实验代码①栈程序代码：#include <stdio.h>#include <malloc.h>#define Stack_Size 6#define ERROR 0#define OK 1typedef int SElemType;typedef struct SNode{SElemType data;struct SNode *next;}SNode,*LinkStack;int CreatTwo(LinkStack &head,int n){int i;SNode *p;head=(LinkStack)malloc(sizeof(SNode));head->next=NULL;printf("请输入数据(数字):\n");for(i=n;i>0;--i){p=(SNode *)malloc(sizeof(SNode));scanf("%d",&p->data);p->next=head->next;head->next=p;}return 1;}int menu_select(){int sn;for(;;){scanf("%d",&sn);if(sn<1||sn>6)printf("\n\t输入错误，请重新输入\n");elsebreak;}return sn;}int Push(LinkStack &top,SElemType e){SNode *q;q=(LinkStack)malloc(sizeof(SNode));if(!q){printf("溢出!\n");return(ERROR);}q->data=e;q->next=top->next;top->next=q;return(OK);}int Pop(LinkStack &top,SElemType &e){SNode *q;if(!top->next){printf("error!\n");return(ERROR);}e=top->next->data;q=top->next;top->next=q->next;free(q);return(OK);}void main(){ int e;LinkStack top;printf("1.初始化一个栈;\n2.PUSH;\n3.POP;\n4.显示所有栈里的元素;\n5.结束;\n");while(1){switch(menu_select()){case 1:if(CreatTwo(top,Stack_Size))printf("Success!\n");break; case 2:printf("Push:\n");scanf("%d",&e);if(Push(top,e))printf("Success!\n");break;case 3:if(Pop(top,e))printf("Success!\n");printf("%d\n",e);break;case 4:LinkStack p;printf("所有栈里的元素:\n");p=top;while(p->next){p=p->next;printf("%7d",p->data);}printf("\n");break;case 5:return;}}}运行结果：②循环队列程序代码：#include<stdlib.h>#include<stdio.h>#define OVERFLOW -1#define OK 1#define ERROR 0#define MAXSIZE 100typedef struct{int *elem;//队列存储空间int front;int rear;}SqQueue;//判断选择是否正确int menu_select(){int sn;for(;;){scanf("%d",&sn);if(sn<1||sn>6)printf("\n\t输入错误，请重新输入\n");elsebreak;}return sn;}//参数(传出)SqQueue &Q,循环队列(空)int InitQueue(SqQueue &Q){Q.elem=(int *)malloc(MAXSIZE*sizeof(int));if(!Q.elem)exit(OVERFLOW);Q.front=Q.rear=-1;for(int i=0;i<MAXSIZE;i++)Q.elem[i]=-1;return OK;}//返回Q的元素个数int QueueLength(SqQueue Q){return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;}//显示队列的元素void Display(SqQueue Q){for(int i=0;i<=QueueLength(Q);i++)if(Q.elem[i]!=-1)printf("%d ",Q.elem[i]);printf("\n");}//入队int EnQueue(SqQueue &Q,int e){Q.rear=(Q.rear+1)%MAXSIZE;if(Q.rear==Q.front)return ERROR;Q.elem[Q.rear]=e;return OK;}//出队int DeQueue(SqQueue &Q,int &e){if(Q.front==Q.rear)return ERROR;e=Q.elem[Q.front+1];Q.elem[Q.front+1]=-1;Q.front=(Q.front+1)%MAXSIZE;return OK;}void main(){SqQueue Q;InitQueue(Q);int elem,e;printf("请输入队列元素(以0结束):\n");scanf("%d",&elem);while(elem!=0){EnQueue(Q,elem);scanf("%d",&elem);}printf("队列为：\n");Display(Q);printf("1.初始化一个队列;\n2.入队;\n3.出队;\n4.显示队列的所有元素;\n5.队列长度:\n6.结束;\n");while(1){switch(menu_select()){case 1:printf("请输入队列元素(以0结束):\n");scanf("%d",&elem);while(elem!=0){EnQueue(Q,elem);scanf("%d",&elem);}printf("队列为：\n");Display(Q);fflush(stdin);break;case 2:scanf("%d",&elem);EnQueue(Q,elem);printf("队列为：\n");Display(Q);fflush(stdin);break;case 3:DeQueue(Q,elem);printf("队列为：\n");Display(Q);break;case 4:printf("\n队列的所有元素:\n");Display(Q);break;case 5:printf("%d\n",QueueLength(Q));break;case 6:return;}}}运行结果：实验二、数组㈠、实验内容：数组一般不做插入或删除操作，也就是说，一旦建立了数组，则结构中的数据元素个数和元素之间的关系就不再发生变动。

数据结构实验报告代码

《数据结构》实验报告实验序号：5 实验项目名称：链式栈五、分析与讨论对上机实践结果进行分析，上机的心得体会。

六、教师评语成绩签名：日期：附源程序清单：实验要求编程实现如下功能：（1）按照输入的栈中元素个数n和各元素值成立一个顺序栈，并输出栈中各元素值。

（2）将数据元素e入栈，并输出入栈后的顺序栈中各元素值。

（3）将顺序栈中的栈顶元素出栈，并输出出栈元素的值和出栈后顺序栈中各元素值。

2. 实验相关原理：栈是一种插入和删除操作都限制在表的一端进行的特殊线性表，它的操作具有“先进后出”的特性。

采用顺序存储结构的栈称为顺序栈。

栈的存储结构描述如下：#define MAXSIZE 100; /*顺序栈的最大长度*/typedef struct{ Selemtype base[MAXSIZE]; /*存储栈中数据元素的数组*/int top; /*top为栈顶指针，它指示栈顶元素的存储空间的下一个存储单元*/}Sqstack;【核心算法提示】1．顺序栈入栈操作的大体步骤：第一判断顺序栈是不是为满，若是满，则函数返回ERROR，不然将待入栈的数据元素寄存在top所指示的存储单元中，再使top后移一个存储单元位置，即将top值加1，最后函数返回OK。

2．顺序栈出栈操作的大体步骤：第一判断顺序栈是不是为空，若是空，则函数返回ERROR，不然将栈顶指针前移一个存储单元位置，即将top值减1,再将top所指示的栈顶元素用e返回其值，并使函数返回OK。

【核心算法描述】status Push(Sqstack &S,Selemtype e)/*将数据元素e压入到顺序栈S中，使其成为新的栈项元素*/{ if >=MAXSIZE) /*若是栈满，则函数返回ERROR*/return ERROR;[++]=e;/*将新元素e寄存在top所指示的存储单元中,并使top值加1*/return OK;}status Pop(Sqstack &S,Selemtype &e)/*将顺序栈S中的栈顶元素从栈中删除，并用e返回其值*/{ if ==0) /*若是栈空，则函数返回ERROR*/Return ERROR;e=[];/*将top值减1,并用e保留top所指示的栈顶元素值*/return OK;}3．源程序代码参考#define MAXSIZE 100typedef struct{ int base[MAXSIZE];int top; /*top指示存储栈顶元素的下一存储单元*/}Sqstack; /*顺序栈的类型概念*/Sqstack Push(Sqstack S,int e) /*顺序栈的入栈操作函数*/{ if >=MAXSIZE)printf("Stack is Overflow\n");else[++]=e;return S;}Sqstack Pop(Sqstack S,int *e) /*顺序栈的出栈操作函数*/{ if ==0)printf("Stack is Empty\n");else*e=[];return S;}void Stack_display(Sqstack S) /*顺序栈的输出函数*/{ int i;for(i=0; i<;i++) /*依次输出栈中各元素的值，栈顶元素在表的尾部*/printf("%4d", [i]);printf("\n");}main(){ Sqstack S;int i,j,n,x,e;printf("please input the length:");/*请求输入顺序栈中元素个数*/scanf("%d",&n);printf("please input the Value:\n ");/*请求输入顺序栈中各个元素值*/for(i=0;i<n;i++)scanf("%d",&[i]);=n;printf("the stack is:\n");Stack_display(S);printf("please input the insert node:");/*请求输入需要入栈的新元素*/scanf("%d",&x);S=Push(S,x);printf("the stack after push is:\n");/*提示输出入栈后栈中各个元素值*/Stack_display(S); /*挪用顺序栈的输出函数*/S=Pop(S,&e);printf("the pop value is:%d\n",e); /*输出出栈元素的值*/printf("the stack after pop is:\n");/*提示输出出栈后栈中各个元素值*/Stack_display(S); /*挪用顺序栈的输出函数*/}（1）按照输入的栈中元素个数和各元素值成立一个链栈，并输出链栈中各元素值, 观察输入的内容与输出的内容是不是一致,特别注意栈顶元素的位置。

数据结构实验源代码

数据结构实验源代码第二章线性表标题：约瑟夫环约瑟夫环编号为 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;标题学生信息管理：描用链式存储结构实现对一个班级学生信息管理。