数据结构实验三(顺序栈的基本操作)

C语言数据结构之栈的基本操作栈（Stack）是一种先入后出（Last In First Out，简称LIFO）的数据结构，可以实现在一端插入和删除元素。

在C语言中，栈可以使用数组或链表来实现。

本文将介绍栈的基本操作及其在C语言中的实现。

栈的基本操作包括入栈（push）、出栈（pop）、获取栈顶元素（top）、判断栈是否为空（isEmpty）等。

下面我们将分别介绍这些操作在C语言中的实现。

1. 入栈（push）操作入栈操作用于将一个元素添加到栈顶。

在使用数组实现栈时，通常需要一个指针top指向栈顶元素的位置，每次入栈时将元素添加到top的位置，并将top加1、C语言中的入栈操作可以这样实现：```c#define MAX_SIZE 100int stack[MAX_SIZE];int top = 0;void push(int val)if (top < MAX_SIZE)stack[top++] = val;} elseprintf("Stack overflow, cannot push element\n");}```2. 出栈（pop）操作出栈操作用于删除栈顶的元素。

在使用数组实现栈时，只需要将top 减1即可删除栈顶元素。

C语言中的出栈操作可以这样实现：```cint poif (top > 0)return stack[--top];} elseprintf("Stack is empty, cannot pop element\n");return -1;}```3. 获取栈顶元素（top）操作获取栈顶元素操作用于返回栈顶的元素，但不删除它。

在使用数组实现栈时，只需要返回top-1位置上的元素即可。

C语言中的获取栈顶元素操作可以这样实现：```cint toif (top > 0)return stack[top-1];} elseprintf("Stack is empty, top element does not exist\n");return -1;}```4. 判断栈是否为空（isEmpty）操作判断栈是否为空操作用于检查栈中是否有元素。

顺序栈的基本操作(总8页) -CAL-FENGHAI.-(YICAI)-Company One1-CAL-本页仅作为文档封面，使用请直接删除上机实验报告学院：计算机与信息技术学院专业：计算机科学与技术(师范）课程名称：数据结构实验题目：顺序栈的基本操作班级序号：师范1班学号： 2731学生姓名：邓雪指导教师：杨红颖完成时间： 2015年12月25号一、实验目的：1．熟悉掌握栈的定义、结构及性质；?2．能够实现创建一个顺序栈，熟练实现入栈、出栈等栈的基本操作；?3．了解和掌握栈的应用。

二、实验环境：Microsoft Visual c++三、实验内容及要求：栈是一种特殊的线性表，逻辑结构和线性表相同，只是其运算规则有更多的限制，故又称为受限的线性表。

建立顺序栈，实现如下功能：1.建立一个顺序栈2.输出栈3.进栈4.退栈5.取栈顶元素6.清空栈7.判断栈是否为空进行栈的基本操作时要注意栈"后进先出"的特性。

四、概要设计：1、通过循环，由键盘输入一串数据。

创建并初始化一个顺序栈。

2、编写实现相关功能函数，完成子函数模块如下。

3、调用子函数，实现菜单调用功能，完成顺序表的相关操作五、代码：#include<>#include<>#define maxsize 64typedef int datatype;立一个顺序栈\n");printf("\t\t\t2.输出栈\n");printf("\t\t\t3.进栈\n");printf("\t\t\t4.退栈\n");printf("\t\t\t5.取栈顶元素\n");printf("\t\t\t6.清空栈\n");printf("\t\t\t7.判断栈是否为空\n");printf("\t\t\t8.结束程序\n");printf("\t\t___________________________________________\n");do{printf("\n\n请选择想要实现的功能：");scanf("%d",&i);switch(i){case 1:s=SET(s);break;case 2:print(s);printf("\n");break;case 3:s=PUSH(s);print(s);printf("\n");break;case 4:s=POP(s);print(s);printf("\n");break;case 5:TOP(s);break;case 6:SETNULL(s);print(s);printf("\n");break;case 7:j=EMPTY(s);if(j==1)printf("空栈\n");elseprintf("非空栈\n");break;case 8:printf("_________________谢谢使用__________________\n");exit (0);}}while(1);return 0;}六、运行界面菜单功能七、实验中遇到的问题及总结1．在写主函数时，如果是用void?main的形式，那么可以不用有返回值，如果是int?main或status?main的话，要有返回值，即末尾要有return语句。

return OK;
}//InitStack
Status StackEmpty(SqStack &S)
{
if(S.base==S.top)
return OK;
else
return NO;
}
Status ClearStack (SqStack &S)//把S置为空
{
if(S.basypedef char SElemType;
typedef struct
{
SElemType *base;
}//Push
Status Pop(SqStack &S,SElemType &c)
//若栈不空，则删除S的栈顶元素，用c返回其值，并返回OK；否则返回ERROR
{
if(S.top==S.base)
return NO;
c=*--S.top;
return OK;
}//Pop
Status GetTop(SqStack &S,SElemType &e)
1．编写程序任意输入栈长度和栈中的元素值，构造一个顺序栈，对其进行清空、销毁、入栈、出栈以及取栈顶元素操作。
2．编写程序实现表达式求值，即验证某算术表达式的正确性，若正确，则计算该算术表达式的值。
主要功能描述如下：
（1）从键盘上输入表达式。
（2）分析该表达式是否合法：
a)是数字，则判断该数字的合法性。若合法，则压入数据到堆栈中。
{
Push(S,c);
}
GetTop(S,c);
cout<<"栈顶元素为："<<c<<endl;
//ClearStack (S);

《数据结构与算法》实验报告一、实验内容1．栈的实现2．顺序栈的基本操作二、实验目的及要求熟悉栈的基本操作在顺序栈的实现。

通过具体应用实例在复习高级编程语言使用方法的基础上初步了解数据结构的应用。

三、设计分析与算法描述顺序栈的存储结构：typedef struct{int elem[Stack_Size];int top;}SeqStack;void InitStack(SeqStack *S)//构造一个空栈(初始化)int Push(SeqStack *S,int x)//进栈int Pop(SeqStack *S,int *x)//出栈int IsEmpty(SeqStack *S)//判栈是否空int IsFull(SeqStack *S)//判栈是否满int GetTop(SeqStack *S,int *x)//读栈顶四、附件：带注释的源程序#include"iostream.h"#define Stack_Size 50#define false 0#define true 1typedef struct{int elem[Stack_Size];int top;}SeqStack;void InitStack(SeqStack *S)//构造一个空栈(初始化) {S->top=-1;}int Push(SeqStack *S,int x)//进栈{if(S->top==Stack_Size-1)//栈已满return (false);S->top++;S->elem[S->top]=x;return (true);}int Pop(SeqStack *S,int *x)//出栈{if(S->top==-1)//栈已空return (false);else{*x=S->elem[S->top];S->top--;return (true);}}int IsEmpty(SeqStack *S)//判栈是否空{if(S->top==-1)return (true);elsereturn (false);}int IsFull(SeqStack *S)//判栈是否满{if(S->top==Stack_Size-1)return (true);elsereturn (false);}int GetTop(SeqStack *S,int *x)//读栈顶{if(S->top==-1)return (false);else{*x=S->elem[S->top];return (true);}}int main(){int i,temp;SeqStack st;InitStack(&st);for(i=0;i<10;i++)Push(&st,i);while(IsEmpty(&st)){Pop(&st,&temp);cout<<temp<<endl;}return 0;}。

数据结构实验报告顺序栈一、实验目的本次实验的主要目的是深入理解和掌握顺序栈这种数据结构的基本概念、操作原理以及在实际编程中的应用。

通过实际编写代码和进行实验操作，提高对数据结构的理解和编程能力，培养解决实际问题的思维和方法。

二、实验环境本次实验使用的编程环境是Visual Studio 2019，编程语言为C+＋。

三、顺序栈的概念顺序栈是一种线性数据结构，它是基于数组实现的。

顺序栈遵循“后进先出”（Last In First Out，LIFO）的原则，即最后入栈的元素最先出栈。

顺序栈需要预先分配一块连续的存储空间来存储栈中的元素。

在操作过程中，通过一个栈顶指针来指示当前栈顶的位置。

当进行入栈操作时，如果栈未满，则将新元素添加到栈顶指针所指的位置，并将栈顶指针向上移动一位；当进行出栈操作时，如果栈非空，则取出栈顶元素，并将栈顶指针向下移动一位。

四、顺序栈的操作（一）初始化操作｀｀｀cpptypedef struct ｛int data;int top;int capacity;｝ SeqStack;void initStack(SeqStack ＆s, int capacity) ｛sdata ＝ new intcapacity;stop ＝－1;scapacity ＝ capacity;｝｀｀｀在初始化函数中，为顺序栈分配指定大小的存储空间，并将栈顶指针初始化为－1，表示栈为空。

（二）入栈操作｀｀｀cppbool push(SeqStack ＆s, int x) ｛if （stop ＝＝ scapacity 1) ｛return false;｝sdata+＋stop ＝ x;return true;｝｀｀｀入栈操作首先检查栈是否已满，如果未满，则将新元素添加到栈顶，并更新栈顶指针。

（三）出栈操作｀｀｀cppbool pop(SeqStack ＆s, int ＆x) ｛if （stop ＝＝－1) ｛return false;｝x ＝ sdatastop;return true;｝｀｀｀出栈操作首先检查栈是否为空，如果非空，则取出栈顶元素，并更新栈顶指针。

一、实验目的1. 掌握栈的定义、特点、逻辑结构，理解栈的抽象数据类型。

2. 熟练掌握顺序栈和链栈两种结构类型的定义、特点以及基本操作的实现方法。

3. 了解栈在解决实际问题中的应用。

二、实验内容1. 编写顺序栈和链栈的基本操作函数，包括入栈（push）、出栈（pop）、判断栈空（isEmpty）、获取栈顶元素（getTop）等。

2. 利用栈实现字符序列是否为回文的判断。

3. 利用栈实现整数序列中最大值的求解。

三、实验步骤1. 创建顺序栈和链栈的结构体，并实现相关的基本操作函数。

2. 编写一个函数，用于判断字符序列是否为回文。

该函数首先将字符序列中的字符依次入栈，然后逐个出栈，比较出栈的字符是否与原序列相同，若相同则表示为回文。

3. 编写一个函数，用于求解整数序列中的最大值。

该函数首先将序列中的元素依次入栈，然后逐个出栈，每次出栈时判断是否为当前栈中的最大值，并记录下来。

四、实验结果与分析1. 顺序栈和链栈的基本操作函数实现如下：```c// 顺序栈的基本操作void pushSeqStack(SeqStack s, ElemType x) {if (s->top < MAXSIZE - 1) {s->top++;s->data[s->top] = x;}}void popSeqStack(SeqStack s, ElemType x) {if (s->top >= 0) {x = s->data[s->top];s->top--;}}bool isEmptySeqStack(SeqStack s) {return s->top == -1;}ElemType getTopSeqStack(SeqStack s) {if (s->top >= 0) {return s->data[s->top];}return 0;}// 链栈的基本操作void pushLinkStack(LinkStack s, ElemType x) {LinkStack p = (LinkStack )malloc(sizeof(LinkStack)); if (p == NULL) {exit(1);}p->data = x;p->next = s->top;s->top = p;}void popLinkStack(LinkStack s, ElemType x) { if (s->top != NULL) {LinkStack p = s->top;x = p->data;s->top = p->next;free(p);}}bool isEmptyLinkStack(LinkStack s) {return s->top == NULL;}ElemType getTopLinkStack(LinkStack s) {if (s->top != NULL) {return s->top->data;}return 0;}```2. 判断字符序列是否为回文的函数实现如下：```cbool isPalindrome(char str) {SeqStack s;initStack(&s);int len = strlen(str);for (int i = 0; i < len; i++) {pushSeqStack(&s, str[i]);}for (int i = 0; i < len; i++) {char c = getTopSeqStack(&s);popSeqStack(&s, &c);if (c != str[i]) {return false;}}return true;}```3. 求解整数序列中最大值的函数实现如下：```cint getMax(int arr, int len) {LinkStack s;initStack(&s);int max = arr[0];for (int i = 0; i < len; i++) {pushLinkStack(&s, arr[i]);if (arr[i] > max) {max = arr[i];}}while (!isEmptyLinkStack(&s)) {popLinkStack(&s, &max);}return max;}```五、实验心得通过本次实验，我对栈的基本操作有了更深入的理解。

实验三栈的基本操作实验三栈的基本运算学号：0700710319 姓名：梁浩然实验日期：2021年5月6日一、实验目的：（1）掌握栈的各种存储结构及基本运算的实现。

（2）掌握堆栈后进先出的运算原则在解决实际问题中的应用。

（3）复习c语言中相关语句及函数的用法。

（4）进一步熟悉c语言的相关知识，能够把某些c语言知识应用得自如一点。

（5）一定要自己先完成实验的课后习题，认真的思考，能够达到独立思考。

二、实验要求：（1）熟练掌握栈的存储结构及其基本操作。

（2）理解所给出的算法，掌握栈在实际中的应用。

（3）将上机程序调试通过，并能独立完成一至两个拓展题目。

（4）一定要读书老师所给出来的程序。

三、实验内容：认真阅读数据结构的课本，熟悉所学的知识，认真复习c语言的相关的知识，然后对括号配对检查。

试设计一个程序对任意输入的语句或数学表达式，判断其括号是否匹配。

若匹配，则返回1，否则返回0。

调试程序并对相应的输出作出分析；修改输入数据，预期输出并验证输出的结果，加深对算法的理解。

四、实验步骤：首先建立一个栈结构，且初始化栈为空。

然后由键盘上随即输入一个带括号的语句或带括号的数学表达式，同时将它们保存在一个字符型数组exps[]中。

扫描表达式exps,当遇到“(”、“[”、“{”时，将其入栈。

遇到“）”、“]”、“}”时，判断栈顶是否有相匹配的括号。

若没有，则退出扫描过程，返回0，否则直到exps扫描完毕为止。

若top为0，则返回1。

（程序略）五、实验预期的效果：（1）认真的研究实验所给的程序；（2）能读懂实验所给的程序，并且自己可以在计算机上调试成功；（3）根据实验所学的知识能做好老师布置给我们的作业，编写程序并且调试出来运行成功。

（4）在试验后自己要认真的总结该次实验所收获的东西。

六、实验方法实验所给程序修改如下：#include \#define MAXSIZE 100 #define TRUE 1 #define FALSE 0 #define NULLtypedef int datatype;typedef struct /*顺序栈的结构体类型定义*/ {datatype stack[MAXSIZE];int top; }seqstack;void setnull(seqstack *s) //置空栈-由于c语言的数组下标是从0开始的，所以置 {s->top=-1;} //空栈操作时将栈顶指针放在下标为0之前，即-1处。

栈的基本操作实验报告实验目的本实验旨在通过使用栈来实现基本的操作，包括入栈、出栈、查看栈顶元素以及判断栈是否为空。

实验原理栈是一种后进先出（Last-In-First-Out）的数据结构，类似于我们平常生活中的堆栈。

栈有两个基本操作：入栈（Push）和出栈（Pop）。

•入栈：将一个元素放入栈的顶部，使其成为新的栈顶元素。

•出栈：移除栈顶元素，并返回该元素的值。

•查看栈顶元素：返回栈顶元素的值，但不将其从栈中移除。

•判断栈是否为空：若栈中没有元素，则栈为空。

实验步骤以下是使用Python语言来实现栈基本操作的步骤。

1. 创建一个空栈首先，我们需要创建一个空栈。

可以使用列表（List）来模拟栈的操作。

例如：stack = []2. 入栈操作接下来，我们可以通过使用append()函数将元素添加到栈的顶部来进行入栈操作。

例如，我们将数字1和2入栈：stack.append(1)stack.append(2)此时栈的内容为：[1, 2]，其中2为栈顶元素。

3. 出栈操作要进行出栈操作，我们可以使用pop()函数。

该函数会移除并返回栈顶元素的值。

例如：value = stack.pop()print(value) # 输出：2此时栈的内容为：[1]，其中1为新的栈顶元素。

4. 查看栈顶元素要查看栈顶元素的值，我们可以使用索引-1来访问栈的最后一个元素。

例如：value = stack[-1]print(value) # 输出：1此时栈的内容仍为：[1]，其中1为栈顶元素。

5. 判断栈是否为空要判断栈是否为空，我们可以使用条件语句结合len()函数来判断栈的长度是否为0。

例如：if len(stack) ==0:print("栈为空")else:print("栈不为空")由于栈中还有一个元素1，所以输出为“栈不为空”。

实验总结通过本实验，我们学习了栈的基本操作，包括入栈、出栈、查看栈顶元素以及判断栈是否为空。

数据结构\顺序串基本操作实验报告实验报告数据结构\顺序串基本操作一、实验目的本实验旨在通过实践，掌握顺序串的基本操作，包括顺序串的初始化、销毁、插入、删除和查找等。

二、实验内容1\初始化顺序串2\销毁顺序串3\插入元素到顺序串4\删除顺序串中的指定元素5\查找顺序串中的指定元素三、实验步骤1\初始化顺序串顺序串的初始化就是创建一个空顺序串，可以通过创建一个定长数组来实现。

具体步骤如下：（1）定义一个定长数组，例如a[MAX_SIZE]，用于存储顺序串的元素。

（2）定义一个变量len，用于记录顺序串的当前长度，初值为0。

2\销毁顺序串销毁顺序串就是释放顺序串占用的内存空间，具体步骤如下：（1）释放数组a所占用的内存空间。

（2）将len重置为0。

3\插入元素到顺序串插入元素到顺序串就是在指定位置插入一个元素。

具体步骤如下：（1）判断插入位置的合法性，如果位置小于0或大于当前顺序串的长度，即为非法操作。

（2）将len加1，表示顺序串的长度增加了一个。

（3）将插入位置及其之后的元素依次后移一位。

（4）将需要插入的元素存放到插入位置处。

4\删除顺序串中的指定元素删除顺序串中的指定元素就是将顺序串中某个位置的元素删除。

具体步骤如下：（1）判断被删除位置的合法性，如果位置小于0或大于等于当前顺序串的长度，即为非法操作。

（2）将被删除位置之后的元素依次前移一位。

（3）将len减1，表示顺序串的长度减少了一个。

5\查找顺序串中的指定元素查找顺序串中的指定元素就是找出顺序串中第一个与给定元素相等的元素的位置。

具体步骤如下：（1）从顺序串的第一个元素开始逐个与给定元素比较，直到找到相等的元素或搜索到顺序串的末尾。

（2）返回相等元素的位置。

四、实验结果与分析根据实验步骤，我们可以完成顺序串的初始化、销毁、插入、删除和查找等基本操作。

通过这些操作，我们可以对顺序串进行各种元素的插入、删除和查找操作，方便实现顺序串的各种功能。

数据结构上机实验报告实验三栈和队列班级：13级计本二班姓名：杨宴强学号：201392130129实验三栈和队列一、实验目的：⒈学习顺序栈的基本操作2.学习链栈的基本操作3.学习循环队列基本操作4.学习链队列基本操作二、实验内容：⒈顺序栈的基本运算2.链栈的基本操作3.循环队列的基本运算4.链队列的基本运算三、实验步骤及结果：1：顺序栈#include"stdio.h"#include"stdlib.h"#define MAXSIZE 20typedef struct{char data[MAXSIZE];//栈中元素存储空间int top;//栈顶指针}SeqStack;//顺序栈类型void Init_SeqStack(SeqStack **s)//顺序栈初始化{*s=(SeqStack*)malloc(sizeof(SeqStack));//在主函数中申请栈空间(*s)->top=-1;//置栈空标志}int Empty_SeqStack(SeqStack*s)//判断栈是否为空{if(s->top==-1)//栈为空时return 1;//返回1elsereturn 0;//返回0}void Push_SeqStack(SeqStack *s,char x)//顺序栈入栈{if(s->top==MAXSIZE-1)//判断是否栈满printf("Stack is full!\n");//栈已满else{s->top++;//s指向下个节点s->data[s->top]=x;//元素x压入栈*s中}}void Pop_SeqStack(SeqStack *s,char *x)//将栈*s中的栈顶元素出栈并通过参数x返回给主调函数{if(s->top==-1)//栈空返回1printf("Stack is empty!\n");//栈为空else{*x=s->data[s->top];//栈顶元素出栈s->top--;//栈顶指针top-1}}void Top_SeqStack(SeqStack *s,char *x)//取顺序栈栈顶元素{if(s->top==-1)//栈空返回1printf("Stack is empty!\n");//栈为空else{*x=s->data[s->top];//取栈顶元素值}}void print(SeqStack *s)//顺序栈输出{int i;//定义变量ifor(i=0;i<=s->top;i++)//判断printf("%4d",s->data[i]);//读入数据printf("\n");//输出栈}void main(){SeqStack *s;//定义指针schar x,*y=&x;//y是指向x的指针，出栈元素经过y传给变量xInit_SeqStack(&s);//顺序栈初始化if(Empty_SeqStack(s))//判断栈是否为空printf("Stack is empty!\n");printf("Input data of stack:\n");//顺序栈元素入栈scanf("%c",&x);//读入数据while(x!='\n')//对x的计数直到\n结束{Push_SeqStack(s,x);//x入栈scanf("%c",&x);}printf("Output all data of stack:\n");//提示print(s);//输出顺序栈中的元素Pop_SeqStack(s,y);//顺序栈元素出栈printf("Output data of Pop stack:%c\n",*y);//输出出栈元素printf("Output all data of stack:\n");print(s);//输出出栈后顺序栈中的元素Top_SeqStack(s,y);//读取顺序栈栈顶元素printf("Output data of top stack:%c\n",*y);//输出读出的栈顶元素printf("Output all data of stack:\n");print(s);//输出当前的顺序栈中的元素}2链栈#include<stdio.h>#include<stdlib.h>typedef struct node{char data;struct node*next;}StackNode;//链栈元素类型void Init_LinkStack(StackNode**s)//链栈初始化{*s=NULL;}int Empty_LinkStack(StackNode*s)//判断链栈是否为空{if(s==NULL)return 1;elsereturn 0;}void Push_LinkStack(StackNode**top,char x)//链栈元素入栈{StackNode*p;p=(StackNode*)malloc(sizeof(StackNode));//生成存储空间p->data=x;p->next=*top;//新生成的栈顶元素*p其后继为原栈顶元素**top *top=p;//栈顶指针*top指向新的栈顶元素*p}void Pop_LinkStack(StackNode**top,char*x)//链栈元素出栈{StackNode*p;if(*top==NULL)printf("Stack is empty!\n");//栈空else{*x=(*top)->data;//栈顶元素经指针x传给对应的变量p=*top;*top=(*top)->next;free(p);}}void print(StackNode*p)//链栈输出{while(p!=NULL){printf("%c,",p->data);p=p->next;}printf("\n");}void main(){StackNode*s;char x,*y=&x;//出栈元素经指针y传给xInit_LinkStack(&s);//链栈初始化if(Empty_LinkStack(s))//判断链栈是否为空printf("Stack is empty!\n");printf("Input any string:\n");//链栈元素入栈scanf("%c",&x);while(x!='\n'){Push_LinkStack(&s,x);scanf("%c",&x);}printf("Output string:\n");//链栈输出print(s);printf("Output stack:\n");Pop_LinkStack(&s,y); //链栈元素出栈printf("Element of Output stack is %c\n",*y);//输出出栈元素printf("Output string:\n");print(s);//链栈输出}3循环队列#include"stdio.h"#include"stdlib.h"#define MAXSIZE 20typedef struct{char data[MAXSIZE];//队头元素存储空间int rear,front;//队尾和队头指针}SeQueue;//顺序队列类型void Int_SeQueue(SeQueue**q)//置空队{*q=(SeQueue*)malloc(sizeof(SeQueue));//生成循环队列的存储空间(*q)->front=0;//队尾与队头指针相等则为队空(*q)->rear=0;}int Empty_SeQueue(SeQueue*q)//判队空{if(q->front==q->rear)//判断是否队空return 1;//队空elsereturn 0;//队不空}void In_SeQueue(SeQueue*q,char x)//元素入队{if((q->rear+1)%MAXSIZE==q->front)//判断是否队满printf("Queue is full!\n");//队满，入队失败else{q->rear=(q->rear+1)%MAXSIZE;//队尾指针加1q->data[q->rear]=x;//将元素X入队}}void Out_SeQueue(SeQueue*q,char*x)//元素出队{if(q->front==q->rear)//判断是否队空printf("Queue is empty");//队空，出队失败else{q->front=(q->front+1)%MAXSIZE;//队头指针加1*x=q->data[q->front];//队头元素出对并由x返回队头元素值}}void print(SeQueue*q)//循环队列输出{int i;//定义变量ii=(q->front+1)%MAXSIZE;//i入队while(i!=q->rear)//判断队空{printf("%4c\n",q->data[i]);//读入数据信息i=(i+1)%MAXSIZE;//逐步累加}printf("%4c\n",q->data[i]);//输出}void main(){SeQueue*q;//定义指针qchar x,*y=&x;//出对元素经指针y传给xInt_SeQueue(&q);//循环队列初始化if(Empty_SeQueue(q))//判队空printf("Queue is empty!\n");//提示printf("Input any string:\n");//给循环队列输入元素scanf("%c",&x);while(x!='\n'){In_SeQueue(q,x);//元素入队scanf("%c",&x);}printf("Output elements of Queue:\n");print(q);//循环队列输出printf("Output Queue:\n");Out_SeQueue(q,y);//循环队列元素出队printf("Element of Output Queue is %c\n",*y);//输出出队元素printf("Output elements of Queue:\n");print(q);//输出出队后的循环队列元素}4.链队列#include"stdio.h"#include"stdlib.h"#define MAXSIZE 30typedef struct node{char data;struct node *next;}QNode;//链队列结点类型typedef struct{QNode *front,*rear;//将头、尾指针纳入到一个结构体的链队列}LQueue;//链队列类型void Init_LQueue(LQueue **q)//创建一个带头结点的空队列{QNode *p;*q=(LQueue*)malloc(sizeof(LQueue));//申请带头、尾指针的结点p=(QNode*)malloc(sizeof(QNode));//申请链队列的头结点p->next=NULL;//头结点的next指针置为空(*q)->front=p;//队头指针指向头结点(*q)->rear=p;//队尾指针指向头结点}int Empty_LQueue(LQueue *q)//判队空{if(q->front==q->rear)return 1;//队为空elsereturn 0;}void In_LQueue(LQueue *q,char x)//入队{QNode *p;p=(QNode*)malloc(sizeof(QNode));//申请新链队列结点p->data=x;p->next=NULL;//新结点作为队尾结点时其next域为空q->rear->next=p;//将新结点*p链到原队尾结点之后q->rear=p;//是队尾指针指向新的队尾结点*p}void Out_LQueue(LQueue *q,char *x)//出队{QNode *p;if(Empty_LQueue(q))printf("Queue is empty!\n");//队空，出队失败else{p=q->front->next;//指针p指向队头结点q->front->next=p->next;//头结点的next指针指向链队列的第二个数据结点*x=p->data;//将删除的队头结点数据经由指针x返回free(p);if(q->front->next==NULL)//出队后队为空，则置为空队列q->rear=q->front;}}void print(LQueue *q)//链队列输出{QNode *p;p=q->front->next;while(p!=NULL){printf("%4c",p->data);p=p->next;}printf("\n");}void main(){LQueue *q;char x,*y=&x;//出队元素经指针y传给xInit_LQueue(&q);//链队列初始化if(Empty_LQueue(q))//判队空printf("Queue is empty!\n");printf("Input any string:\n");//给链队列输入元素scanf("%c",&x);while(x!='\n'){In_LQueue(q,x);scanf("%c",&x);//元素入队}printf("Output elements of Queue:\n");print(q);//链队列输出printf("Output Queue:\n");Out_LQueue(q,y);//元素出队printf("Element of Output Queue is %c\n",*y);//输出出队的元素值printf("Output elements of Queue:\n");print(q);//输出出队后链队列的元素}四、实验总结：通过本次试验，了解了栈和队列的基本操作。

实验三基于数组的栈基本操作实验一、实验目的1．熟悉并能实现栈的定义和基本操作。

2．了解和掌握栈在递归和非递归算法的应用。

二、实验要求1．进行栈的基本操作时要注意栈“后进先出”的特性。

2．编写完整程序完成下面的实验内容并上机运行。

3．整理并上交实验报告。

三、实验内容1.编写程序任意输入栈长度和栈中的元素值，构造一个顺序栈，对其进行入栈、出栈以及取栈顶元素操作。

写个功能写成一个函数。

#include"stdio.h"#include<stdlib.h>#define MAXSIZE 20typedefstruct{int data[MAXSIZE];int top;}seqstack;seqstackstainit(){seqstack s;s.top=-1;return s;}seqstackstackpush(seqstacks,int x){if(s.top==MAXSIZE-1){ printf("overflow\n");exit(0);}s.top++;s.data[s.top]=x;return s;}intstackpop(seqstack *st){int x;if(st->top==-1){printf("empty\n");exit(0);}x=st->data[st->top];st->top--;return x;}void main(){seqstack s,*st;st=&s;inti,a[5],m;printf("请输入依次入栈中五个值：\n");for(i=0;i<5;i++)scanf("%d",&a[i]);s=stainit();for(i=0;i<5;i++)s=stackpush(s,a[i]);printf("得到的栈顶元素为：\n");for(i=s.top;i>=0;i--){m=stackpop(st);printf("%d\n",m);}}2．从键盘上输入一串带括号的字符，如果其中的括号是匹配的，则输出“balance”，如果括号不匹配，则输出“not balance”#include"stdio.h"#include<stdlib.h>#define MAXSIZE 200typedefstruct{char data[MAXSIZE];int top;}seqstack;seqstackstainit(){seqstack s;s.top=-1;return s;}seqstackstackpush(seqstacks,char x) {if(s.top==MAXSIZE-1){ printf("overflow\n");exit(0);}s.top++;s.data[s.top]=x;return s;}charstackpop(seqstack *st){char x;if(st->top==-1){printf("empty\n");exit(0);}x=st->data[st->top];st->top--;return x;}void main(){char c[MAXSIZE],t,m,*p;int k=0;seqstack s,*st;st=&s;s=stainit();printf("请输入字符串："); gets(c);p=c;for(;*p!='\0';p++){ if(*p!=')'&&*p!=']')if(*p=='('||*p=='['){t=*p;s=stackpush(s,*p); } elsecontinue;if(s.top>=0){if(*p==')'||*p==']'){m=stackpop(st);if((m=='('&&*p==')')||(m=='['&&*p==']')) continue;else{printf("not balance.\n");break;} }}else{s=stackpush(s,*p);k++;if(k==1)printf("not balance.\n");break;}}if(s.top==-1&&*p=='\0')printf("balance.\n");}四、思考与提高1．栈的两种存储结构在判别栈空与栈满时，所依据的条件有何不同？答案略。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

实验03栈的基本操作实验学时：２学时实验类型：上机背景知识：顺序栈、链栈，入栈、出栈。

目的要求：1．掌握栈的思想及其存储实现。

2．掌握栈的常见算法的程序实现。

实验内容：（1）采用顺序存储实现栈的初始化、入栈、出栈操作。

（2）采用链式存储实现栈的初始化、入栈、出栈操作。

（3）在主函数中设计一个简单的菜单，分别测试上述算法。

（4）*综合训练：1）堆栈操作合法性：假设以S和X分别表示入栈和出栈操作。

如果根据一个仅由S 和X构成的序列，对一个空堆栈进行操作，相应操作均可行（如没有出现删除时栈空）且最后状态也是栈空，则称该序列是合法的堆栈操作序列。

请编写程序，输入S和X序列，判断该序列是否合法。

2）括号匹配检验：假设表达式中允许包括两种括号：圆括号和方括号，其嵌套的顺序随意，即([]())或[([][])]等为正确的格式，[(])或([())等均为不正确格式。

输入一个表达式，判断其中的括号是否能正确匹配。

3）表达式转换：算术表达式有前缀表示法、中缀表示法和后缀表示法等形式。

日常使用的算术表达式是采用中缀表示法，即二元运算符位于两个运算数中间。

请设计程序将中缀表达式转换为后缀表达式。

输入在一行中给出不含空格的中缀表达式，可包含+、-、*、\以及左右括号()，表达式不超过20个字符。

在一行中输出转换后的后缀表达式，要求不同对象（运算数、运算符号）之间以空格分隔，但结尾不得有多余空格。

实验说明：1．类型定义顺序栈示例#define MAX 100 //栈的最大值typedef struct{ SElemType *base；SElemType *top；intstacksize；}SqStack；链栈示例typedefintElemType; //元素类型typedefstructsnode{SElemType data;structsnode *next;}StackNode, *LinkStack;2．算法4的每个子功能尽可能写成函数形式。

实验日期： 2017 年 4 月 1 日实验目的及要求1. 熟练掌握栈的结构，以及这种数据结构的特点；2. 能够在两种存储结构上实现栈的基本运算，特别注意栈满和栈空的判断条件及描述方法。

实验内容已知顺序栈的类型定义如下：#define MAX 100typedef char datatype;typedef struct{datatype data[MAX];int top;}SeqStack, *SeqStackptr;任务1．题目要求任务一：创建自定义头文件，包含顺序栈的数据类型定义及基本操作函数，需定义的基本操作如下：（1）void Error(char *s);/*自定义错误处理函数*/（2）void InitStack (SeqStackptr sp);/*初始化栈——置空栈*/（3）int EmptyStack (SeqStackptr sp);/*判栈空*/（4）int FullStack (SeqStackptr sp);/*判栈满*/（5）void Push (SeqStackptr sp, datatype x);/*进栈(元素压入栈顶)*/（6）datatype Pop (SeqStackptr sp);/*出栈(元素从栈顶弹出)*/（7）datatype GetTop (SeqStackptr sp);/*读栈顶元素(不出栈)*/（8）int Count (SeqStackptr sp);/*计算栈中元素个数*/任务二：创建一个新的程序文件，请调用提供的顺序栈操作的函数完成把源文本文件中的所有十进制数转换成相应的指定进制的数值存于新的文本文件中，要求定义如下函数：（1）void Trans(int n, int r, char str[])功能：把n整数转换为r进制的值并存于str数组中；（2）void TransFile(int r,char strin[],char strout[]);功能：把strin文件中十进制整数转换为r进制的值并存于文件strout 中。

实现顺序栈的各种基本运算的算法实验原理一、引言顺序栈是一种常见的数据结构，它的特点是栈中元素的存储是连续的。

顺序栈的基本运算包括入栈、出栈、判空和获取栈顶元素等。

本文将详细介绍实现顺序栈各种基本运算的算法实验原理。

二、顺序栈的定义顺序栈是由一个一维数组和一个栈顶指针组成的数据结构。

栈顶指针指向栈顶元素的位置，当栈为空时，栈顶指针为-1；当栈满时，栈顶指针等于数组的长度减1。

三、顺序栈的入栈操作入栈操作是将一个元素压入栈中。

具体步骤如下：1. 判断栈是否已满，如果满则提示栈已满，无法进行入栈操作；2. 栈顶指针加1；3. 将待入栈的元素存入栈顶指针所指向的位置。

四、顺序栈的出栈操作出栈操作是将栈顶元素删除并返回。

具体步骤如下：1. 判断栈是否为空，如果为空则提示栈已空，无法进行出栈操作；2. 获取栈顶元素的值；3. 栈顶指针减1。

五、顺序栈的判空操作判空操作是判断栈是否为空。

具体步骤如下：根据栈顶指针的值来判断，如果栈顶指针为-1，则表示栈为空，否则表示栈非空。

六、顺序栈的获取栈顶元素操作获取栈顶元素操作是获取栈顶元素的值，但不删除。

具体步骤如下：1. 判断栈是否为空，如果为空则提示栈已空，无法获取栈顶元素；2. 获取栈顶元素的值。

七、顺序栈的算法实现下面以C语言为例，给出顺序栈的算法实现：1. 定义顺序栈的数据结构typedef struct {int top; // 栈顶指针int maxSize; // 栈的最大容量int* data; // 栈的数据存储区} SeqStack;2. 初始化顺序栈void initStack(SeqStack* stack, int maxSize) {stack->top = -1;stack->maxSize = maxSize;stack->data = (int*)malloc(maxSize * sizeof(int)); }3. 入栈操作void push(SeqStack* stack, int value) {if (stack->top == stack->maxSize - 1) {printf("栈已满，无法进行入栈操作\n");return;}stack->top++;stack->data[stack->top] = value;}4. 出栈操作int pop(SeqStack* stack) {if (stack->top == -1) {printf("栈已空，无法进行出栈操作\n");return -1;}int value = stack->data[stack->top];stack->top--;return value;}5. 判空操作int isEmpty(SeqStack* stack) {return stack->top == -1;}6. 获取栈顶元素操作int top(SeqStack* stack) {if (stack->top == -1) {printf("栈已空，无法获取栈顶元素\n");return -1;}return stack->data[stack->top];}八、实验原理1. 实验目的：通过实现顺序栈的各种基本运算，加深对顺序栈的理解，并掌握顺序栈的操作原理和算法实现。

数据结构实验报告三-顺序栈的实现一、实验环境：Windows 10 64位MinGW GCC 4.8.1IDEA：CLoin二、实验内容：编写程序实现一个顺序栈，并利用栈实现将十进制转换成十六进制。

三、算法流程：输入一个十进制数，利用短除法和栈先进先出的特性实现进制的转换。

四、程序代码：#include<stdlib.h>#include<stdio.h>#define MAXSIZE 100#define N 16typedef struct stack{int data[MAXSIZE];int top;}Stack;void initstack(Stack *s){s->top=0;}int stackempty(Stack *s){if(s->top==0)return 1;elsereturn 0;}void push(Stack *s,int i){if(s->top<=MAXSIZE){s->data[s->top]=i;s->top++;}elseprintf("空间不足\n");}int pop(Stack *s){int e;if(!stackempty(s)){s->top--;e=s->data[s->top];return e;}elseprintf("空\n");}void conversion(int num){Stack s;int e;initstack(&s);while(num){push(&s,num%16);num=num/16;}while(!stackempty(&s)){e=pop(&s);if(e==10)printf("A");else if(e==11)printf("B");else if(e==12)printf("C");else if(e==13)printf("D");else if(e==14)printf("E");else if(e==15)printf("F");elseprintf("%d",e);}}int main(){int num;printf("Input a num:\n");scanf("%d",&num);printf("the num converted:\n");conversion(num);return 0;}五、运行截图。

#include<stdio.h>#include<malloc.h>#include<windows.h>#define MAXSIZE 100typedef int DataType;typedef struct stack{DataType data[MAXSIZE];int top;}sqstack;sqstack *InitStack(sqstack *S)//顺序栈的初始化{S->top=-1;return S;}void push(sqstack *S,DataType x)//顺序栈的元素入栈{if(S->top>MAXSIZE-1)printf("error!");elseS->top++;S->data[S->top]=x;}DataType pop(sqstack *S)//顺序栈的元素出栈{int x;if(S->top==-1)printf("Underflow!");else{x=S->data[S->top];printf("出栈的元素为:%d\n",S->data[S->top]);S->top--;}return x;}DataType GetTop(sqstack *S)//顺序栈取顶元素{if(S->top==-1){printf("Underflow!\n");return 0;}elsereturn S->data[S->top];}int Empty(sqstack *S)//顺序栈的判空{if(S->top==-1)return 1;else return 0;}void Digit_conversion(sqstack *S){int i=0,x,y,k[MAXSIZE],m;InitStack(S);printf("请输入一个十进制数和您将要转换的进制数(2,8,16):\n");scanf("%d%d",&x,&y);while(x){push(S,x%y);x=x/y;}while(!Empty(S)){k[i]=pop(S);i++;m=i;}printf("十进制数转化为进制数为:");for(i=0;i<m;i++){if(k[i]>9)printf("%c",k[i]+'A'-10);elseprintf("%3d",k[i]);}}int main(){sqstack *L,*Sqstack;char m;int data;L=(sqstack *)malloc(sizeof(sqstack));system("color 3f");printf(" 菜单列表\n");printf("\t┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");printf("\t┃************************************************************┃\n");printf("\t┃* * *┃\n");printf("\t┃* 0.退出 * 1.顺序栈的初始化 *┃\n");printf("\t┃* * *┃\n");printf("\t┃************************************************************┃\n");printf("\t┃* * *┃\n");printf("\t┃* 2.元素的入栈 * 3.元素的出栈 *┃\n");printf("\t┃* * *┃\n");printf("\t┃************************************************************┃\n");printf("\t┃* * *┃\n");printf("\t┃* 4.取栈顶元素 * 5.判空 *┃\n");printf("\t┃* * *┃\n");printf("\t┃************************************************************┃\n");printf("\t┃* *┃\n");printf("\t┃* 6.将十进制数转换为其他进制数 *┃\n");printf("\t┃* *┃\n");printf("\t┃************************************************************┃\n");printf("\t┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");while((m='0')&&(m='1')&&(m='2')&&(m='3')&&(m='4')&&(m='5')&&(m='6')&&(m='7')) {printf("\n请选择你需要操作的步骤(0至7):");fflush(stdin);scanf("%c",&m);switch(m){case '0':{exit(0);break;}case '1':{Sqstack=InitStack(L);break;}case '2':{printf("输入你要入栈的数据:\n");scanf("%d",&data);fflush(stdin);while(data!=0){push(Sqstack,data);printf("继续输入你要入栈的数据,若想结束,请按0终止\n");scanf("%d",&data);}break;}case '3':{pop(Sqstack);break;}case '4':{printf("输入取出的栈顶元素:\n");printf("其值为:%d\n",GetTop(Sqstack));break;}case '5':{if(Empty(Sqstack)==1)printf("此栈为空!\n");elseprintf("此栈不为空!\n");break;}case '6':{Digit_conversion(Sqstack);break;}}}return 0;}。