栈和队列（c语言数据结构实验报告二）

于 2020-06-27 09:02:46 发布
阅读量3.9k 收藏 59
点赞数 17
CC 4.0 BY-SA版权
文章标签： 队列 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46052798/article/details/106978362
本文提供了一个关于栈和队列的数据结构实验代码，包括栈的顺序存储与链式存储，以及队列的顺序存储与链式存储的实现。通过主函数中的菜单，可以调试这些算法，帮助理解栈和队列的基本操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

实验项目中文名称：栈与队列
实验项目英文名称：Stack and queue
实验教学的内容或要求
1.编写函数,采用链式存储实现栈的初始化、入栈、出栈操作
2.编写函数,采用顺序存储实现栈的初始化、入栈、出栈操作
3.编写函数,采用链式存储实现队列的初始化、入队、出队操作
4.编写函数,采用顺序存储实现队列的初始化、入队、出队操作
5.编写一个主函数,在主函数中设计一个简单的菜单,分别调试上述算法

#include<stdio.h>
#include<windows.h>
#pragma warning(disable:4996)
//1.栈的顺序结构
#define Stack_Size 50
typedef struct{
 int elem[Stack_Size];
 int top;
}SeqStack;
//a.初始化
void InitStack1(SeqStack *S){   
 S->top = -1;
 memset(S->elem, 0, sizeof(S->elem));
}
//b.进栈
int Push1(SeqStack *S, int x)  
{
 if (S->top == Stack_Size - 1){   //栈满
  return -1;
 }
 else{
  S->top++;
  S->elem[S->top] = x;
  return 1;
 }
 return 0;
}
//c.出栈
int Pop1(SeqStack *S, int *x){   
/*将栈S的栈顶元素弹出，放到x所指向的存储空间中*/
 if (S->top == -1){     
  return -1;
 }
 else{
  *x = S->elem[S->top];
  S->top--;     //修改栈顶指针
  return *x;
 }
 return 0;
}
//d.取栈顶元素
int GetTop1(SeqStack *S, int *x){ 
/*将栈S的栈顶元素弹出，放到x所指向的存储空间中，但是栈顶指针保持不变*/
 if (S->top == -1){
  return -1;
 }
 else{
  *x = S->elem[S->top];
  return 1;
 }
 return 0;
}
//2.栈的链式结构
typedef struct node{
 int data;
 struct node *next;
}LinkStackNode, *LinkStack;
//a.初始化
void InitStack2(LinkStack top){
 top->next = NULL;
 top->data = 0;
}
//b.进栈
int Push2(LinkStackNode *top, int x)
/* 将数据元素 x 压入栈 top 中 */
{
 LinkStackNode * temp;
 temp = (LinkStackNode *)malloc(sizeof(LinkStackNode));
 if (temp == NULL){
  return -1;   /* 申请空间失败 */
 }
 else{
  temp->data = x;
  temp->next = top->next;
  top->next = temp;   /* 修改当前栈顶指针 */
  return 1;
 }
 return 0;
}
//c.出栈
int Pop2(LinkStack top, int *x) {  
 /* 将栈 top 的栈顶元素弹出，放到 x 所指的存储空间中 */ 
 LinkStackNode * temp; 
 temp = top->next; 
 if (temp == NULL){  /*栈为空*/
  return -1;
 }
 else{
  top->next = temp->next;
  *x = temp->data; free(temp);   /* 释放存储空间 */
  return *x;
 }
 return 0;
}
//3.队列的顺序存储
#define MAXSIZE 50  /*队列的最大长度*/ 
typedef struct {
 int  element[MAXSIZE];  /* 队列的元素空间*/
 int  front;  /*头指针指示器*/
 int  rear;  /*尾指针指示器*/
}SeqQueue;
//a.初始化
void InitQueue1(SeqQueue *Q){  /* 将*Q 初始化为一个空的循环队列 */
 Q->front = Q->rear = 0;
}
//b.入队
int EnterQueue1(SeqQueue *Q, int x)
{  /*将元素 x 入队*/
 if ((Q->rear + 1) % MAXSIZE == Q->front){  /*队列已经满了*/
  return -1;
 }
 else{
  Q->element[Q->rear] = x;
  Q->rear = (Q->rear + 1) % MAXSIZE;  /* 重新设置队尾指针 */
  return 1;
 }  /*操作成功*/
 return 0;
}
//c.出队
int DeleteQueue1(SeqQueue *Q, int *x)
{ /*删除队列的队头元素，用 x 返回其值*/
 if (Q->front == Q->rear){  /*队列为空*/
  return -1;
 }
 else{
  *x = Q->element[Q->front];
  Q->front = (Q->front + 1) % MAXSIZE;  /*重新设置队头指针*/
  return *x;  /*操作成功*/
 }
 return 0;
}
//4.队列的链式存储
typedef struct Node
{
 int data;//数据域
 struct Node *next;//指针域
}LinkQueueNode;
typedef struct
{
 LinkQueueNode *front;//队头指针front
 LinkQueueNode *rear;//队头指针rear
}LinkQueue;
//a.初始化
int InitQueue2(LinkQueue *Q)
{
 Q->front = (LinkQueueNode *)malloc(sizeof(LinkQueueNode));
 if (Q->front != NULL)
 {
  Q->rear = Q->front;
  Q->front->next = NULL;
  return 1;
 }
 else
 {
  return -1;//溢出
 }
 return 0;
}
//b.入队
int EnterQueue2(LinkQueue *Q,int x)
{
 LinkQueueNode *NewNode;
 NewNode = (LinkQueueNode *)malloc(sizeof(LinkQueueNode));
 if (NewNode != NULL)
 {
   NewNode->data = x;
   NewNode->next = NULL;
   Q->rear->next = NewNode;
   Q->rear = NewNode;
  return 1;
 }
 else
 {
  return -1;//溢出
 }
 return 0;
}
//c.出队
int DeleteQueue2(LinkQueue *Q,int *x)
{
 LinkQueueNode *p;
 if (Q->front == Q->rear)
 {
  return -1;
 }
 else{
  p = Q->front->next;
  Q->front->next = p->next;//队头元素p出队
  if (Q->rear == p)//如果队中只有一个元素p,则p出队后成为空队
  {
   Q->rear = Q->front;
  }
  *x = p->data;
  free(p);//释放存储空间
  return *x;
 }
 return 0;
}
void menu1(){
 printf("##############################\n");
 printf("###########栈与队列###########\n");
 printf("########1.栈的顺序存储########\n");
 printf("########2.栈的链式存储########\n");
 printf("######3.队列的顺序存储########\n");
 printf("######4.队列的链式存储########\n");
 printf("############5.退出############\n");
 printf("please enter your choice#");
}
void menu2()
{
 printf("#########################\n");
 printf("#########相关操作########\n");
 printf("##########1.入队#########\n");
 printf("##########2.出队#########\n");
 printf("##########3.退出#########\n");
 printf("#########################\n");
 printf("please enter your choice#");
}
void menu3(){
 printf("#########################\n");
 printf("#########相关操作########\n");
 printf("##########1.入栈#########\n");
 printf("##########2.出栈#########\n");
 printf("##########3.退出#########\n");
 printf("#########################\n");
 printf("please enter your choice#");
}
int main()
{
 int data;                       //输入数据
 int data1;                      //输出数据
 LinkQueue st1;                  //队列链式存储的结构体变量
 SeqQueue st2;                   //队列顺序存储的结构体变量
 LinkStackNode st3;              //栈的链式存储的结构体变量
 SeqStack st4;                   //栈的顺序存储的结构体变量
 int i = 1;
 int j = 1;
 while (i){
  menu1();
  int choice1 = 0;
  int choice2 = 0;
  scanf("%d", &choice1);
  switch (choice1){
  case 1:
   j = 1;
   InitStack1(&st4);
   while (j){
    menu3();
    scanf("%d", &choice2);
    switch (choice2){
    case 1:
     printf("请输入整型，0表示输入结束\n");
     printf("please enter your data: ");
     scanf("%d", &data);
     while (data != 0){
      Push1(&st4, data);
      scanf("%d", &data);
     }
     break;
    case 2:
     printf("Linked Storage outgoing queue is: ");
     while (st4.top!=-1){
      printf("%d", Pop1(&st4, &data1));
     }
     printf("\n");
     break;
    case 3:
     j = 0;
     break;
    default:
     printf("输入错误，请重新输入!\n");
     break;
    }
   }
   break;
  case 2:
   j = 1;
   InitStack2(&st3);
   while (j){
    menu3();
    scanf("%d", &choice2);
    switch (choice2){
    case 1:
     printf("请输入整型，0表示输入结束\n");
     printf("please enter your data: ");
     scanf("%d", &data);
     while (data != 0){
      Push2(&st3, data);
      scanf("%d", &data);
     }
     break;
    case 2:
     printf("Linked Storage outgoing queue is: ");
     while (st3.next!=NULL){
      printf("%d", Pop2(&st3, &data1));
     }
     printf("\n");
     break;
    case 3:
     j = 0;
     break;
    default:
     printf("输入错误，请重新输入!\n");
     break;
    }
   }
   break;
  case 3:
   j = 1;
   InitQueue1(&st2);
   while (j){
    menu2();
    scanf("%d", &choice2);
    switch (choice2){
    case 1:
     printf("请输入整型，0表示输入结束\n");
     printf("please enter your data: ");
     scanf("%d", &data);
     while (data != 0){
      EnterQueue1(&st2, data);
      scanf("%d", &data);
     }
     break;
    case 2:
     printf("Linked Storage outgoing queue is: ");
     while (st2.rear!=st2.front){
      printf("%d", DeleteQueue1(&st2, &data1));
     }
     printf("\n");
     break;
    case 3:
     j = 0;
     break;
    default:
     printf("输入错误，请重新输入!\n");
     break;
    }
   }
    break;
  case 4:
   j = 1;
   InitQueue2(&st1);
   while (j){
    menu2();
    scanf("%d", &choice2);
    switch (choice2){
    case 1:
     printf("请输入整型，0表示输入结束\n");
     printf("please enter your data: ");
     scanf("%d", &data);
     while (data != 0){
      EnterQueue2(&st1, data);
      scanf("%d", &data);
     }
     break;
    case 2:
     printf("Linked Storage outgoing queue is: ");
     while (st1.rear != st1.front){
      printf("%d", DeleteQueue2(&st1, &data1));
     }
     printf("\n");
     break;
    case 3:
     j = 0;
     break;
    default:
     printf("输入错误，请重新输入!\n");
     break;
    }
   }
   break;
  case 5:
   i = 0;
   break;
  default:
   printf("输入错误，请重新输入!\n");
   break;
   }
  }
 system("pause");
 return 0;
 }

关于队列以及栈的相关操作在相关书籍上都会有，这里去模拟栈与队列，是让更多的人去理解栈和队列。
本次实验代码仅供参考（因为在菜单的美观性以及代码本身的效率方面有待提高），所以大家在采纳的过程中可以去在不同方面优化。

评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值