数据结构实验报告(四)

合集下载

《数据结构》实验报告

《数据结构》实验报告

苏州科技学院数据结构(C语言版)实验报告专业班级测绘1011学号10201151姓名XX实习地点C1 机房指导教师史守正目录封面 (1)目录 (2)实验一线性表 (3)一、程序设计的基本思想,原理和算法描述 (3)二、源程序及注释(打包上传) (3)三、运行输出结果 (4)四、调试和运行程序过程中产生的问题及采取的措施 (6)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (6)实验二栈和队列 (7)一、程序设计的基本思想,原理和算法描述 (8)二、源程序及注释(打包上传) (8)三、运行输出结果 (8)四、调试和运行程序过程中产生的问题及采取的措施 (10)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (10)实验三树和二叉树 (11)一、程序设计的基本思想,原理和算法描述 (11)二、源程序及注释(打包上传) (12)三、运行输出结果 (12)四、调试和运行程序过程中产生的问题及采取的措施 (12)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (12)实验四图 (13)一、程序设计的基本思想,原理和算法描述 (13)二、源程序及注释(打包上传) (14)三、运行输出结果 (14)四、调试和运行程序过程中产生的问题及采取的措施 (15)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (16)实验五查找 (17)一、程序设计的基本思想,原理和算法描述 (17)二、源程序及注释(打包上传) (18)三、运行输出结果 (18)四、调试和运行程序过程中产生的问题及采取的措施 (19)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (19)实验六排序 (20)一、程序设计的基本思想,原理和算法描述 (20)二、源程序及注释(打包上传) (21)三、运行输出结果 (21)四、调试和运行程序过程中产生的问题及采取的措施 (24)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (24)实验一线性表一、程序设计的基本思想,原理和算法描述:程序的主要分为自定义函数、主函数。

数据结构实验报告(C语言)(强力推荐)

数据结构实验报告(C语言)(强力推荐)

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

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

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

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

实验教材:数据结构题集(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;}}}运行结果:实验二、数组㈠、实验内容:数组一般不做插入或删除操作,也就是说,一旦建立了数组,则结构中的数据元素个数和元素之间的关系就不再发生变动。

数据结构实验报告实验总结

数据结构实验报告实验总结

数据结构实验报告实验总结本次数据结构实验主要涉及线性表、栈和队列的基本操作以及链表的应用。

通过实验,我对这些数据结构的特点、操作和应用有了更深入的了解。

下面对每一部分实验进行总结。

实验一:线性表的基本操作线性表是一种常见的数据结构,本实验要求实现线性表的基本操作,包括插入、删除、查找、遍历等。

在实验过程中,我对线性表的结构和实现方式有了更清晰的认识,掌握了用数组和链表两种方式实现线性表的方法。

实验二:栈的应用栈是一种后进先出(LIFO)的数据结构,本实验要求利用栈实现简单的括号匹配和后缀表达式计算。

通过实验,我了解到栈可以方便地实现对于括号的匹配和后缀表达式的计算,有效地解决了对应的问题。

实验三:队列的应用队列是一种先进先出(FIFO)的数据结构,本实验要求利用队列实现银行排队和迷宫求解。

通过实验,我对队列的应用有了更加深入的了解,了解到队列可以解决需要按顺序处理的问题,如排队和迷宫求解等。

实验四:链表的应用链表是一种常用的数据结构,本实验要求利用链表实现学生信息管理系统。

通过实验,我对链表的应用有了更深入的了解,了解到链表可以方便地实现对于数据的插入、删除和修改等操作,并且可以动态地调整链表的长度,适应不同的需求。

通过本次实验,我掌握了线性表、栈、队列和链表的基本操作,并了解了它们的特点和应用方式。

同时,通过实际编程的过程,我对于数据结构的实现方式和效果有了更直观的认识,也锻炼了自己的编程能力和解决问题的能力。

在实验过程中,我遇到了一些问题,如程序逻辑错误和内存泄漏等,但通过调试和修改,最终成功解决了这些问题,对自己的能力也有了更多的信心。

通过本次实验,我深刻体会到了理论与实践的结合的重要性,也对于数据结构这门课程有了更加深入的理解。

总之,本次数据结构实验给予了我很多有益的启发和收获,对于数据结构的概念、特点和应用有了更深入的理解。

在以后的学习中,我会继续加强对数据结构的学习和研究,不断提高自己的编程能力和解决问题的能力。

数据结构实验报告

数据结构实验报告

《数据结构》实验报告姓名:学号:班级:学院:实验一单链表实验(一)实验目的1.理解线性表的链式存储结构。

2.熟练掌握动态链表结构及有关算法的设计。

3.根据具体问题的需要,设计出合理的表示数据的链表结构,并设计相关算法。

(二)实验任务编写算法实现下列问题的求解1.求链表中第i个结点的指针(函数),若不存在,则返回NULL。

2.在第i个结点前插入值为x的结点。

3.删除链表中第i个元素结点。

4.在一个递增有序的链表L中插入一个值为x的元素,并保持其递增有序特性。

5.将单链表L中的奇数项和偶数项结点分解开,并分别连成一个带头结点的单链表,然后再将这两个新链表同时输出在屏幕上,并保留原链表的显示结果,以便对照求解结果。

6.求两个递增有序链表L1和L2中的公共元素,并以同样方式连接成链表L3。

(三)主要仪器设备PC机,Windows操作平台,Visual C++(四)实验分析顺序表操作:定义一个顺序表类,该类包括顺序表的存储空间、存储容量和长度,以及构造、插入、删除、遍历等操作的方法(五)源程序头文件文件名:linklist.h#include<iostream>using namespace std;struct node{int data;node *next;};class list{public:list();int length()const{return count; //求链表长度}~list();void create(); //链表构建,以0为结束标志void output(); //链表输出int get_element(const int i)const; //按序号取元素node *locate(const int x) const; //搜索对应元素int insert(const int i,const int x); //插入对应元素int delete_element(const int i); //删除对应元素node *get_head(){return head; //读取头指针}void insert2(const int x);friend void SplitList(list L1, list&L2, list &L3);friend void get_public(list L1, list L2, list &L3);private:int count;node *head;};list::list(){head=new node;head->next=NULL;count=0;}void list::create() //链表构建,以0为结束标志{int x;cout<<"请输入当前链表,以0为结束符。

哈工程数据结构实验报告

哈工程数据结构实验报告

哈工程数据结构实验报告一、实验目的本实验的目的是通过对于哈工程的数据结构实验的实践操作,掌握并理解数据结构中的哈希表的基本原理、实现方式,以及相关的查找、插入和删除操作。

通过实验的实践操作,进一步加深对于数据结构的理解和运用能力。

二、实验步骤和实验原理1.实验环境本次实验使用的是C++语言在Visual Studio环境下进行开发。

2.实验内容本次实验主要涉及到哈希表的构建和相关操作的实践。

具体步骤如下:(1)首先创建一个结构体,包括学生姓名和学号等信息。

(2)然后定义哈希表的存储结构,其中包括哈希表的大小、装填因子等。

(3)根据哈希表的大小,创建一个存储结点的数组。

(4)实现哈希函数,根据学生学号计算哈希值。

(5)实现插入操作,即将结点插入到哈希表中的合适位置。

(6)实现查找操作,根据学生学号查找对应的结点。

(7)实现删除操作,根据学生学号删除对应的结点。

(8)测试程序的运行效果,包括对哈希表进行插入、查找和删除操作等。

三、实验结果与分析通过对实验的步骤和原理的实践操作,成功构建了一个哈希表,并实现了插入、查找和删除操作。

在实验结果的分析中,可以发现哈希表具有一定的优势:通过哈希函数的映射,可以将元素快速地插入到对应的位置,从而实现了快速的查找和删除操作。

四、实验总结通过本次实验,我对于哈希表的原理、实现方式以及相关操作有了更深刻的理解。

通过实践操作,我进一步加深了对于数据结构的掌握和运用能力。

同时,我也认识到哈希表在实际应用中的重要性和优势,对于提高数据处理和查询效率有着重要的作用。

期待在日后的学习和工作中能够更加深入地学习和应用数据结构的知识,提升自己的技术水平和能力。

数据结构实训实验报告

数据结构实训实验报告

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

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

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

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

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

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

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

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

(2)实现栈的入栈、出栈、判断栈空等操作。

(3)实现队列的顺序存储和链式存储。

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

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

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

(3)实现图的邻接矩阵和邻接表存储。

(4)实现图的深度优先遍历和广度优先遍历。

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

(2)实现二分查找算法。

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

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

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

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

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

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

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

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

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

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

数据结构单链表实验报告

数据结构单链表实验报告

数据结构单链表实验报告一、实验目的1、深入理解单链表的数据结构及其基本操作。

2、掌握单链表的创建、插入、删除、查找等操作的实现方法。

3、通过实际编程,提高对数据结构和算法的理解和应用能力。

二、实验环境1、操作系统:Windows 102、编程语言:C 语言3、开发工具:Visual Studio 2019三、实验原理单链表是一种常见的数据结构,它由一系列节点组成,每个节点包含数据域和指针域。

指针域用于指向下一个节点,从而形成链表的链式结构。

单链表的基本操作包括:1、创建链表:通过动态分配内存创建链表的头节点,并初始化链表为空。

2、插入节点:可以在链表的头部、尾部或指定位置插入新的节点。

3、删除节点:根据给定的条件删除链表中的节点。

4、查找节点:在链表中查找满足特定条件的节点。

四、实验内容(一)单链表的创建```cinclude <stdioh>include <stdlibh>//定义链表节点结构体typedef struct Node {int data;struct Node next;} Node;//创建单链表Node createList(){Node head =(Node)malloc(sizeof(Node));if (head == NULL) {printf("内存分配失败!\n");return NULL;}head>data = 0;head>next = NULL;return head;}int main(){Node list = createList();//后续操作return 0;}```在创建单链表时,首先为头节点分配内存空间。

若内存分配失败,则提示错误信息并返回`NULL`。

成功分配内存后,初始化头节点的数据域和指针域。

(二)单链表的插入操作插入操作分为三种情况:头部插入、尾部插入和指定位置插入。

1、头部插入```cvoid insertAtHead(Node head, int data) {Node newNode =(Node)malloc(sizeof(Node));if (newNode == NULL) {printf("内存分配失败!\n");return;}newNode>data = data;newNode>next = head>next;head>next = newNode;}```头部插入时,创建新节点,将新节点的数据域赋值,并将其指针域指向原头节点的下一个节点,然后更新头节点的指针域指向新节点。

数据结构 实验报告

数据结构 实验报告

数据结构实验报告一、实验目的数据结构是计算机科学中非常重要的一门课程,通过本次实验,旨在加深对常见数据结构(如链表、栈、队列、树、图等)的理解和应用,提高编程能力和解决实际问题的能力。

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

操作系统为 Windows 10。

三、实验内容1、链表的实现与操作创建一个单向链表,并实现插入、删除和遍历节点的功能。

对链表进行排序,如冒泡排序或插入排序。

2、栈和队列的应用用栈实现表达式求值,能够处理加、减、乘、除和括号。

利用队列实现银行排队系统的模拟,包括顾客的到达、服务和离开。

3、二叉树的遍历与操作构建一棵二叉树,并实现前序、中序和后序遍历。

进行二叉树的插入、删除节点操作。

4、图的表示与遍历用邻接矩阵和邻接表两种方式表示图。

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

四、实验步骤及结果1、链表的实现与操作首先,定义了链表节点的结构体:```cppstruct ListNode {int data;ListNode next;ListNode(int x) : data(x), next(NULL) {}};```插入节点的函数:```cppvoid insertNode(ListNode& head, int val) {ListNode newNode = new ListNode(val);head = newNode;} else {ListNode curr = head;while (curr>next!= NULL) {curr = curr>next;}curr>next = newNode;}}```删除节点的函数:```cppvoid deleteNode(ListNode& head, int val) {if (head == NULL) {return;}ListNode temp = head;head = head>next;delete temp;return;}ListNode curr = head;while (curr>next!= NULL && curr>next>data!= val) {curr = curr>next;}if (curr>next!= NULL) {ListNode temp = curr>next;curr>next = curr>next>next;delete temp;}}```遍历链表的函数:```cppvoid traverseList(ListNode head) {ListNode curr = head;while (curr!= NULL) {std::cout << curr>data <<"";curr = curr>next;}std::cout << std::endl;}```对链表进行冒泡排序的函数:```cppvoid bubbleSortList(ListNode& head) {if (head == NULL || head>next == NULL) {return;}bool swapped;ListNode ptr1;ListNode lptr = NULL;do {swapped = false;ptr1 = head;while (ptr1->next!= lptr) {if (ptr1->data > ptr1->next>data) {int temp = ptr1->data;ptr1->data = ptr1->next>data;ptr1->next>data = temp;swapped = true;}ptr1 = ptr1->next;}lptr = ptr1;} while (swapped);}```测试结果:创建了一个包含 5、3、8、1、4 的链表,经过排序后,输出为 1 3 4 5 8 。

数据结构实验报告及心得体会

数据结构实验报告及心得体会

数据结构实验报告及心得体会一、引言数据结构是计算机科学中的重要基础课程,通过实验环节的学习,我们能够更好地掌握和应用数据结构的概念、算法和操作。

本报告旨在总结和分享我们进行的数据结构实验,并提出相应的心得体会。

二、实验一:线性表的实现与应用1. 实验目的本实验旨在通过实现和应用线性表的基本操作,掌握线性表的存储结构和算法。

2. 实验内容我们选择了顺序表和链表两种线性表的实现方式,并实现了插入、删除和查找等基本操作。

通过实验,我们发现顺序表适用于元素个数较少、频繁查找的情况,而链表适用于插入和删除操作较多、元素个数不确定的情况。

3. 实验心得通过实验一,我们深刻认识到数据结构的不同实现方式对算法的影响。

选择合适的数据结构可以提高算法效率,提高程序的性能。

同时,我们也意识到了在实际应用中,根据问题的具体特点选择不同的数据结构才能得到最优解。

三、实验二:栈与队列的应用本实验旨在通过实现和应用栈和队列的基本操作,掌握栈和队列的特性及其在实际应用中的作用。

2. 实验内容我们分别实现了顺序栈、链式栈、顺序队列和链式队列,并实现了入栈、出栈、入队和出队等基本操作。

我们发现栈适用于实现回溯算法、递归算法等,而队列适用于广度优先搜索、线程池等场景。

3. 实验心得通过实验二,我们进一步理解了栈和队列在实际编程中的运用。

它们提供了方便的数据结构,帮助我们解决了许多实际问题。

同时,实验过程中,我们也发现了栈溢出的问题,意识到了合理管理栈空间的重要性。

四、实验三:树与二叉树的实现与应用1. 实验目的本实验旨在通过实现和应用树和二叉树的基本操作,掌握树和二叉树的存储结构和算法。

2. 实验内容我们实现了树和二叉树的基本操作,包括创建、插入、删除和遍历等。

通过实验,我们发现树在表示具有部分层次结构的问题时更合适,而二叉树在表示递归结构时更加方便。

通过实验三,我们深入理解了树和二叉树的特性及其应用。

树和二叉树是许多高级数据结构的基础,熟练掌握它们的操作对于解决实际问题非常重要。

北京理工大学-数据结构实验报告-实验四--图书管理系统

北京理工大学-数据结构实验报告-实验四--图书管理系统

实验四图书管理系统姓名:任子龙学号:1120140167 班级:05111451一。

需求分析(1)问题描述有一个小型书库保管了大量图书,关于图书有大量信息需要处理,这些信息包括图书的分类、书名、作者名、购买日期、价格等。

现要求编写一个程序以便于对图书的管理。

(2)基本要求:a.建立图书信息.b.提供查找功能,按照多种关键字查找需要的书籍。

例如按书名查找,输入书名后,将显示出该图书的所有信息,或显示指定信息。

c.提供排序功能,按照多种关键字对所有的书籍进行排序,例如按出版日期进行排序。

d.提供维护功能,可以对图书信息进行添加、修改、删除等功能。

(3)数据结构与算法分析将每一本书看作是一个基本单元。

由于涉及添加、修改操作,这里使用了链表作为数据存储结构;同时,考虑到排序功能,尝试使用双向链表。

其中,每本书作为一个结点,数据域包含char 型变量,指针域含有左右指针left和right。

二.概要设计1。

抽象数据类型的定义为实现上述功能,程序中使用了双向链表,只需要定义一种数据类型:typedef struct book{char number[10];char title[20];char author[10];char date[15];char price[10];struct book *right;struct book *left;}BK;注意结点的指针域有left和right两个。

2.本程序包含两个模块(1)主程序模块主函数只包含了Menu_select()函数。

目的是进入主菜单界面,进行功能选择;直到输入操作码0,退出系统;(2)双向链表单元模块——实现书籍信息的链式存储的抽象数据类型.各函数之间的调用关系:三。

详细设计1。

结点类型typedef struct book{char number[10];char title[20];char author[10];char date[15];char price[10];struct book *right;struct book *left;}BK;2.子函数(1)功能菜单调用函数Menu_select()使用户进入主菜单界面,进行功能选择;先进入无限循环,输入操作码进行系统管理工作,直到输入操作码0,退出系统;(2)各种功能函数Initialize()//初始化图书系统信息;Insert()//添加新的图书信息;Sort()//对图书进行排序,本程序可以实现按“图书编号”、“出版日期"、“图书价格”多种关键字进行排序;Search()//实现对图书的查找功能,本程序可以实现按“图书编号"、“出版日期”、“图书价格”多种关键字进行查找;deletebook()//删除无效的图书信息;Print_book()//打印全部图书信息。

数据结构上机实验报告

数据结构上机实验报告

数据结构实验报告课程数据结构 _ 院系专业班级实验地点姓名学号实验时间指导老师数据结构上机实验报告1一﹑实验名称:实验一——链表二﹑实验目的:1.了解线性表的逻辑结构特性;2.熟悉链表的基本运算在顺序存储结构上的实现,熟练掌握链式存储结构的描述方法;3.掌握链表的基本操作(建表、插入、删除等)4. 掌握循环链表的概念,加深对链表的本质的理解。

5.掌握运用上机调试链表的基本方法三﹑实验内容:(1)创建一个链表(2)在链表中插入元素(3)在链表中删除一个元素(4)销毁链表四﹑实验步骤与程序#include <iostream.h>#include <malloc.h>typedef struct LNode{int data;struct LNode *next;}Lnode, *LinkList;//假设下面的链表均为带头结点。

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

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

数据结构课程实验报告

数据结构课程实验报告

数据结构课程实验报告一、实验目的本次数据结构课程实验的主要目的是通过实践掌握常见数据结构的基本操作,包括线性结构、树形结构和图形结构。

同时,也要求学生能够熟练运用C++语言编写程序,并且能够正确地使用各种算法和数据结构解决具体问题。

二、实验内容本次实验涉及到以下几个方面:1. 线性表:设计一个线性表类,并且实现线性表中元素的插入、删除、查找等基本操作。

2. 栈和队列:设计一个栈类和队列类,并且分别利用这两种数据结构解决具体问题。

3. 二叉树:设计一个二叉树类,并且实现二叉树的遍历(前序遍历、中序遍历和后序遍历)。

4. 图论:设计一个图类,并且利用图论算法解决具体问题(如最短路径问题)。

三、实验过程1. 线性表首先,我们需要设计一个线性表类。

在这个类中,我们需要定义一些成员变量(如线性表大小、元素类型等),并且定义一些成员函数(如插入元素函数、删除元素函数等)。

在编写代码时,我们需要注意一些细节问题,如边界条件、异常处理等。

2. 栈和队列接下来,我们需要设计一个栈类和队列类。

在这两个类中,我们需要定义一些成员变量(如栈顶指针、队头指针等),并且定义一些成员函数(如入栈函数、出栈函数、入队函数、出队函数等)。

在编写代码时,我们需要注意一些细节问题,如空间不足的情况、空栈或空队列的情况等。

3. 二叉树然后,我们需要设计一个二叉树类,并且实现二叉树的遍历。

在这个类中,我们需要定义一个节点结构体,并且定义一些成员变量(如根节点指针、节点数量等),并且定义一些成员函数(如插入节点函数、删除节点函数、遍历函数等)。

在编写代码时,我们需要注意一些细节问题,如递归调用的情况、空节点的情况等。

4. 图论最后,我们需要设计一个图类,并且利用图论算法解决具体问题。

在这个类中,我们需要定义一个邻接矩阵或邻接表来表示图形结构,并且定义一些成员变量(如顶点数量、边的数量等),并且定义一些成员函数(如添加边函数、删除边函数、最短路径算法等)。

《数据结构》实验指导及实验报告栈和队列

《数据结构》实验指导及实验报告栈和队列

《数据结构》实验指导及实验报告栈和队列实验四栈和队列⼀、实验⽬的1、掌握栈的结构特性及其⼊栈,出栈操作;2、掌握队列的结构特性及其⼊队、出队的操作,掌握循环队列的特点及其操作。

⼆、实验预习说明以下概念1、顺序栈:2、链栈:3、循环队列:4、链队三、实验内容和要求1、阅读下⾯程序,将函数Push和函数Pop补充完整。

要求输⼊元素序列1 2 3 4 5 e,运⾏结果如下所⽰。

#include#include#define ERROR 0#define OK 1#define STACK_INT_SIZE 10 /*存储空间初始分配量*/#define STACKINCREMENT 5 /*存储空间分配增量*/typedef int ElemType; /*定义元素的类型*/typedef struct{ElemType *base; /*定义栈底部指针*/ElemType *top; /*定义栈顶部指针*/int stacksize; /*当前已分配的存储空间*/}SqStack;int InitStack(SqStack *S); /*构造空栈*/int push(SqStack *S,ElemType e); /*⼊栈操作*/int Pop(SqStack *S,ElemType *e); /*出栈操作*/int CreateStack(SqStack *S); /*创建栈*/void PrintStack(SqStack *S); /*出栈并输出栈中元素*/int InitStack(SqStack *S){S->base=(ElemType *)malloc(STACK_INT_SIZE *sizeof(ElemType)); if(!S->base) return ERROR;S->top=S->base;int Push(SqStack *S,ElemType e){if(S->top-S->base>=S->stacksize){S->base=(ElemType*)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(ElemType)); S->top=S->base+S->stacksize;S->stacksize+=STACKINCREMENT;}*S->top++=e;return 1}/*Push*/int Pop(SqStack *S,ElemType *e){if(S->top!=S->base){*e=*--S->top;return 1;}elsereturn 0;}/*Pop*/int CreateStack(SqStack *S){int e;if(InitStack(S))printf("Init Success!\n");else{printf("Init Fail!\n");return ERROR;}printf("input data:(Terminated by inputing a character)\n"); while(scanf("%d",&e))Push(S,e);return OK;}/*CreateStack*/while(Pop(S,&e))printf("%3d",e);}/*Pop_and_Print*/int main(){SqStack ss;printf("\n1-createStack\n");CreateStack(&ss);printf("\n2-Pop&Print\n");PrintStack(&ss);return 0;}●算法分析:输⼊元素序列1 2 3 4 5,为什么输出序列为5 4 3 2 1?体现了栈的什么特性?2、在第1题的程序中,编写⼀个⼗进制转换为⼆进制的数制转换算法函数(要求利⽤栈来实现),并验证其正确性。

数据结构实验报告

数据结构实验报告

课程设计报告课程名称:数据结构专业班级:计算机辅修一班学号:财大1309100108姓名:徐倬迅指导教师:袁凌报告日期:2015、6、23计算机科学与技术目录实验一基于顺序结构的线性表实现1 1.1问题描述1 1.2系统设计1 1.3.系统实现2 1.4效率分析5实验二基于链式结构的线性表实现5 2.1问题描述5 2.2系统设计5 2.3系统实现6 2.4效率分析10四实验总结与评价10实验一基于顺序结构的线性表实现1.1问题描述基于顺序存储结构,实现线性表的基本的、常见的运算。

1.2系统设计1.2.1提供12个功能,分别是:1. InitiaList2. DestroyList3. ClearList4. ListEmpty5. ListLength6. GetElem7. LocatElem8. PriorElem9. NextElem10. ListInsert11. ListDelete12. ListTrabverse1.2.2物理结构为顺序存储结构,数据元素为包含一个整型变量的结构体:typedef struct{int item1;}Elemtype;typedef struct{Elemtype * elem;int length;int listsize;}SqList;1.2.3构建线性表之前先声明一个头结点,用于存储该表的基本信息和首结点地址:SqList L1, L2;//声明头结点1.2.4文件预处理#include<stdio.h>#include<stdlib.h>#define TRUE 1;#define FALSE 0;#define OK 2;#define ERROR -1;#define OVERFLOW -2;typedef int status;#define LIST_INIT_SIZE 100;#define LISTINCREMENT 10;//预处理1.3.系统实现1.3.1 InitialList功能初始化线性表,传入的是头结点地址。

数据结构课程实验报告

数据结构课程实验报告

数据结构课程实验报告目录1. 实验简介1.1 实验背景1.2 实验目的1.3 实验内容2. 实验方法2.1 数据结构选择2.2 算法设计2.3 程序实现3. 实验结果分析3.1 数据结构性能分析3.2 算法效率比较3.3 实验结论4. 实验总结1. 实验简介1.1 实验背景本实验是数据结构课程的一次实践性操作,旨在帮助学生加深对数据结构的理解和运用。

1.2 实验目的通过本实验,学生将学会如何选择合适的数据结构来解决特定问题,了解数据结构与算法设计的关系并能将其应用到实际问题中。

1.3 实验内容本实验将涉及对一些经典数据结构的使用,如链表、栈、队列等,并结合具体问题进行算法设计和实现。

2. 实验方法2.1 数据结构选择在实验过程中,需要根据具体问题选择合适的数据结构,比如针对需要频繁插入删除操作的情况可选择链表。

2.2 算法设计针对每个问题,需要设计相应的算法来实现功能,要考虑算法的效率和实际应用情况。

2.3 程序实现根据算法设计,编写相应的程序来实现功能,并进行调试测试确保程序能够正确运行。

3. 实验结果分析3.1 数据结构性能分析在实验过程中,可以通过对不同数据结构的使用进行性能分析,如时间复杂度和空间复杂度等,以便选择最优的数据结构。

3.2 算法效率比较实验完成后,可以对不同算法在同一数据结构下的效率进行比较分析,找出最优算法。

3.3 实验结论根据实验结果分析,得出结论并总结经验教训,为后续的数据结构和算法设计提供参考。

4. 实验总结通过本次实验,学生将对数据结构与算法设计有更深入的了解,并能将所学知识应用到实际问题中,提高自己的实践能力和解决问题的能力。

山东大学数据结构实验报告四

山东大学数据结构实验报告四

山东大学软件工程学院数据结构课程实验报告学号:姓名:班级:软件工程2014级2班实验题目:矩阵和散列表实验学时:实验日期: 2015.11.11实验目的:掌握特殊矩阵和稀疏矩阵。

掌握散列表及其应用。

硬件环境:实验室软件环境:Vistual Studio 2013实验步骤与内容:实验内容:1、创建三对角矩阵类,采用按列映射方式,提供store和retrieve 方法。

2、创建下三角矩阵类,采用按列映射方式,提供store和retrieve 方法。

3、创建稀疏矩阵类,采用行主顺序把稀疏矩阵映射到一维数组中,实现稀疏矩阵的转置和两个稀疏矩阵的加法操作。

4、使用散列表设计实现一个字典,假设关键字为整数且D为961,在字典中插入随机产生的500个不同的整数,实现字典的建立和搜索操作。

分别使用线性开型寻址和链表散列解决溢出。

代码体:ChainHashTableNode.h#pragma once#include"ChainHashTableNode.h"using namespace std;class ChainHashTable{public:ChainHashTable(int divisor);~ChainHashTable();bool Insert(int k);bool Search(int k);void print();private:int d;ChainHashTableNode *ht;};ChainHashTableNode.cpp#include"ChainHashTable.h"#include<iostream>using namespace std;ChainHashTable::ChainHashTable(int divisor) {d = divisor;ht = new ChainHashTableNode[d];}bool ChainHashTable::Insert(int k){int j = k%d;if (ht[j].Insert(k)){return true;}else{return false;}}void ChainHashTable::print(){for (int i = 0; i < d; i++){ht[i].print();}}ChainHashTableNode.h#pragma once#include"Node.h"class ChainHashTableNode{public:ChainHashTableNode();bool Insert(int k);bool Search(int k);void print();private:Node *first;};ChainHashTableNode.cpp#include"ChainHashTableNode.h"#include<iostream>using namespace std; ChainHashTableNode::ChainHashTableNode() {first = 0;}bool ChainHashTableNode::Search(int k) {if (first == 0) return false;Node *current = first;while (current){if (current->value == k){return true;}current = current->link;if (current){if (current->value == k){return true;}}}return false;}bool ChainHashTableNode::Insert(int k) {if (Search(k)){cout << "已经存在此元素" << endl;return false;}else {Node *p = new Node();p->value = k;if (first == 0){first = p;return true;}else{p->link = first;first = p;return true;}}}void ChainHashTableNode::print(){Node *current = first;if (first){while (first){cout << first->value << " ";first = first->link;}cout << endl;first = current;}else {cout << -1 << endl;}}HashTable.h#pragma onceclass HashTable{public:HashTable(int divisor);~HashTable();int Search(int k);//搜索算法bool Insert(int e);void print();private:int hSearch(int k);int d;//除数int *ht;//桶,大小取决于d就是除数是多少bool *empty;//一维数组,用来存储第I个桶是否存入了元素};HashTable.cpp#include"HashTable.h"#include<iostream>using namespace std;HashTable::HashTable(int divisor){d = divisor;ht = new int[d];empty = new bool[d];for (int i = 0; i < d; i++){empty[i] = true;ht[i] = 0;}}HashTable::~HashTable(){delete[]ht;delete[]empty;}int HashTable::hSearch(int k)//搜索值为K的元素{int i = k%d;int j = i;do{if (ht[j] == k || empty[j]) return j;j = (j + 1) % d;} while (j != i);return j;}int HashTable::Search(int k)//搜索值为K的元素{int b = hSearch(k);if (ht[b] == k) return b;return -1;}bool HashTable::Insert(int e){int b = hSearch(e);if (empty[b]){ht[b] = e;empty[b] = false;return true;}else if (ht[b] == e){cout << "已经存在此元素" << endl;return false;}else{cout << "表已经满了" << endl;return false;}}void HashTable::print(){for (int i = 0; i < 961; i++){cout << ht[i] << " ";}cout << endl;return;}LowerTriangularMatrix.h#pragma onceclass LowerTriangularMatrix{public:LowerTriangularMatrix(int size);void Store(int x, int i, int j);//向矩阵里存储一个元素int Retrieve(int i, int j);//返回矩阵中的一个元素void print();private:int n;//矩阵维数int sum;//矩阵非零元素个数int *t;//用数组来存储矩阵};LowerTriangularMatrix.cpp#include"LowerTriangularMatrix.h"#include<iostream>using namespace std;LowerTriangularMatrix::LowerTriangularMatrix(int size){n = size;sum = n*(n + 1) / 2;t = new int[sum];}void LowerTriangularMatrix::Store(int x, int i, int j){if (i<0 || j<0 || i >= n || j >= n){cout << "下三角矩阵行列输入错误" << i << " " << j << endl;return;}else if (x == 0){cout << "下三角所添加的元素必须非零" << endl;return;}else if (i<j){cout << "下三角添加元素位置错误" << endl;return;}t[sum - ((n - j)*(n - j + 1) / 2) + (i - j)] = x;return;}int LowerTriangularMatrix::Retrieve(int i, int j){if (i<0 || j<0 || i >= (n - 1) || j >= (n - 1)){cout << "三对角矩阵行列输入错误" << endl;return -1;}else if (i >= j){return t[sum - ((n - j)*(n - j + 1) / 2) + (i - j)];}else{return 0;}}void LowerTriangularMatrix::print(){for (int i = 0; i < sum; i++){cout << t[i] << " ";}cout << endl;return;}Node.h#pragma onceclass Node{friend class ChainHashTableNode;private:int value;Node *link;};Node.cpp#include"Node.h"using namespace std;SparseMatrix.h#pragma once#include"Term.h"class SparseMatrix{public:SparseMatrix(int row, int col);void transpose();void Store(int x, int i, int j);//向矩阵里存储一个元素void Add(SparseMatrix &b);//两个稀疏矩阵相加void print();private:int row, col;//数组维数int sum;//元素个数int maxsum;//最多的元素个数Term *t;//存储的数组};SparseMatrix.cpp#include"SparseMatrix.h"#include<iostream>using namespace std;SparseMatrix::SparseMatrix(int r, int c){row = r;col = c;sum = 0;maxsum = r*c;t = new Term[maxsum];}void SparseMatrix::transpose(){Term *cur = new Term[maxsum];int *ColSize = new int[col];int *RowNext = new int[row];for (int i = 0; i < col; i++) ColSize[i] = 0;for (int i = 0; i < row; i++) RowNext[i] = 0;for (int i = 0; i < sum; i++) ColSize[t[i].col]++;//表示每一列的非零元素个数RowNext[0] = 0;for (int i = 1; i < col; i++) RowNext[i] = RowNext[i - 1] + ColSize[i - 1];//表示新矩阵中每一行的矩阵的前面的矩阵的个数//进入转置操作for (int i = 0; i < sum; i++){int j = RowNext[t[i].col]++;cur[j].value = t[i].value;cur[j].col = t[i].row;cur[j].row = t[i].col;}delete t;t = cur;}void SparseMatrix::Store(int x, int i, int j){t[sum].value = x;t[sum].row = i;t[sum].col = j;sum++;return;}void SparseMatrix::print(){for (int i = 0; i < sum; i++){cout << t[i].value << " ";}cout << endl;return;}void SparseMatrix::Add(SparseMatrix &b)//两个稀疏矩阵相加{if (col != b.col || row != b.row){cout << "两个矩阵行列不同无法相加" << endl;return;}int sa = 0;int sb = 0;Term *cur = new Term[maxsum];int k = 0;while (sa < sum || sb < b.sum){if (t[sa].col == b.t[sb].col&&t[sa].row == b.t[sb].row){cur[k].col = t[sa].col;cur[k].row = t[sa].row;cur[k].value = t[sa].value + b.t[sb].value;k++;sa++;sb++;}else if (t[sa].row < b.t[sb].row){cur[k].value = t[sa].value;cur[k].row = t[sa].row;cur[k].col = t[sa].col;k++;sa++;}else if (t[sa].row > b.t[sb].row){cur[k].value = b.t[sb].value;cur[k].row = b.t[sb].row;cur[k].col = b.t[sb].col;k++;sb++;}else if (t[sa].col < t[sb].col){cur[k].col = t[sa].col;cur[k].row = t[sa].row;cur[k].value = t[sa].value;k++;sa++;}else{cur[k].value = b.t[sb].value;cur[k].row = b.t[sb].row;cur[k].col = b.t[sb].col;k++;sb++;}}sum = k;delete t;t = cur;return;}Term.h#pragma onceclass Term{friend class SparseMatrix;private:int col, row;int value;};Term.cpp#include"Term.h"TridiagonalMatrix.h#pragma onceclass TridiagonalMatrix{public:TridiagonalMatrix(int size);void Store(int x, int i, int j);//向矩阵里存储一个元素int Retrieve(int i, int j);//返回矩阵中的一个元素void print();private:int n;//矩阵非0元素个数int *t;//用数组来存储矩阵};TridiagonalMatrix.cpp#include"TridiagonalMatrix.h"#include<iostream>using namespace std;TridiagonalMatrix::TridiagonalMatrix(int size){n = size;t = new int[3 * n - 2];}void TridiagonalMatrix::Store(int x, int i, int j){if (i<0 || j<0 || i >= n || j >= n){cout << "三对角矩阵行列输入错误" << i << " " << j << endl;return;}else if (x == 0){cout << "三对角矩阵所添加的元素必须非零" << endl;return;}else if (abs(i - j)>1){cout << "三对角矩阵添加元素位置错误" << endl;return;}switch (i - j){case -1:t[3 * j - 1] = x;break;case 0:t[3 * j] = x;break;case 1:t[3 * j + 1] = x;break;}return;int TridiagonalMatrix::Retrieve(int i, int j){if (i<0 || j<0 || i >= (n - 1) || j >= (n - 1)) {cout << "三对角矩阵行列输入错误" << endl;return -1;}else if (abs(i - j) <= 1){return t[3 * j + (i - j)];}else{return 0;}}void TridiagonalMatrix::print(){for (int i = 0; i < 3 * n - 2; i++){cout << t[i] << " ";}cout << endl;return;}Test.cpp#include<iostream>#include<cstring>#include<cstdlib>#include"TridiagonalMatrix.h"#include"LowerTriangularMatrix.h"#include"SparseMatrix.h"#include"HashTable.h"#include"ChainHashTable.h"using namespace std;int wei, num[100][100];void c(){for (int i = 0; i < wei; i++)for (int j = 0; j < wei; j++)cin >> num[i][j];}int main(){int k = 0, l = 0;/*三对角矩阵实验开始测试数据4~10~3n-241 2 0 03 4 5 00 7 8 90 0 8 7*/cout << "请输入三对焦矩阵维数及内容:" << endl;cin >> wei;c();TridiagonalMatrix *TM = new TridiagonalMatrix(wei);for (int i = 0; i < wei; i++)for (int j = 0; j < wei; j++)if (num[j][i] != 0)TM->Store(num[j][i], j, i);TM->print();cout << "请输入要查询的元素的位置" << endl;cin >> k >> l;l = TM->Retrieve(k, l);cout << "查询结果:" << l << endl;cout << "***********************************************" << endl;/*下三角矩阵实验开始测试数据4~10~n*(n+1)/241 0 0 02 3 0 04 5 6 07 8 9 -1*/cout << "请输入下三角矩阵维数及内容:" << endl;k = 0, l = 0;cin >> wei;c();LowerTriangularMatrix *LTM = new LowerTriangularMatrix(wei);for (int i = 0; i < wei; i++)for (int j = 0; j < wei; j++)if (num[j][i] != 0)LTM->Store(num[j][i], j, i);cout << "请输入要查询的元素的位置" << endl;cin >> k >> l;l = LTM->Retrieve(k, l);cout << "查询结果:" << l << endl;cout << "***********************************************" << endl;/*稀疏角矩阵实验开始测试数据4 54 51 0 0 0 20 3 0 0 04 0 05 00 6 7 0 84 58 0 7 6 00 5 0 0 40 0 0 3 02 0 0 0 19 0 7 6 20 8 0 0 44 0 0 8 02 6 7 0 9*/cout << "请输入稀疏矩阵的维数及内容:" << endl;cin >> k >> l;SparseMatrix *SM = new SparseMatrix(k, l);for (int i = 0; i < k; i++)for (int j = 0; j < l; j++){cin >> num[i][j];if (num[i][j])SM->Store(num[i][j], i, j);}cout << "稀疏矩阵为: ";SM->print();SM->transpose();cout << "转置后稀疏矩阵为: ";SM->print();SM->transpose();cout << "重新转置后稀疏矩阵为: ";cout << "矩阵相加开始,请输入要使用的矩阵维数及内容:" << endl;cin >> k >> l;SparseMatrix *SM2 = new SparseMatrix(k, l);for (int i = 0; i < k; i++)for (int j = 0; j < l; j++){cin >> num[i][j];if (num[i][j])SM2->Store(num[i][j], i, j);}cout << "新矩阵为: ";SM2->print();SM->Add(*SM2);cout << "矩阵相加后为: ";SM->print();cout << "***********************************************" << endl;cin.get();system("pause");/*使用散列表设计实现一个字典,假设关键字为整数且D为961,在字典中插入随机产生的500个不同的整数,实现字典的建立和搜索操作。

(完整版)数据结构实验报告全集

(完整版)数据结构实验报告全集

数据结构实验报告全集实验一线性表基本操作和简单程序1.实验目的(1)掌握使用Visual C++ 6.0上机调试程序的基本方法;(2)掌握线性表的基本操作:初始化、插入、删除、取数据元素等运算在顺序存储结构和链表存储结构上的程序设计方法。

2.实验要求(1)认真阅读和掌握和本实验相关的教材内容。

(2)认真阅读和掌握本章相关内容的程序。

(3)上机运行程序。

(4)保存和打印出程序的运行结果,并结合程序进行分析。

(5)按照你对线性表的操作需要,重新改写主程序并运行,打印出文件清单和运行结果实验代码:1)头文件模块#include iostream.h>//头文件#include<malloc.h>//库头文件-----动态分配内存空间typedef int elemtype;//定义数据域的类型typedef struct linknode//定义结点类型{elemtype data;//定义数据域struct linknode *next;//定义结点指针}nodetype;2)创建单链表nodetype *create()//建立单链表,由用户输入各结点data域之值,//以0表示输入结束{elemtype d;//定义数据元素dnodetype *h=NULL,*s,*t;//定义结点指针int i=1;cout<<"建立一个单链表"<<endl;while(1){cout <<" 输入第"<< i <<"结点data域值:";cin >> d;if(d==0) break;//以0表示输入结束if(i==1)//建立第一个结点{h=(nodetype*)malloc(sizeof(nodetype));//表示指针hh->data=d;h->next=NULL;t=h;//h是头指针}else//建立其余结点{s=(nodetype*) malloc(sizeof(nodetype));s->data=d;s->next=NULL;t->next=s;t=s;//t始终指向生成的单链表的最后一个节点}i++;}return h;}3)输出单链表中的元素void disp(nodetype*h)//输出由h指向的单链表的所有data域之值{nodetype *p=h;cout<<"输出一个单链表:"<<endl<<" ";if(p==NULL)cout<<"空表";while(p!=NULL){cout<<p->data<<" ";p=p->next;}cout<<endl;}4)计算单链表的长度int len(nodetype *h)//返回单链表的长度{int i=0;nodetype *p=h;while(p!=NULL){p=p->next;i++;}return i;}5)寻找第i个节点nodetype *find(nodetype *h,int i)//返回第i个节点的指针{nodetype *p=h;int j=1;if(i>len(h)||i<=0)return NULL;//i上溢或下溢celse{while (p!=NULL&&j<1)//查找第i个节点,并由p指向该节点{j++;p=p->next;}return p;} }6)单链表的插入操作nodetype *ins(nodetype *h,int i,elemtype x)//在单链表head中第i个节点//(i>=0)之后插入一个data域为x的节点{nodetype *p,*s;s=(nodetype*)malloc(sizeof(nodetype));//创建节点ss->data=x;s->next=NULL;if(i==0)//i=0:s作为该单链表的第一个节点{s->next=h;h=s;}else{p=find(h,i);//查找第i个节点,并由p指向该节点if(p!=NULL){s->next=p->next;p->next=s;}return h;}}7)单链表的删除操作nodetype *del(nodetype *h,int i)//删除第i个节点{nodetype *p=h, *s;int j=1;if(i==1)//删除第1个节点{h=h->next;free(p);}else{p=find(h,i-1);//查找第i-1个节点,并由p指向该节点 if(p!=NULL&&p->next!=NULL){s=p->next;//s指向要删除的节点p->next=s->next;free(s);}else cout<<"输入i的值不正确"<<endl;}return h;}8)释放节点空间void dispose(nodetype *h)//释放单链表的所有节点占用的空间{nodetype *pa=h,*pb;if(pa!=NULL){pb=pa->next;if(pb==NULL)//只有一个节点的情况free(pa);else{while (pb!=NULL)//有两个及以上节点的情况{free(pa);pa=pb;pb=pb->next;}free(pa);}}}9)主程序模块:#include"slink.h"//包含头文件slinkvoid main(){nodetype *head;//定义节点指针变量head=create();//创建一个单链表disp(head);//输出单链表cout<<"单链表长度:"<<len(head)<<endl;ins(head, 2,0);//在第二个节点之后插入以0为元素的节点 disp(head);//输出新链表del(head,2);//删除第二个节点disp(head);//输出新链表}5.实验结果建立一个单链表:输入第1结点data域值:1输入第2结点data域值:2输入第3结点data域值:3输入第4结点data域值:4输入第5结点data域值:5输入第6结点data域值:6输入第7结点data域值:7输入第8结点data域值:8输入第9结点data域值:9输入第10结点data域值0:输出一个单链表:1 2 3 4 5 6 7 8 9单链表长度:9输出一个单链表:1 02345678 9输出一个单链表:1 2 3 4 5 6 7 8实验二顺序栈的实现1.实验目的掌握顺序栈的基本操作:初始化栈、判栈空否、入栈、出栈、取栈顶数据元素等运算以及程序实现方法。

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

《数据结构》实验报告
班级:
学号:
姓名:
实验四二叉树的基本操作实验环境:Visual C++
实验目的:
1、掌握二叉树的二叉链式存储结构;
2、掌握二叉树的建立,遍历等操作。

实验内容:
通过完全前序序列创建一棵二叉树,完成如下功能:
1)输出二叉树的前序遍历序列;
2)输出二叉树的中序遍历序列;
3)输出二叉树的后序遍历序列;
4)统计二叉树的结点总数;
5)统计二叉树中叶子结点的个数;
实验提示:
//二叉树的二叉链式存储表示
typedef char TElemType;
typedef struct BiTNode{
TElemType data;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
一、程序源代码
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 30
typedef char ElemType;
typedef struct TNode *BiTree;
struct TNode {
char data;
BiTree lchild;
BiTree rchild;
};
int IsEmpty_BiTree(BiTree *T) { if(*T == NULL)
return 1;
else
return 0;
}
void Create_BiTree(BiTree *T){
char ch;
ch = getchar();
//当输入的是"#"时,认为该子树为空
if(ch == '#')
*T = NULL;
//创建树结点
else{
*T = (BiTree)malloc(sizeof(struct TNode)); (*T)->data = ch; //生成树结点
//生成左子树
Create_BiTree(&(*T)->lchild);
//生成右子树
Create_BiTree(&(*T)->rchild);
}
}
void TraverseBiTree(BiTree T) { //先序遍历
if(T == NULL)
return;
else {
printf("%c ",T->data);
TraverseBiTree(T->lchild);
TraverseBiTree(T->rchild);
}
}
void InOrderBiTree(BiTree T) { //中序遍历if(NULL == T)
return;
else {
InOrderBiTree(T->lchild);
printf("%c ",T->data);
InOrderBiTree(T->rchild);
}
}
void PostOrderBiTree(BiTree T) {
if(NULL == T)
return;
else {
InOrderBiTree(T->lchild);
InOrderBiTree(T->rchild);
printf("%c ",T->data);
}
}
int TreeDeep(BiTree T) {
int deep = 0;
if(T)
{
int leftdeep = TreeDeep(T->lchild);
int rightdeep = TreeDeep(T->rchild);
deep = leftdeep+1 > rightdeep+1 ? leftdeep+1 : rightdeep+1;
}
return deep;
}
int Leafcount(BiTree T, int &num) {
if(T)
{
if(T->lchild ==NULL && T->rchild==NULL)
{
num++;
printf("%c ",T->data);
}
Leafcount(T->lchild,num);
Leafcount(T->rchild,num);
}
return num;
}
void LevelOrder_BiTree(BiTree T){
//用一个队列保存结点信息,这里的队列采用的是顺序队列中的数组实现 int front = 0;
int rear = 0;
BiTree BiQueue[MAXSIZE];
BiTree tempNode;
if(!IsEmpty_BiTree(&T)){
BiQueue[rear++] = T;
while(front != rear){
//取出队头元素,并使队头指针向后移动一位
tempNode = BiQueue[front++];
//判断左右子树是否为空,若为空,则加入队列 if(!IsEmpty_BiTree(&(tempNode->lchild))) BiQueue[rear++] = tempNode->lchild;
if(!IsEmpty_BiTree(&(tempNode->rchild))) BiQueue[rear++] = tempNode->rchild;
printf("%c ",tempNode->data);
}
}
}
int main(void)
{
BiTree T;
BiTree *p = (BiTree*)malloc(sizeof(BiTree));
int deepth,num=0 ;
Create_BiTree(&T);
printf("先序遍历二叉树:\n");
TraverseBiTree(T);
printf("\n");
printf("中序遍历二叉树:\n");
InOrderBiTree(T);
printf("\n");
printf("后序遍历二叉树:\n");
PostOrderBiTree(T);
printf("\n层次遍历结果:");
LevelOrder_BiTree(T);
printf("\n");
deepth=TreeDeep(T);
printf("树的深度为:%d",deepth);
printf("\n");
printf("树的叶子结点为:");
Leafcount(T,num);
printf("\\n树的叶子结点个数为:%d",num);
return 0;
}
二、运行结果(截图)
三、遇到的问题总结
通过死循环的部分可以看出,在判断时是不能进入结点为空的语句中的,于是从树的构建中寻找问题,最终发现这一条语句存在着问题:
这里给T赋值为空,也就是给整个结构体地址赋值为空,但是我们的目的是给该结构体中的内容,即左孩子的地址指向的内容赋为空。

相关文档
最新文档