链栈实验

北京信息科技大学数据结构实验二链栈,循环队列和计算器的操纵

int Push_N(SqStack_N *S,float e) {
SNode_N *p; p=(SNode_N *)malloc(sizeof(SNode_N)); if(!p) exit(0); p->data=e; p->next=S->top; S->top=p; S->length++; return 1; }
if(!S.top)return 0; else {
printf("返回栈顶元素%5d\n",S.top->data); } return 0; }//返回栈顶元素
int PrintStack(SqStack &S) {
Stack p; printf("\n 链式队列中的元素"); p=S.top; if(S.top!=NULL) {
int InitStack(SqStack & S) {
S.top=NULL; S.length=0; return 0; }//初始化链式栈
int Push(SqStack &S,int e) {
Stack p; p=(Stack)malloc(sizeof(SNode)); if(!p)exit(0); p->data=e; p->next=S.top; S.top=p; S.length++; return 0; }//插入元素 e
float s; switch(c){
case '+':s=a+b; break; case '-':s=a-b; break; case '*':s=a*b; break; case '/':

栈的实验报告结论(3篇)

第1篇一、实验目的1. 理解栈的基本概念和操作；2. 掌握栈的顺序存储和链式存储实现方法；3. 熟悉栈在程序设计中的应用。

二、实验内容1. 栈的顺序存储结构实现；2. 栈的链式存储结构实现；3. 栈的基本操作（入栈、出栈、判空、求栈顶元素）；4. 栈在程序设计中的应用。

三、实验方法1. 采用C语言进行编程实现；2. 对实验内容进行逐步分析，编写相应的函数和程序代码；3. 通过运行程序验证实验结果。

四、实验步骤1. 实现栈的顺序存储结构；（1）定义栈的结构体；（2）编写初始化栈的函数；（3）编写入栈、出栈、判空、求栈顶元素的函数；（4）编写测试程序，验证顺序存储结构的栈操作。

2. 实现栈的链式存储结构；（1）定义栈的节点结构体；（2）编写初始化栈的函数；（3）编写入栈、出栈、判空、求栈顶元素的函数；（4）编写测试程序，验证链式存储结构的栈操作。

3. 栈在程序设计中的应用；（1）实现一个简单的四则运算器，使用栈进行运算符和操作数的存储；（2）实现一个逆序输出字符串的程序，使用栈进行字符的存储和输出；（3）编写测试程序，验证栈在程序设计中的应用。

五、实验结果与分析1. 顺序存储结构的栈操作实验结果：（1）入栈操作：在栈未满的情况下，入栈操作成功，栈顶元素增加；（2）出栈操作：在栈非空的情况下，出栈操作成功，栈顶元素减少；（3）判空操作：栈为空时，判空操作返回真，栈非空时返回假；（4）求栈顶元素操作：在栈非空的情况下，成功获取栈顶元素。

2. 链式存储结构的栈操作实验结果：（1）入栈操作：在栈未满的情况下，入栈操作成功，链表头指针指向新节点；（2）出栈操作：在栈非空的情况下，出栈操作成功，链表头指针指向下一个节点；（3）判空操作：栈为空时，判空操作返回真，栈非空时返回假；（4）求栈顶元素操作：在栈非空的情况下，成功获取栈顶元素。

3. 栈在程序设计中的应用实验结果：（1）四则运算器：成功实现加、减、乘、除运算，并输出结果；（2）逆序输出字符串：成功将字符串逆序输出；（3）测试程序：验证了栈在程序设计中的应用。

栈的获取实验报告(3篇)

第1篇一、实验目的1. 理解栈的基本概念和特点。

2. 掌握栈的顺序存储结构和链式存储结构。

3. 熟悉栈的基本操作，包括入栈、出栈、判断栈空等。

4. 通过实验，加深对栈在计算机科学中的应用理解。

二、实验内容1. 实现栈的顺序存储结构，包括初始化、入栈、出栈、判断栈空等操作。

2. 实现栈的链式存储结构，包括初始化、入栈、出栈、判断栈空等操作。

3. 设计并实现一个递归算法，求解斐波那契数列的前n项。

4. 设计并实现一个算法，判断一个字符串是否为回文。

三、实验步骤1. 实现栈的顺序存储结构（1）定义栈的结构体，包含栈的最大容量、栈顶指针、栈底指针、栈元素数组等。

（2）编写栈的初始化函数，初始化栈的最大容量、栈顶指针和栈底指针。

（3）编写入栈函数，判断栈是否已满，若未满则将元素压入栈顶。

（4）编写出栈函数，判断栈是否为空，若不为空则将栈顶元素弹出。

（5）编写判断栈空函数，判断栈顶指针是否等于栈底指针。

2. 实现栈的链式存储结构（1）定义栈的节点结构体，包含数据域和指针域。

（2）编写栈的初始化函数，初始化栈头节点。

（3）编写入栈函数，判断栈是否已满，若未满则创建新节点并插入链表头部。

（4）编写出栈函数，判断栈是否为空，若不为空则删除链表头部节点。

（5）编写判断栈空函数，判断栈头节点是否为空。

3. 实现递归算法求解斐波那契数列（1）编写递归函数，计算斐波那契数列的第n项。

（2）调用递归函数，计算斐波那契数列的前n项。

4. 实现判断字符串是否为回文的算法（1）编写一个辅助函数，判断两个字符串是否相等。

（2）将字符串逆序，并判断逆序后的字符串是否与原字符串相等。

四、实验结果与分析1. 顺序栈的实验结果通过实现顺序栈，我们成功完成了初始化、入栈、出栈、判断栈空等操作。

实验结果表明，顺序栈在空间利用上较为高效，但在插入和删除操作时，需要移动栈中元素，时间复杂度为O(n)。

2. 链栈的实验结果通过实现链栈，我们成功完成了初始化、入栈、出栈、判断栈空等操作。

链式栈设计实验报告

一、实验目的1. 理解链式栈的概念和特点。

2. 掌握链式栈的存储结构及基本操作。

3. 通过实验，加深对栈数据结构在实际应用中的理解。

二、实验环境1. 编程语言：C语言2. 操作系统：Windows/Linux3. 开发环境：Visual Studio/Code::Blocks三、实验内容1. 链式栈的定义与存储结构2. 链式栈的基本操作3. 链式栈的应用实例四、实验步骤1. 链式栈的定义与存储结构（1）定义链式栈的结构体：包括数据域和指针域。

```ctypedef struct StackNode {int data; // 数据域struct StackNode next; // 指针域} StackNode, LinkStack;```（2）创建链式栈：初始化链式栈的头指针为NULL。

```cvoid InitStack(LinkStack S) {S = (LinkStack)malloc(sizeof(StackNode));if (S == NULL) {exit(1);}(S)->next = NULL;}```2. 链式栈的基本操作（1）入栈（Push）：在链式栈的头部插入一个新元素。

```cvoid Push(LinkStack S, int x) {StackNode p = (StackNode )malloc(sizeof(StackNode)); if (p == NULL) {exit(1);}p->data = x;p->next = S->next;S->next = p;}```（2）出栈（Pop）：删除链式栈的头部元素，并返回其值。

```cint Pop(LinkStack S) {if (S->next == NULL) {exit(1);}StackNode p = S->next;int x = p->data;S->next = p->next;free(p);return x;}```（3）取栈顶元素（GetTop）：返回链式栈的头部元素的值。

C语言数据结构----链栈实验报告

#include<stdio.h>#include<stdlib.h>#include<time.h>typedef int elemtype;typedef struct node{elemtype data;struct node *next;}node,*linkstack;linkstack *top;//链栈初始化node init_linkstack(){node top;top.next=NULL;return top;}//判栈空int linkstack_pankong(node top) {if(top.next==NULL)return 1;elsereturn 0;}//输出链栈元素void print_linkstack(node *top) {node *p;for(p=top->next;p;p=p->next){printf("%d\t",p->data);}}//入栈void puts_link(node *top,int a){node *p;p=(node *)malloc(sizeof(node));if(p==NULL){}else{p->data=a;p->next=top->next;top->next=p;}}//链栈逆序node nixu_link(node *a){node s,*r;s=init_linkstack();for(r=a->next;r;r=r->next){puts_link(&s,r->data);}return s;}//主函数部分void main(){elemtype x,i,n,a;node top;srand((unsigned)time(NULL));/*初始化链栈*/top=init_linkstack();printf("申请链栈内存空间成功\n");elemtype t;do{printf("\n\t请选择以下选项:\n\t1.生成链栈且输出\n\t2.将链栈逆序输出\n\t0.退出程序\n");printf("请输入对应选项:");scanf("%d",&t);switch(t){case 1:{printf("请输入需要生成随机数的数量: ");scanf("%d",&n);for(i=0;i<n;i++){a=rand()%50;puts_link(&top,a); //调用入栈函数，将随机数入栈}printf("链栈当前内容如下:\n");print_linkstack(&top);}continue;case 2:{if(linkstack_pankong(top)){printf("当前链栈内容是空的!");continue;}printf("链栈逆序输出为:\n");top=nixu_link(&top);print_linkstack(&top);}continue;case 0:break;}}while(t!=0);}。

链栈顺序栈实验报告

第五次实验报告——顺序栈、链栈的插入和删除一需求分析1、在演示程序中，出现的元素以数字出现定义为int型，2、演示程序在计算机终端上，用户在键盘上输入演示程序中规定的运算命令，相应的输入数据和运算结果显示在终端上3、顺序栈的程序执行的命令包括如下：（1）定义结构体（2）顺序栈的初始化及创建（3）元素的插入（4）元素的删除（5）顺序栈的打印结果3、链栈的程序执行的命令包括如下：（1）定义结构体（2）链栈的初始化及创建（3）元素的插入（4）元素的删除（5）链栈的打印结果二概要设计1、顺序栈可能需要用到有序表的抽象数据类型定义：ADT List{数据对象:D={ai|ai∈ElemL, i=1,2,...,n, n≥0}数据关系:R1={<ai-1,ai>|ai-1,ai ∈D, i=2,...,n }基本操作：InitStack(SqStack &S)操作结果：构造一个空栈Push(L,e)操作结果：插入元素e为新的栈顶元素Status Pop(SqStack &S)操作结果：删除栈顶元素}ADT List；2、链栈可能需要用到有序表的抽象数据类型定义：ADT List{数据对象:D={ai|ai∈ElemL, i=1,2,...,n, n≥0}数据关系:R1={<ai-1,ai>|ai-1,ai ∈D, i=2,...,n } 基本操作：LinkStack(SqStack &S)操作结果：构造一个空栈Status Push(L,e)操作结果：插入元素e为新的栈顶元素Status Pop(SqStack &S)操作结果：删除栈顶元素}ADT List；3、顺序栈程序包含的主要模块：(1) 已给定的函数库：（2）顺序栈结构体：（3）顺序栈初始化及创建:(4)元素插入(5)元素删除（6）主程序：4、链栈程序包含的主要模块：(1) 已给定的函数库：（2）链栈结构体：（3）链栈初始化及创建:(4)元素插入(5)元素删除(6)主程序：三详细设计线性栈：结构体#define STACK_INIT_SIZE 100//存储空间初始分配量#define STACKINCREMENT 10//存储空间分配增量typedef struct{int *base;//在构造栈之前和销毁之后，base的值为NULL int *top;//栈顶指针int stacksize;//当前已分配的存储空间，以元素为单位}SqStack#include"Base.h"主函数#include"construction.h"#include"stack_operation.c"int main(){SqStack S;int choice,e;S=InitStack();S=Input_Sq(S);printf("请选择执行的操作，输入1执行入栈操作，输入2执行出栈操作choice=");scanf("%d",&choice);switch(choice){case 1:{printf("请输入插入元素的值e=");scanf("%d",&e);S=Push(S,e);printf("执行入栈操作后的线性栈为");Print_Stack(S);};break;case 2:{S=Pop(S);printf("执行出栈操作后的线性栈为");Print_Stack(S);};break;default : printf("您输入的值不合法");}}线性栈的创建SqStack InitStack()//线性栈的创建{SqStack S;S.base=(int*)malloc(STACK_INIT_SIZE * sizeof(int));//分配存储空间if(!S.base)exit(OVERFLOW);//存储分配失败S.top=S.base;S.stacksize=STACK_INIT_SIZE;return S;}输入函数SqStack Input_Sq(SqStack S)//输入函数{int n,i;printf("请输入元素个数n=");scanf("%d",&n);printf("请输入%d个元素",n);for(i=0;i<n;i++){scanf("%d",S.top);S.top++;}return S;}进栈函数SqStack Push(SqStack S,int e)//进栈函数{if(S.top-S.base>=S.stacksize)//判断栈是否为满，追加存储空间{S.base=(int*)realloc(S.base,(S.stacksize+STACKINCREMENT) *sizeof(int));if(!S.base)exit(OVERFLOW);//存储分配失败S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;//插入元素return S;}出栈函数SqStack Pop(SqStack S)//删除函数{int e;if(S.top==S.base)printf("线性栈为空");e=*--S.top;return S;}输出函数void Print_Stack(SqStack S)//打印函数{int i;while(S.base!=S.top){for(i=0;i<S.top-S.base;i++){S.top--;printf("%5d",*S.top);}printf("\n");}库函数* Base.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() *//* 函数结果状态代码 */#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是函数的类型,其值是函数结果状态代码，如OK等 */typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSEl链栈程序：结构体typedef struct SNode//建立链表结构体{int data;struct SNode *next;}SNode,*LinkStack;主函数#include"Base.h"#include"construction.h"#include"LinkStack_operation.c"int main(){LinkStack S;int choice,e;S=Creatlist_Stack();printf("请选择执行的操作，输入1执行入栈操作，输入2执行出栈操作choice=");scanf("%d",&choice);switch(choice){case 1:{printf("请输入插入元素的值e=");scanf("%d",&e);S=Push(S,e);printf("执行操作入栈后的线性栈为");Print_Stack(S);};break;case 2:{S=Pop(S);printf("执行出栈操作后的线性栈为");Print_Stack(S);};break;default : printf("您输入的值不合法\n");}}创建链栈函数LinkStack Creatlist_Stack()//创建一个链栈{LinkStack S;LinkStack P;int i,n;S=(LinkStack)malloc(sizeof(SNode));S->next=NULL;/* 先建立一个链栈 */printf("请输入元素个数n=");scanf("%d",&n);printf("请输入%d个数据\n",n);i=0;scanf("%d",&S->data);for(i=1;i<n;++i){P=(LinkStack)malloc(sizeof(SNode)); /* 生成新结点 */P->next=S;S=P;scanf("%d",&S->data); /* 输入元素值 */}return S;}入栈函数LinkStack Push(LinkStack S,int e){LinkStack P;if(S==NULL)return ERROR;P=(LinkStack)malloc(sizeof(SNode));P->data=e;P->next=S;S=P;return S;}出栈函数LinkStack Pop(LinkStack S){LinkStack P,Q;P=S;S=S->next;free(P);return S;}输出函数void Print_Stack(LinkStack S){while(S){printf("%5d",S->data);S=S->next;}printf("\n");}库函数* Base.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() *//* 函数结果状态代码 */#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是函数的类型,其值是函数结果状态代码，如OK等 */typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSEl四调试分析:输出函数用了语句S->next!=NULL改正：语句S！=NULL五用户手册:看提示内容六测试结果线性栈：1）请输入元素的个数：4，请输入4个数据 1 2 3 4，请输入执行语句，选择输入1执行入栈操作，选择输入2执行出栈操作choice=1，请输入插入元素的值e=6，执行入栈操作后的线性栈为6 4 3 2 1 2）请输入元素的个数：4，请输入4个数据 1 2 3 4，请输入执行语句，选择输入1执行入栈操作，选择输入2执行出栈操作choice=2,执行出栈操作后的线性栈为3 2 1链栈：1）请输入元素的个数：4，请输入4个数据 1 2 3 4，请输入执行语句，选择输入1执行入栈操作，选择输入2执行出栈操作choice=1，请输入插入元素的值e=6，执行入栈操作后的线性栈为6 4 3 2 1 2）请输入元素的个数：4，请输入4个数据 1 2 3 4，请输入执行语句，选择输入1执行入栈操作，选择输入2执行出栈操作choice=2,执行出栈操作后的线性栈为3 2 1。

栈的链式存储结构的表示和实现实验报告

概要设计：
(1)初始化链栈。 (2)将链栈置空。 (3)完成入栈和出栈操作，完成取栈顶元素操作。 (4)选择菜单上的 0，退出该程序的运行，结束实验内容。初始化栈操作，将栈的栈顶指针置为空值，即设栈 S 和栈顶指针 top， S→top=null。如果所建栈里有数据元素，要将其置空，同样也是将栈顶指针的值置为空值。入栈操作，向栈里插入数据元素。首先要为插入数据元素分配结点，将插入数据元素的值赋值给插入结点的数据域，其次修改栈顶指针的指向关系，即修改插入结点和栈顶指针的地址，最后修改栈顶指针。出栈操作，从栈里删除数据元素。首先要判断栈是否为空栈，如是空栈则操作失败。否则，进行出栈操作，修改删除结点和栈顶指针，最后释放删除结点。取栈顶元素。
1
详细设计： //链栈类型定义 typedef int ElemType; typedef struct stacknode { ElemType data; stacknode *next; }StackNode; typedef struct { stacknode *top; }LinkStack; //入栈 void pushLstack(LinkStack *s,ElemType x) { StackNode *p; p=new StackNode; p->data=x; p->next=s->top; s->top=p; } //出栈
3
printf("链栈空!!\n"); return 0; } else { x=s->top->data; printf("当前链栈的栈顶元素为%d",x); return 0; } } X top
an a1
^

栈的基本操作实验报告

一、实验目的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;}```五、实验心得通过本次实验，我对栈的基本操作有了更深入的理解。

链栈的实现实验心得

链栈的实现实验心得链栈的实现实验心得做煤化学实验，给我最大的感触是：一种知识的融会贯通后的实践，在实践中寻觅知识的脚步，在巩固中感受实践的印证，使理论与实践做到良好的水乳交融，相得益彰。

当然，整个实验里程并不是想象中那样，操作简易，程序，流程便捷。

整个过程，虽谈不上错综复杂，烟雾缭绕，盘曲错节，但，实验前若不能做好充分的准备和确实有效的预习工作，实验过程中会遇到各种各样之前没有预见到的问题。

所以，预习是实验前必要的准备之一，也是整个实验里程是否顺利成功的关键元素。

这是我最大的体会。

在做煤化学实验的过程中，最令人兴奋的是，在忙忙碌碌，有条不紊的实验步躲之后，经过了或漫长或短暂的等待之后，揭开实验结果面纱的那一刻，犹如园丁辛勤开垦，浇灌之后等待含苞待放的花朵的那样兴奋与紧张，在看到自己亲力亲为后的实验成果，内心的喜悦与自豪是无法自抑的。

当然，其中也不乏实验失败的时候，我觉得这时候是对人最大的考验，既是考验人耐心的时候，更是对一个人毅力和责任心的'考验，因为，做实验对每个人来说是一次对知识的巩固和运用的过程，是对知识的变相提高与升华，所以，机会既珍贵又难得，我们应该珍惜机会，不该仅仅以得到实验数据为目的而轻易地放弃不断探索与求知的机会，因为，知识永远不是一成不变的，也许通过自己的亲身实践能令我们发现学术界所没有发掘的知识，难道这不是一种别样的收获吗？那才是我们身为学者的真正求知的态度。

在做实验的整个过程中，我觉得获益匪浅，我感受到了知识带给我的震撼与快乐，原来知识的海洋远不是我们所理解的那样狭隘与有限，它是那么地浩淼，广阔无垠，无边无际。

我学到了很多，也掌握了很多，充分地感知到实践与理论是不可分割的有机整体。

像是，煤的工业分析，也称煤的技术分析或实用分析，工业分析的结果是煤炭加工利用和煤炭科学研究的基础技术参数。

碳氢元素是构成煤中有机质的主要元素，碳氢的含量可作为表征煤化程度的指标，碳氢元素含量是煤炭加工利用的重要依据。

西南科技大学数据结构实验报告栈的基本操作

西南科技大学数据结构实验报告实验名称：栈的基本操作实验环境：windows 7 VS2010实验类别：指导教师：专业班级：姓名：学号：1、掌握栈的链式存储结构2、学会栈基本运算的实现二、实验内容我所做的实验是实验题3.2，编写程序3-2.cpp，实现链栈的各种基本运算，并在此基础上设计一个主程序完成如下功能（1）、初始化链栈s；（2）、判断链栈s是否非空；（3）、依次进栈元素a,b,c,d,e;（4）、判断链栈s是否非空；（5）、输出链栈长度；（6）、输出从栈顶到栈底元素；（7）、输出出链栈序列；（8）、判断链栈s是否非空；（9）、释放链栈。

本次实验我是用C++来完成的，链栈也就是采用单链表实现，链栈的优点是不存在栈满上溢的情况，规定栈的所有操作都是在单链表的表头进行的，所以实现链栈也就是对单链表的简化。

下面具体介绍一下本次实验的实验过程：1、初始化链栈要建立链栈的头结点，并将其next域置为NULL。

2、链栈为空的条件是栈的指针的下一个指向空（s->next==NULL）,也就是单链表中没有数据结点。

3、进栈也就是将新数据结点插入到头结点之后。

4、链栈的长度也就是从第一个数据结点开始扫描单链表，从而保存访问的数据结点的个数，然后将其值返回。

5、从栈顶到栈底元素的输出也就是从第一个数据结点开始扫描单链表吗，并输出当前访问结点的数据域值6、输出出栈序列是在栈不为空的条件下，将头结点的指针域所指数据结点的数据域输出，然后将其空间释放，也就是删除。

7、释放链栈也就是对栈的销毁，释放栈占用的全部存储空间四、实验结果本次实验实现了栈的各种基本运算，并对其进行检验，均没有发生错误，符合实验要求。

五、实验心得通过本次实验，可以说我对单链表的操作再一次熟悉了一遍，并且了解到栈在实际应用当中也很广泛，例如在计算器当中的表达式的求值可以用栈来实现，DFS深度优先搜索也可以用栈来实现，从而解决了求解迷宫问题等等。

实验七链栈

实验七链栈1. 创建一个包含数字元素的链栈，同时具有如下功能：【1】初始化一个链栈【2】输出链栈中各结点的值【3】在链栈中插入值为x的新元素【4】在链栈中出栈操作并打印被删除的元素【5】给出当前的栈顶元素提示：第一步：定义该链栈的存储结构（元素都是整型数字）第二步：定义5种操作的函数第三步：编写main函数。

使用switch函数，根据用户的输入，实现链栈相应的基本操作。

2. 选做实验：把第1题中的数字元素改为学生信息表中的信息（学号，姓名，成绩），同时具有上面的5种功能。

#include <stdio.h>#include <stdlib.h>typedef struct stacknode{int data;struct stacknode *next;}stacknode;typedef struct{stacknode *top;}stackk;stackk *initlink(){stackk *s;s=(stacknode*)malloc(sizeof(stacknode));s->top=NULL;return s;}int pushlink(stackk *s,int x){stacknode *q;q=(stacknode *)malloc(sizeof(stacknode));q->data=x;q->next=s->top;s->top=q;}display(stackk *s){stacknode *p;p=s->top;printf("display the stacknode:\n");if (s->top=NULL) printf("the stacknode is empty!\n");else {while(p){printf("->%d",p->data);p=p->next;}}}int poplink(stackk *s){stacknode *p; int v;if(s->top==NULL) printf("The stack is empty\n"); else {v=s->top->data;p=s->top;s->top=s->top->next;free(p);return v;}}int gettop(stackk *s){int e;if(s->top==NULL) printf("The stack is empty!\n");e=s->top->data;return e;}main(stacknode *p){int n,k,i,select,h,x1,x2;printf("create a empty stacknode!\n");p = initlink();printf("input a stacknode length:\n");scanf("%d",&n);for (i=1;i<=n;i++){printf("input a stacknode value:\n");scanf("%d",&k);pushlink(p,k);}printf("select 1:display()\n");printf("select 2:pushlink()\n");printf("select 3:poplink()\n");printf("select 4:gettop()\n");printf("input a your select(1-4):\n");scanf("%d",&select);switch(select){case 1:{display(p);break;}case 2:{printf("input a push a value :\n");scanf("%d",&h);pushlink(p,h);display(p);break;}case 3:{x1=poplink(p);printf("x1->%d\n",x1);display(p);break;}case 4: {x1=gettop(p);printf("x1->%d",x1); break;}}}。

链栈顺序栈实验报告

第五次实验报告——顺序栈、链栈的插入和删除一需求分析1、在演示程序中，出现的元素以数字出现定义为int型，2、演示程序在计算机终端上，用户在键盘上输入演示程序中规定的运算命令，相应的输入数据和运算结果显示在终端上3、顺序栈的程序执行的命令包括如下：（1）定义结构体（2）顺序栈的初始化及创建（3）元素的插入（4）元素的删除（5）顺序栈的打印结果3、链栈的程序执行的命令包括如下：（1）定义结构体（2）链栈的初始化及创建（3）元素的插入（4）元素的删除（5）链栈的打印结果二概要设计1、顺序栈可能需要用到有序表的抽象数据类型定义：ADT List{数据对象:D={ai|ai∈ElemL, i=1,2,...,n, n≥0}数据关系:R1={<ai-1,ai>|ai-1,ai ∈D, i=2,...,n }基本操作：InitStack(SqStack &S)操作结果：构造一个空栈Push(L,e)操作结果：插入元素e为新的栈顶元素Status Pop(SqStack &S)操作结果：删除栈顶元素}ADT List；2、链栈可能需要用到有序表的抽象数据类型定义：ADT List{数据对象:D={ai|ai∈ElemL, i=1,2,...,n, n≥0}数据关系:R1={<ai-1,ai>|ai-1,ai ∈D, i=2,...,n } 基本操作：LinkStack(SqStack &S)操作结果：构造一个空栈Status Push(L,e)操作结果：插入元素e为新的栈顶元素Status Pop(SqStack &S)操作结果：删除栈顶元素}ADT List；3、顺序栈程序包含的主要模块：(1) 已给定的函数库：（2）顺序栈结构体：（3）顺序栈初始化及创建:(4)元素插入(5)元素删除（6）主程序：4、链栈程序包含的主要模块：(1) 已给定的函数库：（2）链栈结构体：（3）链栈初始化及创建:(4)元素插入(5)元素删除(6)主程序：三详细设计线性栈：结构体#define STACK_INIT_SIZE 100//存储空间初始分配量#define STACKINCREMENT 10//存储空间分配增量typedef struct{int *base;//在构造栈之前和销毁之后，base的值为NULL int *top;//栈顶指针int stacksize;//当前已分配的存储空间，以元素为单位}SqStack#include"Base.h"主函数#include"construction.h"#include"stack_operation.c"int main(){SqStack S;int choice,e;S=InitStack();S=Input_Sq(S);printf("请选择执行的操作，输入1执行入栈操作，输入2执行出栈操作choice=");scanf("%d",&choice);switch(choice){case 1:{printf("请输入插入元素的值e=");scanf("%d",&e);S=Push(S,e);printf("执行入栈操作后的线性栈为");Print_Stack(S);};break;case 2:{S=Pop(S);printf("执行出栈操作后的线性栈为");Print_Stack(S);};break;default : printf("您输入的值不合法");}}线性栈的创建SqStack InitStack()//线性栈的创建{SqStack S;S.base=(int*)malloc(STACK_INIT_SIZE * sizeof(int));//分配存储空间if(!S.base)exit(OVERFLOW);//存储分配失败S.top=S.base;S.stacksize=STACK_INIT_SIZE;return S;}输入函数SqStack Input_Sq(SqStack S)//输入函数{int n,i;printf("请输入元素个数n=");scanf("%d",&n);printf("请输入%d个元素",n);for(i=0;i<n;i++){scanf("%d",S.top);S.top++;}return S;}进栈函数SqStack Push(SqStack S,int e)//进栈函数{if(S.top-S.base>=S.stacksize)//判断栈是否为满，追加存储空间{S.base=(int*)realloc(S.base,(S.stacksize+STACKINCREMENT) *sizeof(int));if(!S.base)exit(OVERFLOW);//存储分配失败S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;//插入元素return S;}出栈函数SqStack Pop(SqStack S)//删除函数{int e;if(S.top==S.base)printf("线性栈为空");e=*--S.top;return S;}输出函数void Print_Stack(SqStack S)//打印函数{int i;while(S.base!=S.top){for(i=0;i<S.top-S.base;i++){S.top--;printf("%5d",*S.top);}printf("\n");}库函数* Base.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() *//* 函数结果状态代码 */#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是函数的类型,其值是函数结果状态代码，如OK等 */typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSEl链栈程序：结构体typedef struct SNode//建立链表结构体{int data;struct SNode *next;}SNode,*LinkStack;主函数#include"Base.h"#include"construction.h"#include"LinkStack_operation.c"int main(){LinkStack S;int choice,e;S=Creatlist_Stack();printf("请选择执行的操作，输入1执行入栈操作，输入2执行出栈操作choice=");scanf("%d",&choice);switch(choice){case 1:{printf("请输入插入元素的值e=");scanf("%d",&e);S=Push(S,e);printf("执行操作入栈后的线性栈为");Print_Stack(S);};break;case 2:{S=Pop(S);printf("执行出栈操作后的线性栈为");Print_Stack(S);};break;default : printf("您输入的值不合法\n");}}创建链栈函数LinkStack Creatlist_Stack()//创建一个链栈{LinkStack S;LinkStack P;int i,n;S=(LinkStack)malloc(sizeof(SNode));S->next=NULL;/* 先建立一个链栈 */printf("请输入元素个数n=");scanf("%d",&n);printf("请输入%d个数据\n",n);i=0;scanf("%d",&S->data);for(i=1;i<n;++i){P=(LinkStack)malloc(sizeof(SNode)); /* 生成新结点 */P->next=S;S=P;scanf("%d",&S->data); /* 输入元素值 */}return S;}入栈函数LinkStack Push(LinkStack S,int e){LinkStack P;if(S==NULL)return ERROR;P=(LinkStack)malloc(sizeof(SNode));P->data=e;P->next=S;S=P;return S;}出栈函数LinkStack Pop(LinkStack S){LinkStack P,Q;P=S;S=S->next;free(P);return S;}输出函数void Print_Stack(LinkStack S){while(S){printf("%5d",S->data);S=S->next;}printf("\n");}库函数* Base.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() *//* 函数结果状态代码 */#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是函数的类型,其值是函数结果状态代码，如OK等 */typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSEl四调试分析:输出函数用了语句S->next!=NULL改正：语句S！=NULL五用户手册:看提示内容六测试结果线性栈：1）请输入元素的个数：4，请输入4个数据 1 2 3 4，请输入执行语句，选择输入1执行入栈操作，选择输入2执行出栈操作choice=1，请输入插入元素的值e=6，执行入栈操作后的线性栈为6 4 3 2 1 2）请输入元素的个数：4，请输入4个数据 1 2 3 4，请输入执行语句，选择输入1执行入栈操作，选择输入2执行出栈操作choice=2,执行出栈操作后的线性栈为3 2 1链栈：1）请输入元素的个数：4，请输入4个数据 1 2 3 4，请输入执行语句，选择输入1执行入栈操作，选择输入2执行出栈操作choice=1，请输入插入元素的值e=6，执行入栈操作后的线性栈为6 4 3 2 1 2）请输入元素的个数：4，请输入4个数据 1 2 3 4，请输入执行语句，选择输入1执行入栈操作，选择输入2执行出栈操作choice=2,执行出栈操作后的线性栈为3 2 1。

链栈的实现实验内容原理

链栈的实现实验内容原理
链栈的实现实验内容和原理可以按以下步骤详细阐述:
一、链栈的基本概念
链栈是一种重要的数据结构,它只允许在一端进行插入和删除操作的线性表。

进行插入操作的一端称为栈顶,进行删除操作的一端称为栈底。

二、链栈的存储结构
链栈使用链表来存储元素,每个元素使用结点来表示,结点包含数据域和指针域,通过指针链接结点来实现栈的结构。

三、设计链栈的存储结构
为了实现链栈,需要设计存储结点的结构体,包含要存储的数据和指向下一个结点的指针。

还要定义栈的头指针,指向栈顶结点。

四、实现链栈的基本操作
1. 初始化栈:将头指针指向NULL,表示空栈。

2. 入栈:创建新结点,将数据存入结点,结点指针指向原栈顶结点,头指针更新为新结点,实现元素入栈。

3. 出栈:记录栈顶元素,头指针移向次栈顶结点,释放原栈顶结点空间,返回栈顶元素,实现元素出栈。

4. 获取栈顶元素:返回头指针所指结点的数据。

5. 判断栈空:判断头指针是否为NULL。

五、编写主函数测试各种操作
可以编写主函数,实例化链栈,测试各种入栈、出栈操作,查看执行结果是否正确,从而完整实现链栈数据结构。

通过以上步骤,可以在代码中实现链栈这一重要的数据结构,并测试验证其功能的正确性。

这可以加深对链栈原理的理解,提高编程能力。

实现链栈的各种基本运算的算法实验总结

实现链栈的各种基本运算的算法实验总结示例文章篇一：哎呀，我一个小学生，哪懂什么“实现链栈的各种基本运算的算法实验总结”呀！这听起来可太难啦！不过，老师让做，那我就努力试试吧。

我们先来说说什么是链栈。

这就好像是一堆玩具，一个接一个地排好队。

前面的玩具可以被先拿走，后面的再跟上，是不是有点像排队买冰淇淋呀？在做这个实验的时候，我可费了不少劲儿呢！一会儿要创建这个链栈，一会儿又要往里面塞东西，还要能把东西拿出来。

这就好比我在搭积木，好不容易搭好了，又得小心翼翼地拆一部分，还不能让整个积木塔倒掉。

我记得最清楚的就是写那个入栈的算法啦。

我心里直犯嘀咕：“这可怎么弄呀？” 我就像一只迷路的小蚂蚁，到处乱撞。

后来我跟同桌小明讨论，我问他：“小明，你说这入栈到底是咋回事儿呀？”小明挠挠头说：“我也有点迷糊呢。

”我们俩你看看我，我看看你，愁眉苦脸的。

可是我们没放弃，继续琢磨。

最后终于搞明白了，那种开心劲儿，就像大热天吃了一大口冰淇淋！还有出栈的算法，也不简单。

我老是担心一不小心就出错了，心里七上八下的。

经过这么一番折腾，我算是明白了，做这个链栈的实验就像是走迷宫，得一步一步小心地走，一个不小心就会迷路。

但只要坚持，总能找到出口。

总的来说，这个链栈的实验虽然很难，但是让我学到了好多东西，也让我知道了遇到困难不能退缩，要勇敢地去面对，去解决。

我相信，以后再遇到这样的难题，我也能搞定！示例文章篇二：哎呀呀，这“实现链栈的各种基本运算的算法实验”对我这个小学生来说，可真是个超级难搞的大难题呢！一开始，老师跟我们说要做这个实验的时候，我整个人都懵啦！啥是链栈呀？我完全搞不清楚。

就好像让我去抓一只会飞的恐龙一样，根本不知道从哪儿下手！后来老师慢慢给我们讲解，我才稍微有点明白。

原来链栈就像是一个装东西的特别箱子，只不过这个箱子有它自己独特的规则。

做实验的时候，我和我的小伙伴们那叫一个手忙脚乱。

我们就像一群没头的苍蝇，到处乱撞。

链栈实验报告

数据结构实验报告姓名：方钢学号：20105567 专业：电子商务班级：10—1班指导教师：实验时间：实验地点：新区实验楼四楼（实验题目）链栈实验报告1.实验内容和要求1.1实验要求①本次实验中，链栈使用带头结点的单链表实现。

②链栈结构定义，算法实现全部放入库函数“linkStack.h”中；③各运算和变量命名直观易懂，并有相应的注释。

1.2实验内容<1>初始化一个链栈。

<2>判断是否空栈。

<3>入栈<4>取栈顶元素<5>出栈<6>将10进制数转换为16进制数2.实验目的①掌握栈的基本概念。

②掌握链栈的建立、入栈和出栈等方法。

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

3.数据结构设计3.1<1>初始化一个链栈。

<2>判断是否空栈。

<3>入栈<4>取栈顶元素<5>出栈算法：int main(int argc, char* argv[]){node* H, *L, *P,*q;int y;initialstack(L);//初始化if(stackEmpty(L))cout<<"空栈"<<endl;elsecout<<"栈不空"<<endl;cout<<"尾插法创建带头结点的单链表>>"<<endl;//以“9999”作为结束元素输入条件，用引用参数返回链表 pushstack( L );H=L->next;//H为头指针cout<<"入栈元素顺序为：";P=L->next;while(P){cout<<P->data<<",";P=P->next;}cout<<endl;popstack(H);L->next=H;cout<<"出栈后元素顺序为：";P=H;while(P){cout<<P->data<<",";P=P->next;}cout<<endl;if(stacktop(H,q)){y=q->data;cout<<"栈顶元素"<<y<<endl;}destroyList(L);return 0;}截图：3.2算法：int main(int argc, char* argv[]) {node *p,*L,*H;initialstack(L);int M,x;char a,b,c,d,e,f;cout<<"输入一个10进制数:";cin>>M;Tentosixteen(&M,L);H=L->next;cout<<"入栈元素顺序为：";p=L->next;while(p){cout<<p->data<<",";p=p->next;}cout<<endl;popstack(H);L->next=H;cout<<"输出一个16进制数:OX"; p=H;while(p){x=p->data;switch(x){case 97:cout<<"A";break;case 98:cout<<"B";break;case 99:cout<<"C";break;case 100:cout<<"D";break;case 101:cout<<"E";break;case 102:cout<<"F";break;default:cout<<x;}p=p->next;}cout<<endl;destroyList(L);return 0;}截图：4.总结和心得1>通过链栈的上机操作明白了代码在内存中的实现过程，理解了进制转换在内存中的实现方式;2>使用了switch—case来判断命名ABCDEF。

教育教学链栈顺序栈实验报告

链栈顺序栈实验报告1.实验目的本实验旨在通过对链栈和顺序栈两种数据结构的理解和实践操作，加深对栈的性质及其操作的理解，并比较两种栈的优缺点。

通过实际编程，培养解决实际问题的能力,同时体验数据结构在实际应用中的重要性。

2.实验原理链栈是一种用链表实现的栈，其中每个节点都包含一个数据域和两个指针，一个指向下一个节点，另一个指向上一个节点。

顺序栈则是一种用数组实现的栈，具有固定的容量。

两种栈都遵循后进先出(1IFO)的原则。

3.实验步骤(1)定义链栈和顺序栈的结构和操作方法。

(2)创建链栈和顺序栈的实例。

(3)对两种栈进行入栈、出栈等基本操作。

(4)比较两种栈的执行效率。

(5)分析并记录实验结果。

4.实验结果与分析实验结果显示，在大部分情况下，链栈的执行效率高于顺序栈。

这是因为在顺序栈中，元素的存取需要按照数组的索引进行，而链栈中元素的存取只需通过指针链接，因此链栈的操作更高效。

然而，顺序栈的空间利用率高于链栈，因为顺序栈只需预先分配固定容量的空间，而链栈则需要为每个节点分配额外的空间存储指针。

5.实验结论通过本实验，我们得出以下结论：链栈和顺序栈各有优缺点，应根据具体应用场景选择合适的数据结构。

在处理大量数据且内存空间有限的情况下，应优先考虑链栈；而在处理小规模数据且内存空间充足的情况下，顺序栈可能是一个更好的选择。

6.实验问题与改进在实验过程中，我们发现对于链栈来说，如果节点间的链接出现错误，可能会导致整个链表的错误。

因此，我们需要更加细心地处理链表中的链接问题。

此外，我们还需提高编程技巧和细心程度，避免在实验过程中出现错误。

7.实验体会与展望通过本次实验，我们更加深入地理解了栈的性质及其操作，并掌握了链栈和顺序栈的实现方法。

我们还了解了两种数据结构的优缺点以及在实际应用中的适用场景。

在未来的学习和工作中，我们将继续深入学习数据结构及其相关领域的知识，以提高我们的编程能力和解决问题的能力。

同时，我们也将努力将所学的知识和技能应用于实际问题的解决中，以实现学以致用的目标。

数据结构栈实验报告

一、实验目的本次实验旨在帮助学生掌握栈的基本概念、特点、逻辑结构以及抽象数据类型，熟练运用顺序栈和链栈进行基本操作，理解递归算法中栈的状态变化，并学会在计算机科学中应用栈解决实际问题。

二、实验内容1. 实现顺序栈和链栈的结构类型定义、特点以及基本操作的实现。

2. 编写算法判断给定字符序列是否为回文。

3. 设计算法，利用栈操作将指定栈中的内容进行逆转。

4. 实现求解整数数组最大值的递归算法。

5. 分析实验过程中遇到的问题及解决方法。

三、实验步骤1. 实现顺序栈和链栈（1）顺序栈顺序栈使用数组实现，具有以下特点：- 存储空间固定，栈的大小预先定义。

- 栈顶指针指示栈顶元素的位置。

- 入栈和出栈操作都在栈顶进行。

- 当栈满时，无法继续入栈。

- 当栈空时，无法继续出栈。

（2）链栈链栈使用链表实现，具有以下特点：- 栈的大小可变，不受存储空间限制。

- 栈顶指针指向栈顶元素的前一个节点。

- 入栈和出栈操作的时间复杂度为O(1)。

- 不存在栈满或栈空的情况。

2. 编写算法判断字符序列是否为回文（1）创建一个空栈。

（2）遍历字符序列，将每个字符依次入栈。

（3）遍历字符序列，将每个字符依次出栈，并判断出栈的字符是否与原序列中的字符相同。

（4）若所有字符均相同，则字符序列为回文；否则，不是回文。

3. 设计算法，利用栈操作将指定栈中的内容进行逆转（1）创建一个空栈。

（2）遍历原栈，将每个元素依次出栈，并判断栈是否为空。

（3）若栈不为空，则将出栈的元素依次入栈。

（4）当原栈为空时，将新栈中的元素依次出栈，实现栈内容的逆转。

4. 实现求解整数数组最大值的递归算法（1）定义一个递归函数，用于求解数组中最大值。

（2）在递归函数中，比较当前元素与左右子数组中的最大值。

（3）返回最大值。

5. 分析实验过程中遇到的问题及解决方法（1）问题：顺序栈在栈满时无法继续入栈。

解决方法：在入栈操作前，判断栈的大小是否已满。

若已满，则提示用户栈已满，无法继续入栈。

实验四链栈一、实验目的1、掌握用VC工具上机调试链栈的基本方法；2、掌握链栈的基本操作，链栈初始化、链栈入栈、链栈出栈、判断链栈是否为空、求队列长度以及链栈销毁操作；3、掌握栈在链式映像下的操作实现。

二、实验学时2学时三、实验类型验证型四、实验内容1、链栈的初始化、链栈入栈、链栈出栈、判断链栈是否为空、求链栈长度、链栈输出及链栈销毁操作的实现；2、通过设计统一界面来调用链栈的基本操作的实现。

五、实验原理1、链栈概述链栈是栈这一受限的线性表的链式映像实现。

为方便操作，链栈采用带头结点的单链表存储结构，若链栈为空则栈头结点指针域为空；若链栈非空则栈头结点指向链栈的第一个元素，操作是可将其赋值给工作指针进行相应的各种操作即可。

2、链栈基本算法(1)LinkStackInitiate(S)；初始化链栈S。

(2)LinkStackEmpty(S)；判断链栈S非空否操作。

(3)EnLinkStack (S,x)；链栈S入栈操作，在链栈S的栈顶插入数据元素x。

(4)DeLinkStack (S,d)；链栈S出栈操作，把链栈S的栈顶元素删除并由参数d带回。

(5)LenLinkStack (S)；求链栈S长度。

(6)DisLinkStack (S)；输出链栈S。

(7)DestroyLinkStack(S)；销毁链栈S。

3、模块层次要求画出链栈的模块层次图。

如图所示图7 链栈的模块层次图4、关键算法NS图六、实验步骤及要求用VC语言编程实现建立一个链栈，并在此链栈中入栈若干个元素和出栈若干个元素1.链栈初始化；2.通过键盘读取元素建立链栈S；3.判断此循环队列是否为空；4.输出此链栈；5.求此时链栈S长度；6.链栈S若干个元素入栈；7.求此时链栈S长度；8.输出此链栈S；9.链栈S出栈若干个元素；10.判断此链栈S是否为空；11.求此时链栈S长度；12.输出此链栈S；13.销毁此链栈S；14.程序完成。

七、界面要求1、界面统一。

实验四链式栈实验

实验四链式栈实验时间：2011年3月28日星期一地点：实验室一实验目的：理解链式栈的逻辑结构和存储结构，熟练掌握链式栈的相关操作。

1、问题描述问题描述同前面的顺序栈，这里是使用一个链表来表示一个栈。

使用带表头结点的链表，这样所有对栈的初始化和判断条件都需要作相应的更改。

2、数据结构设计链式栈的数据类型：typedef struct stackNode //链栈结点的类型定义{ ElemType data; //数据域struct stackNode *next; //指针域} StackNode;typedef struct //链栈的类型定义{StackNode *top;//栈顶指针} LinkStack;3、功能（函数）说明链式栈基本操作：StackInitial(LinkStack *pS) //创建一个由指针pS所指向的空链栈IsEmpty(LinkStack *pS) //链栈为空时返回，否则返回IsFull(LinkStack *pS) //栈为满时返回，否则返回Push(LinkStack *pS, ElemType e) //若栈不满，则元素e进栈Pop(LinkStack *pS) //若栈不为空，则删除栈顶元素，并返回它的值GetTop(LinkStack *pS) //若栈不为空，则返回栈顶元素的值MakeEmpty(LinkStack *pS) //将由指针pS所指向的栈变为空栈4、界面设计指导用户按照正确的格式输入数据。

5、编码实现#include <stdio.h>#include <iostream.h>typedef int ElemType;typedef struct stackNode //链栈结点的类型定义{ ElemType data; //数据域struct stackNode *next; //指针域} StackNode;typedef struct//链栈的类型定义{StackNode *top; // 栈顶指针} LinkStack;void StackInitial(LinkStack *pS)//指针pS所指向的链栈初始化为有表头结点链表{StackNode *p;p = new StackNode;if (p == NULL) //内存分配失败，退出{printf("内存分配失败!\n");return;}p -> next = NULL;//头结点指针域置空pS -> top = p;}int IsEmpty(LinkStack *pS)//链栈为空时返回1，否则返回0{return pS -> top -> next == NULL;}void Push(LinkStack *pS, ElemType e)//将元素e插入到栈顶{StackNode *p;p =new StackNode ;if (p == NULL) //内存分配失败{ printf("内存分配失败!\n");return;}p ->data =e;p ->next =pS ->top ->next;//栈顶插入pS ->top ->next = p;}ElemType Pop(LinkStack *pS)//若栈不为空，则删除栈顶元素，并返回它的值{ElemType temp;StackNode *p;if (IsEmpty(pS)) //栈为空，退出{ printf("空栈!\n");return 0;}p = pS -> top -> next;temp = p -> data;//保存栈顶结点数据pS -> top -> next = p -> next; //栈顶指针后移delete p; //释放结点return temp;}ElemType GetTop(LinkStack *pS)//若栈不为空，则返回栈顶元素的值{StackNode *p;if (IsEmpty(pS)) //栈为空，退出{ printf("空栈!\n");return 0;}p = pS -> top -> next;return p -> data;}void MakeEmpty(LinkStack *pS)//将链栈设置为空栈，仅保留头结点{StackNode *p, *q; //p为当前结点指针p = pS -> top -> next; //从第一个结点开始while (p != NULL) //当没有到达栈底时{ q = p; //暂存当前结点指针p = p -> next;//当前结点指针后移delete p;}pS -> top -> next = NULL;//头结点指针域置空}void Destroy(LinkStack *pS)//释放链栈所有结点的存储空间{StackNode *p, *q;p = pS -> top; //从第一个结点开始while (p != NULL){ q = p; //暂存当前结点指针p = p -> next; //当前结点指针后移delete p;}pS -> top = NULL; //栈顶指针置空}void output1(){int i;for(i=0;i<10;i++)printf(" ");for(i=0;i<32;i++)printf("*");printf("\n");}void mainpp(){int i;output1();for(i=0;i<10;i++) printf(" "); printf("* ");printf("1.元素进栈");for(i=0;i<16;i++) printf(" ");printf("*");printf("\n"); for(i=0;i<10;i++) printf(" "); printf("* ");printf("2.元素出栈");for(i=0;i<16;i++) printf(" ");printf("*");printf("\n"); for(i=0;i<10;i++) printf(" "); printf("* ");printf("3.读栈顶元素");for(i=0;i<14;i++) printf(" ");printf("*");printf("\n"); for(i=0;i<10;i++) printf(" "); printf("* ");printf("4.栈置空");for(i=0;i<18;i++) printf(" ");printf("*");printf("\n"); for(i=0;i<10;i++) printf(" "); printf("* ");printf("0.退出");for(i=0;i<8;i++) printf(" ");printf("*");printf("\n"); output1();}void main() //主函数{int k=1,m,x;LinkStack *HS;StackNode *pS;ElemType e;HS=new LinkStack;pS=new StackNode;StackInitial(HS);mainpp();while (k){printf("请选择0--4 : "); scanf("%d",&m);//getchar();switch (m){case 0: return;case 1: {printf("输入元素,入栈: ");scanf("%d",&e);Push(HS,e);break;}case 2: {e=Pop(HS);printf("%d\n",e);printf("\n");break;}case 3: {printf("取出栈顶元素: ");x=GetTop(HS);printf("%d\n",x);break;}case 4: {printf("栈置空: \n");MakeEmpty(HS);printf("\n");break;}default: return;}printf("继续运行吗Y(1)/N(0): "); scanf("%d",&k);if(!k) return;}}6、运行测试输入相关数据，建立链表，以链表作为栈，测试各功能函数。

链栈的算法实现

《数据结构》课程实验、实习、课程设计报告专业: 班级:级学号30 姓名: 成绩:报告所属类别：实验□实习□课程设计□实验（实习、课程设计）序号：题目：链栈的算法实现实验（实习、课程设计）时间、地点：实验目的、要求：在链栈中入栈1,2,3,4,5. 出栈5,4. 输出3,2,1。

实验题目的解决方案：（1）建立链栈并入栈；（2）出栈两个元素；（3）输出剩余。

实验所涉及的流程图、结构图、源程序及结果：/* Note:Your choice is C IDE */#include"stdio.h"#include"malloc.h"typedef struct node{int data;struct node *next;}NODE;NODE *crea_linkstack(){NODE *top,*p;int n,a;top=NULL;printf("\ninput number of push linkstack: ");scanf("%d",&n);if(n>0){printf("\ninput %d elements of linkstack: ",n);while(n>0){scanf("%d",&a);p=(NODE *)malloc(sizeof(NODE));p->next=top;p->data=a;top=p;n--;}}return (top);}NODE *popstack(NODE *top){NODE *p;int x=2;if(top != NULL){while(x>0){printf("%3d",top->data);p=top;top=top->next;x--;free(p);}}return(top);}void print(NODE *top){NODE *p;p=top;if(p != NULL){printf("\noutput the linkstack: ");while(p != NULL)实习、课程设计评语：{printf("%3d",p->data);p=p ->next;}}elseprintf("the linkstack is empty.\n");}void main(){NODE *a;a=crea_linkstack();printf("\npop two elements: ");a=popstack(a);print(a);}实验（实习、课程设计）中出现的问题及解决办法：实验（实习、课程设计）体会：。

链栈实验

北京信息科技大学数据结构实验二链栈,循环队列和计算器的操纵

栈的实验报告结论(3篇)

栈的获取实验报告(3篇)

链式栈设计实验报告

C语言数据结构----链栈实验报告

链栈顺序栈实验报告

栈的链式存储结构的表示和实现实验报告

栈的基本操作实验报告

链栈的实现实验心得

西南科技大学数据结构实验报告栈的基本操作

实验七 链栈

链栈顺序栈实验报告

链栈的实现实验内容原理

实现链栈的各种基本运算的算法实验总结

链栈实验报告

教育教学 链栈顺序栈实验报告

数据结构栈实验报告

链栈实验

实验四链式栈实验

链栈的算法实现

实验七链栈

教育教学链栈顺序栈实验报告