实验三实现顺序栈的插入和删除算法

合集下载

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

数据结构与算法分析实验报告一、实验目的本次实验旨在通过实际操作和分析，深入理解数据结构和算法的基本概念、原理和应用，提高解决实际问题的能力，培养逻辑思维和编程技巧。

二、实验环境本次实验使用的编程语言为 Python，使用的开发工具为 PyCharm。

操作系统为 Windows 10。

三、实验内容（一）线性表的实现与操作1、顺序表的实现使用数组实现顺序表，包括插入、删除、查找等基本操作。

通过实验，理解了顺序表在内存中的存储方式以及其操作的时间复杂度。

2、链表的实现实现了单向链表和双向链表，对链表的节点插入、删除和遍历进行了实践。

体会到链表在动态内存管理和灵活操作方面的优势。

（二）栈和队列的应用1、栈的实现与应用用数组和链表分别实现栈，并通过表达式求值的例子，展示了栈在计算中的作用。

2、队列的实现与应用实现了顺序队列和循环队列，通过模拟银行排队的场景，理解了队列的先进先出特性。

（三）树和二叉树1、二叉树的遍历实现了先序、中序和后序遍历算法，并对不同遍历方式的结果进行了分析和比较。

2、二叉搜索树的操作构建了二叉搜索树，实现了插入、删除和查找操作，了解了其在数据快速查找和排序中的应用。

（四）图的表示与遍历1、邻接矩阵和邻接表表示图分别用邻接矩阵和邻接表来表示图，并比较了它们在存储空间和操作效率上的差异。

2、图的深度优先遍历和广度优先遍历实现了两种遍历算法，并通过对实际图结构的遍历，理解了它们的应用场景和特点。

（五）排序算法的性能比较1、常见排序算法的实现实现了冒泡排序、插入排序、选择排序、快速排序和归并排序等常见的排序算法。

2、算法性能分析通过对不同规模的数据进行排序实验，比较了各种排序算法的时间复杂度和空间复杂度。

四、实验过程及结果（一）线性表1、顺序表在顺序表的插入操作中，如果在表头插入元素，需要将后面的元素依次向后移动一位，时间复杂度为 O(n)。

删除操作同理，在表头删除元素时，时间复杂度也为 O(n)。

《数据结构》实验指导书

四、实验说明
1.单链表的类型定义
#include <stdio.h>
typedef int ElemType；//单链表结点类型
typedef struct LNode
{ElemType data;
struct LNode *next;
2.明确栈、队列均是特殊的线性表。
3.栈、队列的算法是后续实验的基础（广义表、树、图、查找、排序等）。
六、实验报告
根据实验情况和结果撰写并递交实验报告。
实验四串
一、预备知识
1.字符串的基本概念
2.字符串的模式匹配算法
二、实验目的
1.理解字符串的模式匹配算法（包括KMP算法）
typedef struct
{ElemType *base；
int front,rear；
} SqQueue；
4.单链队列的类型定义
typedef struct QNode
{QElemType data;
typedef struct list
{ElemType elem[MAXSIZE];//静态线性表
int length; //顺序表的实际长度
} SqList;//顺序表的类型名
五、注意问题
1.插入、删除时元素的移动原因、方向及先后顺序。
4.三元组表是线性表的一种应用，通过它可以更好地理解线性表的存储结构。同时矩阵又是图的重要的存储方式，所以这个实验对更好地掌握线性表对将来对图的理解都有极大的帮助。
六、实验报告
根据实验情况和结果撰写并递交实验报告。
实验六树和二叉树
一、预备知识
1.二叉树的二叉链表存储结构

数据结构C语言单链表上实现插入和删除的算法实验报告

一、实验目的1．掌握单链表的基本操作：插入、删除、查找以及表的合并等运算。

2．掌握运用C语言上机调试单链表的基本方法。

二、实验任务1．试编写在单链表上实现插入和删除的算法。

三、程序流程图四、测试过程及结果五、总结1．程序特点：最小化、模块化、for循环。

2．单链表特点：动态分配内存、必须从已知指针逐一查找数据、通过改变数据间的链接改变顺序。

附录程序清单#include <stdio.h>#include <stdlib.h>struct NODE{int data;NODE *next;};NODE *creatlink(){NODE *head,*p,*s;int i,n;head=(NODE *)malloc(sizeof(NODE));p=head;scanf("%d",&n);for(i=0;i<n;i++){s=(NODE *)malloc(sizeof(NODE));scanf("%d",&s->data);p->next=s;p=s;}p->next=0;return head;}void print(NODE *p){for(p=p->next;p!=0;p=p->next)printf("%d ",p->data);printf("\n");}void insert(NODE *p,int i,int x){NODE *s;int j;for(j=1;j<i;j++)p=p->next;s=(NODE *)malloc(sizeof(NODE));s->data=x;s->next=p->next;p->next=s;}void Delete(NODE *p,int i){NODE *s;int j;for(j=1;j<i;j++)p=p->next;s=p->next;p->next=s->next;free(s);}void main(){int i,x;NODE A=*creatlink();scanf("%d%d",&i,&x);insert(&A,i,x);print(&A);scanf("%d",&i);Delete(&A,i);print(&A);}。

栈和队列的操作实验小结

栈和队列的操作实验小结一、实验目的本次实验旨在深入理解和掌握栈和队列这两种基本数据结构的基本操作，包括插入、删除、查找等操作，并通过实际操作加深对这两种数据结构特性的理解。

二、实验原理栈（Stack）：栈是一种后进先出（Last In First Out，LIFO）的数据结构，即最后一个进入栈的元素总是第一个出栈。

在计算机程序中，栈常常被用来实现函数调用和递归等操作。

队列（Queue）：队列是一种先进先出（First In First Out，FIFO）的数据结构，即第一个进入队列的元素总是第一个出队。

在计算机程序中，队列常常被用来实现任务的调度和缓冲等操作。

三、实验步骤与结果创建一个空栈和一个空队列。

对栈进行入栈（push）和出栈（pop）操作，观察并记录结果。

可以发现，栈的出栈顺序与入栈顺序相反，体现了后进先出的特性。

对队列进行入队（enqueue）和出队（dequeue）操作，观察并记录结果。

可以发现，队列的出队顺序与入队顺序相同，体现了先进先出的特性。

尝试在栈和队列中查找元素，记录查找效率和准确性。

由于栈和队列的特性，查找操作并不像在其他数据结构（如二叉搜索树或哈希表）中那样高效。

四、实验总结与讨论通过本次实验，我更深入地理解了栈和队列这两种数据结构的基本特性和操作。

在实际编程中，我可以根据需求选择合适的数据结构来提高程序的效率。

我注意到，虽然栈和队列在某些操作上可能不如其他数据结构高效（如查找），但它们在某些特定场景下具有无可替代的优势。

例如，在实现函数调用和递归时，栈的特性使得它成为最自然的选择；在实现任务调度和缓冲时，队列的特性使得它成为最佳选择。

我也认识到，不同的数据结构适用于解决不同的问题。

在选择数据结构时，我需要考虑数据的特性、操作的频率以及对时间和空间复杂度的需求等因素。

通过实际操作，我对栈和队列的实现方式有了更深入的理解。

例如，我了解到栈可以通过数组或链表来实现，而队列则可以通过链表或循环数组来实现。

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

算法与及数据结构实验报告算法与数据结构实验报告一、实验目的本次算法与数据结构实验的主要目的是通过实际操作和编程实现，深入理解和掌握常见算法和数据结构的基本原理、特性和应用，提高我们解决实际问题的能力和编程技巧。

二、实验环境本次实验使用的编程语言为 Python，开发环境为 PyCharm。

同时，为了进行算法性能的分析和比较，使用了 Python 的 time 模块来计算程序的运行时间。

三、实验内容1、线性表的实现与操作顺序表的实现：使用数组来实现顺序表，并实现了插入、删除、查找等基本操作。

链表的实现：通过创建节点类来实现链表，包括单向链表和双向链表，并完成了相应的操作。

2、栈和队列的应用栈的实现与应用：用数组或链表实现栈结构，解决了表达式求值、括号匹配等问题。

队列的实现与应用：实现了顺序队列和循环队列，用于模拟排队系统等场景。

3、树结构的探索二叉树的创建与遍历：实现了二叉树的先序、中序和后序遍历算法，并对其时间复杂度进行了分析。

二叉搜索树的操作：构建二叉搜索树，实现了插入、删除、查找等操作。

4、图的表示与遍历邻接矩阵和邻接表表示图：分别用邻接矩阵和邻接表来存储图的结构，并对两种表示方法的优缺点进行了比较。

图的深度优先遍历和广度优先遍历：实现了两种遍历算法，并应用于解决路径查找等问题。

5、排序算法的比较插入排序、冒泡排序、选择排序：实现了这三种简单排序算法，并对不同规模的数据进行排序，比较它们的性能。

快速排序、归并排序：深入理解并实现了这两种高效的排序算法，通过实验分析其在不同情况下的表现。

6、查找算法的实践顺序查找、二分查找：实现了这两种基本的查找算法，并比较它们在有序和无序数据中的查找效率。

四、实验步骤及结果分析1、线性表的实现与操作顺序表：在实现顺序表的插入操作时，如果插入位置在表的末尾或中间，需要移动后续元素以腾出空间。

删除操作同理，需要移动被删除元素后面的元素。

在查找操作中，通过遍历数组即可完成。

实验一：顺序表的插入和删除

实验报告一------顺序表的插入和删除1.实验目的1、输入一批整型数据，建立顺序表；2、实现顺序表的插入（输入插入位置i,插入元素）3、实现顺序表的删除（输入删除元素位置i）4、实现顺序表中数据的显示；5、实现顺序表中数据的查找和定位；6、编写主函数，调试上述算法。

2.实验源代码#include<stdio.h>#define max 100void sequenlist(int s[],int n) //建立一个顺序表{for(int i=0;i<n;i++){printf("顺序表第%d个元素是：\n",i+1);scanf("%d",&s[i]);}printf("所以该顺序表输出为：\n");for(int j=0;j<n;j++){printf("%d\t",s[j]);}putchar('\n');}void insert(int s[],int &n,int i,int x) //顺序表的插入{if(n==max||i<1||i>n+1)printf("插入失败!!!\n");elsefor(int k=n-1;k>=i-1;k--){s[k+1]=s[k];}s[i-1]=x;n++;}void dele(int s[],int &n,int i) //删除元素位置i {if(i<1||i>n+1)printf("无法删除!!!\n");elsefor(int j=i-1;j<n;j++){s[j]=s[j+1];}n--;}void disp(int s[],int n) //输出顺序表数据{printf("该顺序表输出为：\n");for(int j=0;j<n;j++){printf("%d\t",s[j]);}putchar('\n');}void locate(int s[],int &n,int x) //查找和定位{int k;for(int j=0;j<n;j++){if(s[j]==x)k=j+1;}printf("您要查找的数据位于第%d位!\n",k);}int main(){int s[max];int n;int i,x;int num;printf("请输入顺序表的数据元素个数：\n");scanf("%d",&n);sequenlist(s,n); //顺序表的建立printf("******************************************************\n" );printf("*************1.插入***********************************\n");printf("*************2.删除***********************************\n");printf("*************3.输出***********************************\n");printf("*************4.查找***********************************\n");printf("******************************************************\n" );while(1){printf("请选择：\n");scanf("%d",&num);switch(num){case 1:printf("请选择要插入的位置：\n");scanf("%d",&i);printf("请选择要插入的数据：\n");scanf("%d",&x);insert(s,n,i,x);break;case 2:printf("请选择您要删除的元素位置：\n");scanf("%d",&i);dele(s,n,i);break;case 3:disp(s,n);break;case 4:printf("请选择您要查询的元素：\n");scanf("%d",&x);locate(s,n,x);break;default:goto l;break;}}l:return 0;}3．实验结果见下图！。

栈的正序逆序插入删除清空操作源代码

#include<stdio.h>#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( )#include<iostream.h> // cout,cin#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int SElemType;typedef int Status;#define STACK_INIT_SIZE 100// 存储空间初始分配量#define STACKINCREMENT 10 // 存储空间分配增量typedef struct {SElemType *base; // base的初值为NULLSElemType *top; // 栈顶指针int stacksize; // 当前已分配的存储空间，以元素为单位}SqStack;Status InitStack(SqStack &S){// 构造一个空栈SS.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));if(!S.base) exit(OVERFLOW);S.top =S.base;S.stacksize= STACK_INIT_SIZE;return OK;}// STACK_INIT_SIZEStatus StackEmpty (SqStack S){// 若栈S为空栈，则返回TRUE，否则返回FALSEif(S.top-S.base)return FALSE;return TRUE;}Status Push(SqStack &S, SElemType e){// 插入元素e为新的栈顶元素int *Newbase;if(S.top-S.base>=S.stacksize){//栈满，追加存储Newbase=(SElemType*)realloc(S.base,(S.stacksize+ STACKINCREMENT)*sizeof(SElemType));if(!Newbase)exit(OVERFLOW);//存储分配失败S.base=Newbase;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}//pushStatus Pop (SqStack &S,SElemType &e){// 若栈不空，则删除S的栈顶元素，用e返回其值，// 并返回OK；否则返回ERRORif(S.top==S.base)return ERROR;e=*--S.top;return OK;}//PopStatus ClearStack (SqStack &S){// 把S置为空栈S.top=S.base;return OK;}// ClearStack//正序输出void PrintL(SqStack &S){int *p,n;p=S.base;for(n=S.top-S.base;n>0;n--){printf("%d\t",*p);p++;}//逆序输出/*void PrintL(SqStack &S){int *p,n;p=S.top;for(n=0;n<S.top-S.base;n++){printf("%d\t",*--p);//为啥不可以替换--p？？？}}*/void main(){int k,e;//为了区别下边变量的用法不同这里用k区别开n的作用//int n,e;SqStack S;InitStack (S);printf("空栈已经为您创建成功啦！*_* \n");printf("请您输入入栈的元素：^_^ \n"); //$$while(e!=0) //这里的0是输入入栈元素结束的标志{scanf("%d",&e); //输入栈中元素Push(S,e); //进栈操作if(e==0){ //$$Pop (S, e); //$$在打印出来之前删掉栈尾部元素^_^PrintL(S); //$$输出栈break; //$$结束}}// PrintL(S);这里会出现反复输出的现象printf("\n1.插入\t\n2.删除\t\n3.清空\t\n0.退出\t\n请选择您需要的操作序号~_~ \n");while(k){//主函数中定义的k可以用了int n;scanf("%d",&n);switch(n){ //switch(k){case 1:printf("请输入您要插入的数字@_@ --->\t");scanf("%d",&e);printf("\n");//添加Push (S,e);printf("插入栈顶元素后栈的情况如下所示~_~\n");//要清楚地告诉PrintL(S);printf("\n请选择您还需要的操作序号*_*\n");//可删除break;case 2:printf("删除栈尾元素后栈的情况如下所示#_#\n");Pop (S, e);// printf("删除栈顶元素%d \t",e);//输出不好看不用PrintL(S);printf("\n");printf("\n请选择您还需要的操作序号*_*\n");//可删除break;case 3:ClearStack(S);printf("栈已清空!_! !_!");printf("\n请选择您还需要的操作序号*_*\n");//可删除break;case 0:exit(0);break;default: exit(0);}}}总结：这是关于栈的基本操作的程序，我自己调试了一个晚上。

线性表的插入和删除-栈和队列的算法-利用三元组表实现矩阵相加--实验

内蒙古科技大学信息工程学院计算机系《数据结构与算法》实验报告
add(a,b,c);
nodeprint(c);
return 0;
}
实验过程及结果线性表的顺序存储和删除：线性表的链式存储和删除：
顺序栈：
链队列：
实验三：
实验总结
【实验1】
这次实验了解了线性表的顺序存储结构和线性表的链式存储结构的插入和删除的操作，了解了线性表这两种存储方式的不同以及这两种线性表的优缺点，顺序存储结构的效率较低而链式存储结构的插入和删除效率高一些，操作更容易一些。

【实验2】
这次实验初步掌握了栈和队列的简单应用，学会的创建栈和队列，向栈和队列中传入参数，销毁栈和队列。

【实验3】
这次实验掌握了数组的压缩存储和应用，用三元组实现了矩阵之间的相加
1、每个实验项目填写一份实验报告，电子版命名方式为：学号姓名项目号.doc。

例如：1167111182张三3.doc表示张三做的第3个项目的实验报告。

2、实验报告电子版应该在实验后一周内由学习委员收齐后存放在一个文件夹下，文件夹命
名方式为：软件12-1班3，表示软件12-1班第3个项目的实验报告，压缩。

第一时间发送
给任课教师。

必须以班级为单位上交。

顺序栈的实现代码

顺序栈的实现代码顺序栈是一种基于数组实现的栈结构，它具有后进先出（LIFO）的特点。

在顺序栈中，元素的插入和删除操作只能在栈顶进行，即只能在栈顶进行入栈和出栈操作。

下面我们将介绍顺序栈的实现代码。

我们需要定义一个顺序栈的结构体，包含两个主要的成员变量：一个数组用于存储栈中的元素，一个整数用于记录栈顶的位置。

```#include <stdio.h>#define MAX_SIZE 100typedef struct {int data[MAX_SIZE];int top;} SeqStack;```在顺序栈的初始化函数中，我们将栈顶位置初始化为-1，表示栈为空。

```void init(SeqStack *stack) {stack->top = -1;}```接下来，我们实现入栈操作。

入栈操作是将一个元素插入到栈顶的过程。

首先，我们需要判断栈是否已满，如果栈已满则无法插入元素；如果栈未满，则将栈顶位置加1，并将要插入的元素放入栈顶位置。

```void push(SeqStack *stack, int element) {if (stack->top == MAX_SIZE - 1) {printf("Stack is full, cannot push element.\n");return;}stack->top++;stack->data[stack->top] = element;}```然后，我们实现出栈操作。

出栈操作是将栈顶元素删除的过程。

首先，我们需要判断栈是否为空，如果栈为空则无法删除元素；如果栈不为空，则将栈顶位置减1，并返回栈顶元素的值。

```int pop(SeqStack *stack) {if (stack->top == -1) {printf("Stack is empty, cannot pop element.\n");return -1;}int element = stack->data[stack->top];stack->top--;return element;}```接下来，我们实现获取栈顶元素的操作。

数据结构实验顺序表的基本操作

数据结构实验-顺序表的基本操作顺序表是一种线性数据结构，它的元素在内存中是连续存储的。

顺序表具有随机访问的特点，可以通过下标直接访问元素，因此在访问元素时具有较高的效率。

顺序表的基本操作包括插入、删除、查找等，下面将对这些基本操作进行详细介绍。

1. 初始化：初始化顺序表需要为其分配一定的内存空间，以存储元素。

可以使用静态分配或动态分配两种方式来初始化顺序表。

静态分配是在编译时为顺序表分配固定大小的内存空间，而动态分配是在运行时根据需要动态地为顺序表分配内存空间。

2. 插入操作：插入操作是将一个元素插入到顺序表的指定位置上。

在插入元素之前，需要判断顺序表是否已满，如果已满则需要进行扩容操作。

插入元素时，需要将插入位置以及其后的元素向后移动一位，为插入元素腾出位置。

插入操作的时间复杂度为O(n)，其中n为顺序表的长度。

3. 删除操作：删除操作是将顺序表中的一个元素删除。

在删除元素之前，需要判断顺序表是否为空，如果为空则无法进行删除操作。

删除元素时，需要将删除位置后面的元素向前移动一位，覆盖删除位置上的元素。

删除操作的时间复杂度为O(n)，其中n为顺序表的长度。

4. 查找操作：查找操作是根据给定的关键字，在顺序表中查找满足条件的元素。

可以使用顺序查找或二分查找两种方式进行查找。

顺序查找是从顺序表的第一个元素开始，逐个比较关键字，直到找到满足条件的元素或遍历完整个顺序表。

二分查找是在有序顺序表中进行查找，每次将待查找区间缩小一半，直到找到满足条件的元素或待查找区间为空。

查找操作的时间复杂度为O(n)，其中n为顺序表的长度。

5. 修改操作：修改操作是将顺序表中的一个元素修改为新的值。

修改操作需要先进行查找操作，找到待修改的元素，然后将其值修改为新的值。

修改操作的时间复杂度为O(n)，其中n为顺序表的长度。

6. 遍历操作：遍历操作是依次访问顺序表中的每个元素。

可以使用for循环或while循环进行遍历，从第一个元素开始，依次访问每个元素，直到遍历完整个顺序表。

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

实验三顺序栈的插入和删除算法
一．实验目的：
掌握栈在顺序存储结构上的插入和删除运算。

二．实验要求：
1. 给出程序设计的基本思想、原理和算法描述。

2. 画出程序流程图；根据数据结构有关知识编出算法程序；
3. 源程序给出注释。

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

三．实验内容：
1．编写函数实现顺序栈中的插入（入栈）;
2．编写函数实现顺序栈中的删除（出栈）;
3．编写程序实现以下功能:
(1) 创建一个顺序栈:22,33,45,99,8;
(2) 调用插入函数,令元素58入栈;
(3) 调用删除函数,删除栈顶的三个元素;
(4) 输出最终顺序栈中的元素。

算法分析：
进栈，判断栈是否已满，若栈满，则进行溢出处理，若栈未满，将栈顶指针加一，将新元素送入到栈顶指针所指的位置。

出栈，判断栈是否为空，若栈空，进行下溢处理，若栈不空，将栈顶元素赋给变量，将栈顶指针退一。

流程图：
源程序：
#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 50/*定义数组长度*/
int stack[MAXSIZE];/*栈元素的数据类型*/ int top;
void push(int x)
{if(top==MAXSIZE-1)
{printf("栈满溢出\n");
exit(1);
}
else{top++;
stack[top]=x;
}
}
int pop()
{int x;
if(top==-1)
{printf("栈空溢出\n");
exit(1);
}
else
{x=stack[top];
top--;
}
return x;
}
main()
{ int i;top=0;
printf("请输入顺序栈\n");
for(i=1;i<=5;i++)
{scanf("%d",&stack[i]);
top++;
}
push(58);
for(i=1;i<=top;i++)
printf("%3d",stack[i]);/*输出删除后的数组*/
printf("\n");
for(i=1;i<=3;i++)
pop();
for(i=1;i<=top;i++)
printf("%3d",stack[i]);
printf("\n");
}
实验小结：通过本次实验让我对栈的算法有了进一步了解，让我受益良多。