算法与数据结构实验报告
数据结构与算法实验报告

数据结构与算法实验报告一、实验目的1.学习并掌握线性表的链式存储结构和链表的基本操作;2.掌握链表的插入、删除、查找等基本操作算法的实现;3.了解链表的应用场景。
二、实验内容与过程本次实验主要包括以下实验内容:1.链表的定义与建立;2.链表的插入操作;3.链表的删除操作;4.链表的查找操作;5.链表的遍历操作;6.链表的逆序操作;7.链表的合并操作。
实验过程如下:1.链表的定义与建立首先,我们定义一个链表的结构,其中包括节点的定义,节点的数据域和指针域。
节点的数据域存放具体的数据,指针域用于指向下一个节点。
```typedef struct Nodeint data;struct Node* next;} Node;```然后,我们定义链表的头指针,并初始化为空链表。
```Node* head = NULL;```2.链表的插入操作插入操作是指在链表中间或末尾插入一个新节点。
首先,我们创建一个新节点,并为其分配内存空间。
```Node* newNode = (struct Node*) malloc(sizeof(Node));newNode->data = 10;newNode->next = NULL;```然后,我们遍历链表,找到插入位置。
```Node* current = head;while (current->next != NULL)current = current->next;```最后,我们将新节点插入到链表中。
```current->next = newNode;```3.链表的删除操作删除操作是指删除链表中的一些节点。
首先,我们找到要删除的节点的前一个节点。
```Node* current = head;while (current->next != NULL && current->next->data != data) current = current->next;```然后,我们将要删除的节点的指针域赋值给前一个节点的指针域。
数据结构与算法分析实验报告

数据结构与算法分析实验报告一、实验目的本次实验旨在通过实际操作和分析,深入理解数据结构和算法的基本概念、原理和应用,提高解决实际问题的能力,培养逻辑思维和编程技巧。
二、实验环境本次实验使用的编程语言为 Python,使用的开发工具为 PyCharm。
操作系统为 Windows 10。
三、实验内容(一)线性表的实现与操作1、顺序表的实现使用数组实现顺序表,包括插入、删除、查找等基本操作。
通过实验,理解了顺序表在内存中的存储方式以及其操作的时间复杂度。
2、链表的实现实现了单向链表和双向链表,对链表的节点插入、删除和遍历进行了实践。
体会到链表在动态内存管理和灵活操作方面的优势。
(二)栈和队列的应用1、栈的实现与应用用数组和链表分别实现栈,并通过表达式求值的例子,展示了栈在计算中的作用。
2、队列的实现与应用实现了顺序队列和循环队列,通过模拟银行排队的场景,理解了队列的先进先出特性。
(三)树和二叉树1、二叉树的遍历实现了先序、中序和后序遍历算法,并对不同遍历方式的结果进行了分析和比较。
2、二叉搜索树的操作构建了二叉搜索树,实现了插入、删除和查找操作,了解了其在数据快速查找和排序中的应用。
(四)图的表示与遍历1、邻接矩阵和邻接表表示图分别用邻接矩阵和邻接表来表示图,并比较了它们在存储空间和操作效率上的差异。
2、图的深度优先遍历和广度优先遍历实现了两种遍历算法,并通过对实际图结构的遍历,理解了它们的应用场景和特点。
(五)排序算法的性能比较1、常见排序算法的实现实现了冒泡排序、插入排序、选择排序、快速排序和归并排序等常见的排序算法。
2、算法性能分析通过对不同规模的数据进行排序实验,比较了各种排序算法的时间复杂度和空间复杂度。
四、实验过程及结果(一)线性表1、顺序表在顺序表的插入操作中,如果在表头插入元素,需要将后面的元素依次向后移动一位,时间复杂度为 O(n)。
删除操作同理,在表头删除元素时,时间复杂度也为 O(n)。
本科生《算法与数据结构》实验报告3

《算法与数据结构》实验报告学院专业姓名学号实验1:ADT List(线性表)(3学时)[问题描述]线性表是典型的线性结构,实现ADT List,并在此基础上实现两个集合的交运算或并运算。
[实验目的](1)掌握线性表链表存储结构。
(2)掌握在单链表上基本操作的实现。
(3)在掌握单链表的基本操作上进行综合题的实现。
[实验内容及要求](1)要求用带头结点的单链表存储两个集合中的元素和最终的结果。
(2)集合的元素限定为十进制数,程序应对出现重复的数据进行过滤,即链表中没有重复数据。
(3)显示两个集合的内容及其运算结果。
[测试数据](1)set1={3, 8, 5, 8,11},set2={22, 6, 8, 3, 15,11,20 }set1∪set2=set1∩set2=(2)set1={1, 3, 5, 7},set2={2, 3, 7, 14, 25,38}set1∪set2=set1∩set2=[思考](1)分析你所设计的算法的时间复杂度?(2) 若输入两个集合内的元素是递增的,见测试数据(2),请你提出一种时间复杂度更少的算法思想,并分析时间复杂度是多少?《算法与数据结构》实验报告学院专业姓名学号实验2:利用栈将中缀表达式转换为后缀表达式并进行计算(3学时)[问题描述]中缀表达式是最普通的一种书写表达式的方式,而后缀表达式不需要用括号来表示,计算机可简化对后缀表达式的计算过程,而该过程又是栈的一个典型应用。
[实验目的](1)深入理解栈的特性。
(2)掌握栈结构的构造方法。
[实验内容及要求](1)中缀表达式中只包含+、-、×、/ 运算及(和)。
(2)可以输入任意中缀表达式,数据为一位整数。
(3)显示中缀表达式及转换后的后缀表达式(为清楚起见,要求每输出一个数据用逗号隔开)。
(4)对转换后的后缀表达式进行计算。
栈的类定义如下:#include <iostream.h>const int StackSize=50;class Stack{char *StackList;int top;public:Stack(){StackList=new char[StackSize];top=-1;}bool IsEmpty();bool IsFull();void Push(char x);char Pop();char GetTop();void postexpression();}; // Stack[测试数据](1)6+3*(9-7)-8/2转换后的后缀表达式为:计算结果为:(2)(8-2)/(3-1)*(9-6)转换后的后缀表达式为:计算结果为:[思考](1)把中缀表达式转化为后缀表达式的好处?(2)考虑当表达式中数据的位数超过一位时,如何修改你的程序?困难在哪?《算法与数据结构》实验报告学院专业姓名学号实验3:n皇后问题(6学时)[问题描述]在一个n×n的国际象棋棋盘上按照每行顺序摆放棋子,在棋盘上的每一个格中都可以摆放棋子,但任何两个棋子不得在棋盘上的同一行、同一列、同一斜线上出现,利用递归算法解决该问题,并给出该问题的n个棋子的一个合理布局。
数据结构与算法实验报告(线性表)

一、实验目的1、深刻理解线性结构的特点以及线性表的概念。
2、熟练掌握线性表的顺序存储结构、链式存储结构及基本运算算法的实现,特别是查找、插入和删除等算法。
二、实验环境1) 硬件:每个学生需配备计算机一台,操作系统:Windows2000/XP。
2) 软件:visual c++6.0。
三、实验题目和实验内容实验题目:线性表的顺序、链式表示及其应用实验内容:1、基本题:实验2.1、实验2.2、实验2. 4、实验2.72、附加题:实验2.3、实验2.6(没做)四、实验数据和实验结果2.1a,b,c,d,e2.2a,b,c,d,e22.4a,b,c,d,e2.7第一个多项式:2x+6x^2-4x^3+3x^4 第二个多项式1x-3x^2+6x^3-3x^4五、附录(程序代码)2.1#include<iostream.h>#include<malloc.h>#define MaxSize 50typedef struct{char data[MaxSize];int length;}SqList;void CreateList(SqList *&L,char a[],int n) {int i;L=(SqList *)malloc(sizeof(SqList));for(i=0;i<n;i++)L->data[i]=a[i];L->length=n;}void InitList(SqList *&L){L=(SqList *)malloc(sizeof(SqList));L->length=0;}void DestroyList(SqList *&L){free(L);}int ListEmpty(SqList *L){return (L->length==0);}int ListLength(SqList *L){return (L->length);}void DispList(SqList *L){int i;for(i=0;i<L->length;i++)cout<<L->data[i];cout<<endl;}char GetElem(SqList *L,int i,char &e){if(i<1||i>L->length)return 0;e=L->data[i-1];return e;}第3 页共15 页int LocateElem(SqList *L,char e){int i=0;while(i<L->length&&L->data[i]!=e) i++;if(i>=L->length)return 0;elsereturn i+1;}int ListInsert(SqList*&L,int i,char e) {int j;if(i<1||i>L->length+1)return 0;i--;for(j=L->length;j>i;j--)L->data[j]=L->data[j-1];L->data[i]=e;L->length++;return 1;}int ListDelete(SqList *&L,int i,char &e) {int j;if(i<1||i>L->length)return 0;i--;e=L->data[i];for(j=i;j<L->length-1;j++)L->length--;return 1;}void main (){SqList *p;char b[10],e;int k;cout<<"元素个数:";cin>>k;cout<<"输入元素:";for(int m=0;m<k;m++)cin>>b[m];InitList(p);4CreateList(p,b,k);cout<<"输出顺序表:";DispList(p);cout<<"顺序表长度是:"<<ListLength(p)<<endl;if(ListEmpty(p))cout<<"顺序表为空"<<endl;elsecout<<"顺序表不为空"<<endl;cout<<"顺序表第3位元素是:"<<GetElem(p,3,e)<<endl;cout<<"元素a的位置是:第"<<LocateElem(p,'a')<<"位"<<endl;ListInsert(p,4,'f');cout<<"在第4个元素上插入元素f:";DispList(p);cout<<"删除顺序表第3个元素:";ListDelete(p,3,e);DispList(p);DestroyList(p);}2.2#include<iostream.h>#include<malloc.h>typedef struct LNode{char data;struct LNode *next;}LinkList;void CreateListR(LinkList *&L,char a[],int n){LinkList *s,*r;int i;L=(LinkList *)malloc(sizeof(LinkList));r=L;for(i=0;i<n;i++){s=(LinkList *)malloc(sizeof(LinkList));s->data=a[i];r->next=s;r=s;}r->next=NULL;}第5 页共15 页void InitList(LinkList *&L){L=(LinkList *)malloc(sizeof(LinkList));L->next=NULL;}void DestroyList(LinkList *&L){LinkList *pre=L,*p=pre->next;while(p){free(pre);pre=p;p=pre->next;}free(pre);}int ListEmpty(LinkList *L){return(L->next==NULL);}int ListLength(LinkList *L){int n=0;LinkList *p=L;while(p->next){n++;p=p->next;}return(n);}void DispList(LinkList *L){LinkList *p=L->next;while(p){cout<<p->data;p=p->next;}cout<<endl;}char GetElem(LinkList *L,int i,char &e) {int j=0;6LinkList *p=L;while(j<i&&p!=NULL){j++;p=p->next;}if(!p)return 0;else{e=p->data;return e;}}int LocateElem(LinkList *L,char e){int i=1;LinkList *p=L->next;while(p&&p->data!=e){p=p->next;i++;}if(!p)return(0);elsereturn(i);}int ListInsert(LinkList *&L,int i,char e){int j=0;LinkList *p=L,*s;while(j<i-1&&p){j++;p=p->next;}if(!p)return 0;else{s=(LinkList *)malloc(sizeof(LinkList));s->data=e;s->next=p->next;第7 页共15 页p->next=s;return 1;}}int ListDelete(LinkList *&L,int i,char &e){int j=0;LinkList *p=L,*q;while(j<i-1&&p){j++;p=p->next;}if(!p)return 0;else{q=p->next;if(!q)return 0;e=q->data;p->next=q->next;free(q);return 1;}}void main(){LinkList *h;char b[10],e;int k;cout<<"元素个数:";cin>>k;cout<<"输入元素:";for(int m=0;m<k;m++)cin>>b[m];InitList(h);CreateListR(h,b,k);cout<<"输出单链表:";DispList(h);cout<<"单链表长度是:"<<ListLength(h)<<endl;if(ListEmpty(h))cout<<"单链表为空"<<endl;else8cout<<"单链表不为空"<<endl;cout<<"单链表第3位元素是:"<<GetElem(h,3,e)<<endl;cout<<"元素a的位置是:第"<<LocateElem(h,'a')<<"位"<<endl;ListInsert(h,4,'f');cout<<"在第4个元素上插入元素f:";DispList(h);cout<<"删除单链表第3个元素:";ListDelete(h,3,e);DispList(h);DestroyList(h);}2.4#include<iostream.h>#include<malloc.h>typedef struct LNode{char data;struct LNode *next;}LinkList;void CreateListR(LinkList *&L,char a[],int n){LinkList *s,*r;int i;L=(LinkList *)malloc(sizeof(LinkList));r=L;for(i=0;i<n;i++){s=(LinkList *)malloc(sizeof(LinkList));s->data=a[i];r->next=s;r=s;}r->next=L;}void InitList(LinkList *&L){L=(LinkList *)malloc(sizeof(LinkList));L->next=NULL;}void DestroyList(LinkList *&L){第9 页共15 页LinkList *pre=L->next,*p=pre->next;L->next=NULL;while(p){free(pre);pre=p;p=pre->next;}free(pre);}int ListEmpty(LinkList *L){return(L->next==NULL);}int ListLength(LinkList *L){int n=0;LinkList *p=L;while(p->next!=L&&p->next){n++;p=p->next;}return(n);}void DispList(LinkList *L){LinkList *p=L->next;while(p!=L&&p){cout<<p->data;p=p->next;}cout<<endl;}char GetElem(LinkList *L,int i,char &e) {int j=1;LinkList *p=L->next;while(j<i&&p!=L&&p){j++;p=p->next;}10return 0;else{e=p->data;return e;}}int LocateElem(LinkList *L,char e){int i=1;LinkList *p=L->next;while(p!=L&&p->data!=e&&p){p=p->next;i++;}if(!p)return(0);elsereturn(i);}int ListInsert(LinkList *&L,int i,char e){int j=1;LinkList *p=L->next,*s;while(j<i-1&&p&&p!=L){j++;p=p->next;}if(!p)return 0;else{s=(LinkList *)malloc(sizeof(LinkList));s->data=e;s->next=p->next;p->next=s;return 1;}}int ListDelete(LinkList *&L,int i,char &e) {第11 页共15 页LinkList *p=L->next,*q;while(j<i-1&&p&&p!=L){j++;p=p->next;}if(!p)return 0;else{q=p->next;if(!q||q==L->next)return 0;e=q->data;p->next=q->next;free(q);return 1;}}void main(){LinkList *h;char b[10],e;int k;cout<<"元素个数:";cin>>k;cout<<"输入元素:";for(int m=0;m<k;m++)cin>>b[m];InitList(h);CreateListR(h,b,k);cout<<"输出循环单链表:";DispList(h);cout<<"循环单链表长度是:"<<ListLength(h)<<endl;if(ListEmpty(h))cout<<"循环单链表为空"<<endl;elsecout<<"循环单链表不为空"<<endl;cout<<"循环单链表第3位元素是:"<<GetElem(h,3,e)<<endl;cout<<"元素a的位置是:第"<<LocateElem(h,'a')<<"位"<<endl;ListInsert(h,4,'f');cout<<"在第4个元素上插入元素f:";DispList(h);12cout<<"删除循环单链表第3个元素:";ListDelete(h,3,e);DispList(h);DestroyList(h);}2.7#include<iostream.h>#include<malloc.h>typedef struct polynomial{int coef; //系数int index; //指数struct polynomial *next;}LinkList;void CreateList(LinkList *&L, int n){LinkList *s,*r;int i;L=(LinkList *)malloc(sizeof(LinkList));r=L;for(i=0;i<n;i++){s=(LinkList*)malloc(sizeof(LinkList));cout<<"依次输入多项式系数和指数:";cin>>s->coef>>s->index;s->next = NULL;r->next=s;r=s;}}void InitList(LinkList *&L){L=(LinkList *)malloc(sizeof(LinkList));L->next=NULL;}void AddList(LinkList *&list1,LinkList *&list2,int m,int n) {LinkList *s,*r,*t;int i;s=list1->next;r=list2->next;t=list1;第13 页共15 页for(i=0;i<n;i++){if(s==NULL){s=list1->next;t=list1;}while(s!=NULL){if(s->index!=r->index){s=s->next;t=t->next;}else break;}if(!s){s=(LinkList*)malloc(sizeof(LinkList));s->coef=r->coef;s->index=r->index;s->next=NULL;t->next=s;s=s->next;r=r->next;continue;}else{if(s->index==r->index)s->coef=s->coef+r->coef;if(s->coef==0){LinkList *temp1;temp1=s;s=s->next;t->next=s;delete temp1;}}r=r->next;s=NULL;}cout<<"多项式相加的结果是:";14list1=list1->next;while(list1){cout<<list1->coef<<"x^"<<list1->index;if(list1->next!=NULL)cout<<"+";list1=list1->next;}}void DispList(LinkList *L){L=L->next;while(L){cout<<L->coef<<"x^"<<L->index;if(L->next!=NULL)if(L->next->coef>0)cout<<"+";L=L->next;}}void main(){LinkList *list1,*list2;InitList(list1);InitList(list2);int m,n;cout<<"请输入第一个多项式的项数:";cin>>m;CreateList(list1,m);cout<<"多项式表示是:";DispList(list1);cout<<endl;cout<<"请输入第二个多项式的项数:";cin>>n;CreateList(list2,n);cout<<"多项式表示是:";DispList(list2);cout<<endl;AddList(list1,list2,m,n);cout<<endl;}第15 页共15 页。
数据结构与算法实验报告

数据结构与算法实验报告实验目的:1.加深对链表的理解,掌握链表的基本操作;2.掌握递归算法的设计思想及应用。
实验内容:本次实验主要包括两个部分的实现与测试,分别为链表的基本操作及递归算法的应用。
一、链表的基本操作1.链表的创建链表的创建主要包括新建链表头结点和逐个插入新结点两个步骤。
首先通过malloc函数新建一个链表头结点,并使链表头结点的指针域为空。
然后通过循环输入新节点的数据值,并将新节点插入到链表的尾部。
2.链表的插入链表的插入操作主要包括在链表头部插入新节点、在链表尾部插入新节点和在链表中间插入新节点。
在插入链表头部时,首先通过malloc函数生成新节点,并将链表头节点指针域的原指向设置为新节点;在插入链表尾部时,首先通过循环找到链表的尾节点,并生成新节点,将尾节点指针域的原指向设置为新节点;在插入链表中间时,首先通过循环找到要插入的位置节点,然后生成新节点,并将新节点指针域的原指向设置为下一个节点,将前一个节点的指针域设置为新节点。
3.链表的删除链表的删除操作主要包括删除头节点、删除尾节点和删除中间节点。
在删除头节点时,首先通过free函数释放头节点的内存空间,然后将链表的头节点指针指向第二个节点;在删除尾节点时,首先通过循环找到倒数第二个节点,并将倒数第二个节点的指针域置空,最后通过free函数释放尾节点的内存空间;在删除中间节点时,首先通过循环找到要删除的节点的前一个节点,然后将前一个节点的指针域指向要删除节点的下一个节点,最后通过free函数释放要删除节点的内存空间。
4.链表的查询链表的查询操作主要包括按位置查询和按值查询。
在按位置查询时,通过循环找到指定位置的节点,然后返回节点的数据值;在按值查询时,通过循环比较节点的数据值与指定值,找到匹配的节点,并返回该节点的位置。
二、递归算法的应用递归算法是一种函数自己调用自己的算法设计思想,具有简洁、清晰的特点。
本次实验主要应用递归算法解决实际问题,包括斐波那契数列的求解和二叉树的遍历。
数据结构与算法实验报告[1]
![数据结构与算法实验报告[1]](https://img.taocdn.com/s3/m/ba40520cb80d6c85ec3a87c24028915f804d84df.png)
数据结构与算法实验报告实验目的:本次实验主要目的是掌握数据结构与算法的基本概念和实际应用。
通过设计和实现特定的数据结构和算法,加深对其原理和应用的理解,培养分析和解决实际问题的能力。
实验内容:本次实验包括以下几个部分:1\实验环境和工具介绍在本部分,将介绍实验所使用的开发环境和工具,包括操作系统、编程语言、集成开发环境等。
2\实验设计和思路本部分将详细介绍实验的设计思路、算法的选择和实现方式。
具体包括数据结构的选择、算法的设计原理、时间和空间复杂度分析等。
3\实验步骤和代码实现在本部分,将详细列出实验的具体步骤和算法的实现代码。
包括数据结构的定义和操作、算法的实现和测试数据的等。
4\实验结果和分析在本部分,将展示实验的运行结果,并对实验结果进行分析和讨论。
包括实际运行时间、空间占用、算法的优缺点等方面的讨论。
5\实验总结和思考在本部分,将对整个实验进行总结和思考。
包括实验过程中遇到的问题和解决方法,对实验结果的评价,以及对进一步的研究方向的思考等内容。
附件:本文档附带以下附件:1\源代码:包括数据结构的定义和操作,算法的实现等。
2\测试数据:用于验证算法实现的测试数据。
3\实验结果截图:包括算法运行结果、时间和空间占用等方面的截图。
法律名词及注释:1\数据结构:在计算机科学中,数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。
2\算法:算法是解决问题的一系列清晰而简明的指令,是计算或操作的一种良定义的规程。
3\时间复杂度:时间复杂度是度量算法运行时间长短的一个表达式,用大O符号表示。
4\空间复杂度:空间复杂度是度量算法运行过程中所需的存储空间的一个表达式,用大O符号表示。
结语:本文档详细介绍了数据结构与算法实验的设计思路、步骤和实现代码,并对实验结果进行了分析和讨论。
实验过程中,我们掌握了数据结构与算法的基本概念和实际应用,提高了问题解决能力和编程实践能力。
算法与及数据结构实验报告

算法与及数据结构实验报告算法与数据结构实验报告一、实验目的本次算法与数据结构实验的主要目的是通过实际操作和编程实现,深入理解和掌握常见算法和数据结构的基本原理、特性和应用,提高我们解决实际问题的能力和编程技巧。
二、实验环境本次实验使用的编程语言为 Python,开发环境为 PyCharm。
同时,为了进行算法性能的分析和比较,使用了 Python 的 time 模块来计算程序的运行时间。
三、实验内容1、线性表的实现与操作顺序表的实现:使用数组来实现顺序表,并实现了插入、删除、查找等基本操作。
链表的实现:通过创建节点类来实现链表,包括单向链表和双向链表,并完成了相应的操作。
2、栈和队列的应用栈的实现与应用:用数组或链表实现栈结构,解决了表达式求值、括号匹配等问题。
队列的实现与应用:实现了顺序队列和循环队列,用于模拟排队系统等场景。
3、树结构的探索二叉树的创建与遍历:实现了二叉树的先序、中序和后序遍历算法,并对其时间复杂度进行了分析。
二叉搜索树的操作:构建二叉搜索树,实现了插入、删除、查找等操作。
4、图的表示与遍历邻接矩阵和邻接表表示图:分别用邻接矩阵和邻接表来存储图的结构,并对两种表示方法的优缺点进行了比较。
图的深度优先遍历和广度优先遍历:实现了两种遍历算法,并应用于解决路径查找等问题。
5、排序算法的比较插入排序、冒泡排序、选择排序:实现了这三种简单排序算法,并对不同规模的数据进行排序,比较它们的性能。
快速排序、归并排序:深入理解并实现了这两种高效的排序算法,通过实验分析其在不同情况下的表现。
6、查找算法的实践顺序查找、二分查找:实现了这两种基本的查找算法,并比较它们在有序和无序数据中的查找效率。
四、实验步骤及结果分析1、线性表的实现与操作顺序表:在实现顺序表的插入操作时,如果插入位置在表的末尾或中间,需要移动后续元素以腾出空间。
删除操作同理,需要移动被删除元素后面的元素。
在查找操作中,通过遍历数组即可完成。
数据结构与算法的实验报告

数据结构与算法的实验报告数据结构与算法第二次实验报告电子105班赵萌2010021526实验二:栈和队列的定义及基本操作一、实验目的:. 熟练掌握栈和队列的特点. 掌握栈的定义和基本操作,熟练掌握顺序栈的操作及应用. 掌握对列的定义和基本操作,熟练掌握链式队列的操作及应用, 掌握环形队列的入队和出队等基本操作. 加深对栈结构和队列结构的理解,逐步培养解决实际问题的编程能力二、实验内容:定义顺序栈,完成栈的基本操作:空栈、入栈、出栈、取栈顶元素;实现十进制数与八进制数的转换;定义链式队列,完成队列的基本操作:入队和出队;1.问题描述:(1)利用栈的顺序存储结构,设计一组输入数据(假定为一组整数),能够对顺序栈进行如下操作:. 初始化一个空栈,分配一段连续的存储空间,且设定好栈顶和栈底;. 完成一个元素的入栈操作,修改栈顶指针;. 完成一个元素的出栈操作,修改栈顶指针;. 读取栈顶指针所指向的元素的值;. 将十进制数N 和其它d 进制数的转换是计算机实现计算的基本问题,其解决方案很多,其中最简单方法基于下列原理:即除d 取余法。
例如:(1348)10=(2504)8N N div 8 N mod 81348 168 4168 21 021 2 52 0 2从中我们可以看出,最先产生的余数4 是转换结果的最低位,这正好符合栈的特性即后进先出的特性。
所以可以用顺序栈来模拟这个过程。
以此来实现十进制数与八进制数的转换; . 编写主程序,实现对各不同的算法调用。
(2)利用队列的链式存储结构,设计一组输入数据(假定为一组整数),能够对链式队列进行如下操作:. 初始化一个空队列,形成一个带表头结点的空队;. 完成一个元素的入队操作,修改队尾指针;. 完成一个元素的出队操作,修改队头指针;. 修改主程序,实现对各不同的算法调用。
其他算法的描述省略,参见实现要求说明。
2.实现要求:对顺序栈的各项操作一定要编写成为C(C++)语言函数,组合成模块化的形式,每个算法的实现要从时间复杂度和空间复杂度上进行评价。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
2015-2016学年第二学期《算法与数据结构》课程实验报告专业软件工程学生姓名成晓伟班级软件141学号**********实验学时16实验教师徐秀芳信息工程学院实验一单链表的基本操作一、实验目的1.熟悉C语言上机环境,进一步掌握C语言的基本结构及特点。
2.掌握线性表的各种物理存储表示和C语言实现。
3.掌握单链表的各种主要操作的C语言实现。
4.通过实验理解线性表中的单链表存储表示与实现。
二、主要仪器及耗材普通计算机三、实验内容与要求1、用C语言编写一个单链表基本操作测试程序。
(1)初始化单链表(2)创建单链表(3)求单链表长度(4)输出单链表中每一个结点元素(5)指定位置插入某个元素(6)查找第i个结点元素的值(7)查找值为e 的结点,并返回该结点指针(8)删除第i个结点(9)销毁单链表2、实验要求(1)程序中用户可以选择上述基本操作。
程序启动后,在屏幕上可以菜单形式显示不同功能,当按下不同数字后完成指定的功能,按其他键,则显示错误后重新选择。
(2)要求用线性表的顺序存储结构,带头结点的单链表存储结构分别实现。
(3)主函数实现对基本操作功能的调用。
3、主要代码(1)初始化单链表LinkList *InitList(){ //创建一个空链表,初始化线性表LinkList *L;L=(LinkList *)malloc(sizeof(LinkList));L->next=NULL;return L;}(2)创建单链表//头插法void CreateListF(LinkList *L){LinkList *s;int i=1,a=0;while(1){printf("输入第%d个元素(0表示终止)",i++);scanf("%d",&a);if(a==0)break;s=(LinkList *)malloc(sizeof(LinkList));s->data=a;s->next=L->next;L->next=s;}}(3)求链表长度int ListLength(LinkList *L){ //求链表长度int n=0;LinkList *p=L;while(p->next!=NULL){p=p->next;n++;}return(n);}(4)在指定位置插入元素int InsertList(LinkList *L,int i,ElemType e){LinkList *p=L,*s;int j=0;while(p!=NULL&&j<i-1){p=p->next;j++;} //找出要插入的位置的前一个位置if(p==NULL){return 0;}else{s=(LinkList *)malloc(sizeof(LinkList));s->data=e;s->next=p->next;p->next=s;return 1;}}(5)输出链表void DispList(LinkList *L){ //输出链表LinkList *p=L->next;while(p!=NULL){printf("%d",p->data);p=p->next;}printf("\n");}(6)查找链表中指定元素int GetElem(LinkList *L,int i){ //查找链表中指定元素LinkList *p=L;int j=0;while(j<i&&p!=NULL){j++;p=p->next;}if(p==NULL){return 0;}else{return p->data;}}(7)查找值是e的结点并返回该指针LinkList *LocateElem(LinkList *L,ElemType e){ //查找值是e的结点并返回该指针int i=1;LinkList *p=L;while(p!=NULL)if(p->data==e) return p;}if(p==NULL){return NULL;}}(8)删除元素int ListDelete(LinkList *L,int i,ElemType *e){ //删除元素LinkList *p=L,*q;int j=0;while(p!=NULL&&j<i-1){p=p->next;j++;} //找到要删除元素地址的前一个地址if(p==NULL){ return 0;} //不能删除else{q=p->next;*e=q->data;p->next=q->next;free(q); //删除成功return 1;}}(9)销毁链表void DestroyList(LinkList *L){//销毁链表LinkList *pre=L,*p=L->next;while(p!=NULL){free(pre);pre=p;p=pre->next;}free(pre);}main函数:int main(){LinkList *L;ElemType e;int i;L=InitList();CreateListF(L);DispList(L);printf("输入要查找的元素位置:\n");scanf("%d",&i);e=GetElem(L,i);printf("%d\n",e);printf("单链表长度为:%d\n",ListLength(L));printf("输入要删除元素的位置:");scanf("%d",&i);if (i>ListLength(L)){printf("超出范围重新输入");scanf("%d",&i);}if(ListDelete(L,i,&e)==0){printf("未找到元素\n");}else DispList(L);printf("输入插入元素的位置和值:");scanf("%d%d",&i,&e);InsertList(L,i,e);DispList(L);return 0;}4、测试数据及测试结果输入:23 56 12 28 45输出:四、注意事项1、存储结构定义和基本操作尽可能用头文件实现。
2、采用缩进格式,加足够多的注释。
3、注意循环条件、边界条件等。
4、善于发现问题、分析问题、解决问题,并总结思考。
5、对于算法描述及实现完全理解。
五、拓展提高1、若L为带头结点的单链表,删除最大值结点2、将两个单链表合并为一个单链表实验二循环链表的基本操作一、实验目的熟练掌握线性表的基本操作在链式循环存储结构上的实现。
二、主要仪器及耗材普通计算机三、实验内容1、在上一次单链表基本操作的基础上,修改程序,将其改为单循环链表,并实现相关操作。
(1)初始化单循环链表(2)创建单循环链表(3)求单循环链表长度(4)输出单循环链表中每一个结点元素(5)指定位置插入某个元素(6)查找第i个结点元素的值(7)查找值为e 的结点,并返回该结点指针(8)删除第i个结点(9)销毁单循环链表2、实验要求(1)程序中用户可以选择上述基本操作。
程序启动后,在屏幕上可以菜单形式显示不同功能,当按下不同数字后完成指定的功能,按其他键,则显示错误后重新选择。
(2)要求用不带头结点的循环链表实现。
(3)具体功能测试由主函数实现。
3、主要代码(1)初始化单循环链表void initLinkList(LinkList L)//初始化循环单链表{L=(LinkList)malloc(sizeof(LNode));L->next=L;//创建一个空表}(2)创建单循环链表LinkList creat(LinkList L)//给循环链表赋值{LinkList p,q,r;int N,i=0;//printf("请输入第%d个值:",++i);while(1){printf("请输入第%d个值:",++i);scanf("%d",&N);//输入节点的值if(N==0)//以0为结尾{break;}if(i==1)//当只有一个节点时{p=(LinkList)malloc(sizeof(LNode));//给p节点分配内存空间p->date =N;p->next =NULL;q=p;}else//当节点不为1时{r=(LinkList)malloc(sizeof(LNode));r->date =N;r->next =NULL;q->next =r;q=r;//}}if(q!=NULL){q->next =p;//将尾节点指向头节点完成循环}L=p;return L;//返回头指针}(3)打印循环链表void print(LinkList L)//打印循环链表{LinkList p;//printf("**\n");p=L;//printf("**\n");if(p==NULL)//当链表尾空表时{printf("这是一个空表\n");}while(p->next!=L)//只有当p节点不为尾节点是打印节点中的数据域{//printf("**\n");printf("%d ",p->date );p=p->next ;}printf("%d\n",p->date );//打印尾节点中的数据}(4)求链表的长度int length(LinkList L)//求链表的长度{LinkList p;//printf("**\n");int n=1;//printf("**\n");p=L;//printf("**\n");while(p->next!=L)//当p节点不为尾节点时计数{n++;//printf("**\n");p=p->next;}return n;//返回链表长度//printf("%d****\n",n);}(5)删除指定位置的节点LinkList del(LinkList L,int flag)//删除指定位置的节点{LinkList p,q;int i;p=L;q=L->next ;//int i=1;if(flag==1)//当删除节点为头结点时{while(q->next !=L)//让p节点为尾节点{q=q->next ;}L=p->next ;//头结点为L->NEXT节点q->next =L;//让尾节点指向新的头结点free(p);//释放p}else{for(i=1;i<flag-1;i++)//让p和q节点到达指定位置{p=p->next ;q=q->next ;}p->next =q->next ;free(q);//删除q节点}return L;//返回头指针}(6)查找第i个结点元素的值int search1(LinkList L,int flag)//按照节点的位置返回节点中的数据{LinkList p;int i;p=L;for(i=1;i<flag;i++)//循环找到节点的位置{p=p->next;}return p->date;//返回节点的数据}(7)查找值为e 的结点,并返回该结点指针int search2(LinkList L,int data)//按照数据来查找节点的位置{LinkList p;int i=1;p=L;while(1){if(p->date==data)//当查找到数据域与查找的数据相同是跳出循环{break;}else{i++;p=p->next;}}return i;}(8)删除第i个结点LinkList insert(LinkList L,int falg,int data)//指定位置插入元素{LinkList p,s;int i;p=L;s=(LinkList)malloc(sizeof(LNode));for(i=1;i<falg;i++)//寻找位置{p=p->next;}s->date=data;//将data赋值给s节点s->next=p->next;p->next=s;return L;}(9)销毁单循环链表LinkList destroy(LinkList L)//销毁循环链表{LinkList p,q;p=L->next ;while(p!=L){q=p->next ;free(p);p=q;}free(L);L=NULL;return L;}……main函数:int main(){LinkList L=NULL;int m,k,Case,Length,DAT1,flag,P,e;printf("**1.创建一个循环链表**\n");printf("**2.打印所创建的循环链表**\n");printf("**3.插入节点**\n");printf("**4.删除节点**\n");printf("**5.求循环的长度**\n");printf("**6.查找第i节点**\n");printf("**7.查找某个值得节点**\n");printf("**8.销毁链表**\n");printf("**9.删除最大节点**\n");printf("**10.退出程序**\n");for(;;){printf(" 请输入操作的序号\n");scanf("%d",&Case);switch(Case){case 1: initLinkList(L);L=creat(L);break;case 2: print(L);break;case 3: printf("请输入需要插入的位置(之后)及其数据\n");scanf("%d%d",&m,&k);L=insert(L,m,k);print(L);break;case 4: printf("请输入需要删除的节点\n");scanf("%d",&Case);L=del(L,Case);print(L);//printf("%d",Length);break;case 5: Length=length(L);printf("循环的长度是%d\n",Length);break;case 6: printf("请输入需要查找的节点序号: ");scanf("%d",&flag);DAT1=search1(L,flag);printf("所查找的节点数据为%d\n",DAT1);break;case 7: printf("输入需要查找的值\n");scanf("%d",&e);P=search2(L,e);printf("所查找的位置是%d\n",P);break;case 8: L=destroy(L);print(L);break;//case 10:case 9: exit(0);break;}}return 0;}4、测试数据及测试结果输入:1 2 3 4 5输出:四、注意事项1、存储结构定义和基本操作尽可能用头文件实现。