栈和队列的基本操作

最新推荐文章于 2022-06-16 16:26:06 发布
原创 最新推荐文章于 2022-06-16 16:26:06 发布 · 7.6k 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#存储 #struct #null #算法 #测试

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

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

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

（4）采用顺序存储实现循环队列的初始化、入队、出队操作。

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

///
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define TRUE   1
#define FALSE  0
#define ERROR 0
#define OVERFLOW -2
#define STACK_INIT_SIZE 100
#define STACKINCREMENT  20

////////////////////采用链式存储实现栈的初始化、入栈、出栈操作

typedef struct stacklist{
 int data;
 struct stacklist *next;
}stacklist,*linkstack;

linkstack top,head;

linkstack create()
{
 linkstack p;
 p=(linkstack)malloc(sizeof(stacklist));
 p->next=NULL;
 return p;
}

void bulidstack()
{
 linkstack p,q;
 int data;
 p=top;
 printf("请输入进栈的元素:");
 scanf("%d",&data);
 q=create();
 q->data=data;
 q->next=p->next;
 top->next=q;
}

void outstack()//出栈
{ 
 linkstack p;
    p=top->next;
 if(p!=NULL)
 {
  printf("%d 出栈\n",p->data);
  top->next=p->next;
  free(p);
 }
 else
  printf("栈为空\n");
}

void tip1()
{
 printf("**********\n");
 printf("*1 进栈  *\n");
 printf("*2 出栈  *\n");
 printf("*0 退出  *\n");
 printf("*请选择：*\n");
 printf("**********\n");
}

//////////


///////////////////////下面为采用顺序存储实现栈的初始化、入栈、出栈操作

typedef struct Stack{//顺序栈
    int  *base;
    int  *top;
    int    stacksize;      //栈可使用的最大容量
} SqStack;

int  InitStack (SqStack &S){ //0栈的初始化
    S.base=(int *)malloc (STACK_INIT_SIZE *sizeof(int));
    if (! S.base)  exit (OVERFLOW);
    S.top=S.base; 
    S.stacksize=STACK_INIT_SIZE;//栈的空间大小
    return 1;
}

int Push(SqStack &S, int e){//1入栈
    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 1;
}

int Pop(SqStack &S){//2出栈
 int e;
    if( S.top==S.base)
 {
  printf("栈为空\n");
  return ERROR;//空栈
 }
    e=*--S.top;
    return e;//返回栈顶元素
}

void Print(SqStack &S){//输出
 
    if( S.top==S.base)
 {
  printf("栈为空\n");
  return ;//空栈
 }
 while(S.top>S.base)
 {
  printf("%d  ",*S.base);
  S.base++;
 }
 printf("\n");
 return ;
 
}


void tip2()
{
 printf("*********计科101陈东东*************\n");
 printf("*输入1进栈                        *\n");
 printf("*输入2出栈                        *\n");
 printf("*输入0退出                        *\n");
 printf("***********************************\n");
}

//////////////////////////////
////////////////////采用链式存储实现队列的初始化、入队、出队操作

typedef struct QNode{//创建队成员
 int  data;//数据成员
 struct QNode *next;
}QNode,*QueuePtr;

typedef struct{//队头队尾指针
 QueuePtr  front;
 QueuePtr  rear;
}LinkQueue;

void InitQueue(LinkQueue &Q)//初始化队列
{ 
 Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));//开辟空间
 if(!Q.front) exit ( OVERFLOW);//开辟失败则退出
 Q.front ->next = NULL;
 //return 1;
}

int EnQueue(LinkQueue &Q)//入队操作
{ 
 int e;
 QueuePtr p;
 printf("请输入入队元素:");
 scanf("%d",&e);
 p=(QueuePtr)malloc(sizeof(QNode));
 if (p==NULL) exit (OVERFLOW);
 p->data = e;  p->next = NULL;
 Q.rear->next=p;//把p插入队尾
 Q.rear=p;//把p变为队尾
 return 1;
}

int DeQueue(LinkQueue &Q)//出队操作
{
 QueuePtr p;
 int e;
 if ( Q.front == Q.rear){
  printf("队列为空\n");
  return -1;
 }
 p=Q.front->next;//头指针为空
 e=p->data;
 printf("%d  出对\n",e);
 Q.front->next =p->next;//指针后移
 if (Q.rear == p) Q.rear = Q.front;//如果p为队尾
 free(p);//释放p
 return 1;
}

void tip3()
{ 
 printf("*************\n");
 printf("*输入1 进队 *\n");
 printf("*输入2 出对 *\n");
 printf("*输入0 退出 *\n");
 printf("*请选择:    *\n");
 printf("*************\n");
}


/////////////////

//////////////////////下面为循环队列

#define MAXQSIZE 100  /*队列的最大长度*/
typedef struct {
    int *base;   // 队列的元素空间头指针指示器
    int  front;                 
    int  rear;   /*尾指针指示器*/
}SqQueue;       

int InitQueue(SqQueue &Q) {//初始化操作
 Q.base = (int * )malloc(MAXQSIZE*sizeof(int));
 if (!Q. base) exit (OVERFLOW); 
 Q.front=Q.rear =0;
 return 1;
}

int EnQueue(SqQueue &Q) {//入队操作
 int e;
 if ((Q. rear+ 1) % MAXQSIZE == Q. front)
 {
  printf("队列已满,不能进队\n");
  return -1;//满标志
 }
 printf("请输入进队元素:");
 scanf("%d",&e);
 Q.base[Q.rear] = e;//进队
 Q.rear = (Q. rear + 1) % MAXQSIZE;//队尾指针后移
 return 1;
}

int DeQueue (SqQueue &Q) {//出队操作
 int e;
 if (Q. front == Q. rear) {
  printf("队列已经为空\n");
  return -1;
 }
 e = Q. base[Q. front];//队头出队
 printf("%d  出队\n",e);
 Q.front = (Q.front + 1) % MAXQSIZE;//队头下标后移
 return 1;
}

void tip4()
{ 
 printf("*************\n");
 printf("*输入1 进队 *\n");
 printf("*输入2 出对 *\n");
 printf("*输入0 退出 *\n");
 printf("*请选择:    *\n");
 printf("*************\n");
}


//////////////////
void tip0()
{
 printf("**********计科101陈东东******************************\n");
 printf("*Case=1,采用链式存储实现栈的初始化、入栈、出栈操作  *\n");
 printf("*Case=2,采用顺序存储实现栈的初始化、入栈、出栈操作  *\n");
 printf("*Case=3,采用链式存储实现队列的初始化、入队、出队操作*\n");
 printf("*Case=4,采用链式存储实现队列的初始化、入队、出队操作*\n");
 printf("*Case=0,退出                                        *\n");
 printf("*请输入Case:                                        *\n");
 printf("*****************************************************\n");

}
int main()
{
 int Case;
 tip0();
 while(scanf("%d",&Case),Case)
 {
  int k;
  if(Case==1)//采用链式存储实现栈的初始化、入栈、出栈操作
  {
   top=create();
   
   tip1();
   while(scanf("%d",&k),k)
   {
    switch(k)
    {
    case 1:
     bulidstack();
     printf("操作完成\n");
     tip1();
     break;
    case 2:
     outstack();
     printf("操作完成\n");
     tip1();
     break;
    }
   }
   
  }
  else if(Case==2)//下面为采用顺序存储实现栈的初始化、入栈、出栈操作
  { 
   int x;
   SqStack S;
   //struct Stack S;
   tip2();
   InitStack(S);
   while(scanf("%d",&k),k)
   {
    switch(k)
    {
    case 1:
     printf("请输入进栈元素：");
     scanf("%d",&x);
     Push(S, x);
     printf("操作完毕\n");
     tip2();
     break;
    case 2:
     
     printf("%d 出栈\n",Pop(S));
     printf("操作完毕\n");
     tip2();
     break;
    }
   } 
   
  }
        else if(Case==3)//采用链式存储实现队列的初始化、入队、出队操作
  { 
   LinkQueue Q;
   InitQueue(Q);//初始化队列
   tip3();
   while(scanf("%d",&k),k)
   {
    switch(k)
    {
    case 1:
     EnQueue(Q);
     tip3();
     printf("操作完毕\n");
     break;
    case 2:
     DeQueue(Q);
     tip3();
     printf("操作完毕\n");
     break;
    }
    
   }
   
  }
  else if(Case==4)//采用链式存储实现队列的初始化、入队、出队操作
  {
   SqQueue Q;
   InitQueue(Q);//初始化
   tip4();
   while(scanf("%d",&k),k)
   {
    switch(k)
    {
    case 1:
     EnQueue(Q);
     tip4();
     printf("操作完毕\n");
     break;
    case 2:
     DeQueue(Q);
     tip4();
     printf("操作完毕\n");
     break;
    }
   }
   
  }
  tip0();
 }
 return 0;
}

实验二 栈和队列基本操作的实现
陈的博客
12-06 1922
实验二 栈和队列基本操作的实现 实验目的 1.掌握栈、队列的思想及其存储实现 2.掌握栈、队列基本操作的实现 实验内容 1.编写函数，采用链式存储实现栈的初始化、入栈、出栈操作。 2.编写函数，采用顺序存储实现栈的初始化、入栈、出栈操作。 3.编写函数，采用链式存储实现队列的初始化、入队、出队操作。 4.编写函数，采用顺序存储实现队列的初始化、入队、出队操作。 5.编写一个主函数，在主函数中设计一个简单的菜单，分别调用上述函数。 #include<cstdio> #include<c
栈和队列基本操作及练习
08-05
栈和队列基本操作及练习
栈的基本操作
热门推荐
Guo_guo
05-11 1万+
#include "stdafx.h" #include #include #define OK 1 #define TRUE 1 #define ERROR 0 #define FALSE 0 #define overflow -2 #define STACK_INTT_SIZE 100 #define STACK_INIT_INCREMENT 20 #define Status int #de
栈与队列基本操作
m0_60777643的博客
01-30 4101
一.栈 1.顺序栈操作： 注：栈是一种只在头部进行操作的数据结构，不需要用到中间插入和删除，因此一般日常生活中用顺序表的形式来表示栈，操作可能会更方便。 ① 顺序栈的创建（初始化）： ...
实验二栈和队列基本操作.doc
10-08
实验二栈和队列基本操作 栈的基本操作 栈是一种线性表，遵循“先进后出”的原则，即最后进入栈的元素最先被删除。栈的基本操作包括入栈、出栈、取栈顶元素、遍历栈和清空栈等。 栈的顺序存储构造 栈的顺序存储...
武汉理工数据结构实验2栈和队列基本操作和应用[归类].pdf
10-28
武汉理工数据结构实验2栈和队列基本操作和应用 本实验旨在让学生熟练掌握顺序栈和队列的基本操作，并学习它们的应用。实验内容包括顺序栈和队列的基本操作演示程序的设计与实现，以及顺序栈和队列在不同进制之间的...
栈，队列的基本操作
06-08
栈，队列的基本操作以及运用队列实现看病挂号的小系统（C语言）
C_栈..
PepDokHa的博客
01-20 756
C语言—数据结构 实现栈
栈与队列的操作
奈川直子
10-27 1465
一、操作要求 1．关于栈的要求 （1）建立一个数据元素值为一个字符的带头结点的单链表，并输出单链表中字符序列, 观察输入的内容与输出的内容是否一致。 （2）借助一个栈判断上述已知单链表中字符序列是否为回文，如果是，则输出“此链表中的字符序列构成回文”，否则输出“此链表中的字符序列不构成回文”。 2．关于队列的要求 （1）根据输入的队列长度n和各元素值建立一个带头结点的循环链表表示的队列（循环链队列），并且只设一个尾指针来指向尾结点，然后输出队列中各元素值。 （2）将数据元素e入队，并输出入队后的
栈和队列的操作
YTLDSS的博客
06-16 311
实验目的： （1）掌握栈的顺序存储结构、链式存储结构及其基本操作 （2）掌握队列的顺序存储结构、链式存储结构及其基本操作。 实验内容： （1）编程实现栈的以下基本操作：建栈，取栈顶元素，入栈，出栈。 （2）编程实现队列的以下基本操作：建队列，取队头元素，入队，出队。 实验代码： #include<iostream> using namespace std; #define MAXSIZE 100 typedef struct//顺序栈 { int *base; int *top;
栈和队列基本操作
weixin_55859275的博客
10-12 987
栈和队列的基本操作 （1）顺序栈 （2）链栈 （3）链队列 以下代码仅仅作为参考 世上没有完美的代码，只有更好的代码。从健壮性的角度考虑以下代码可能在特殊情况下会出现错误，所以仅仅作为参考思路。 （1）顺序栈 #include<iostream> using namespace std; typedef int ElementType; #define MAXSIZE 100 typedef struct node { ElementType Data[MAXSIZE]; .
栈和队列基本操作代码c++
最新发布
01-02
### C++ 中栈和队列的基本操作代码示例 #### 栈的基本操作 在C++中，`std::stack` 提供了一系列用于管理栈内元素的方法。下面是一个简单的程序展示如何创建并操作一个栈： ```cpp #include <iostream> #include <stack> using namespace std; int main() { stack<int> stk; // 元素压入栈 stk.push(1); stk.push(2); stk.push(3); cout << "栈顶元素：" << stk.top() << endl; // 输出栈顶元素 // 移除栈顶元素 stk.pop(); cout << "移除后的栈顶元素：" << stk.top() << endl; // 获取栈的大小 cout << "当前栈的大小：" << stk.size() << endl; // 判断栈是否为空 if (!stk.empty()) { cout << "栈不是空的" << endl; } else { cout << "栈是空的" << endl; } return 0; } ``` 这段代码展示了向栈中添加新项(`push`)、访问顶部项目而不删除它(`top`)、弹出最上面的一项(`pop`)以及查询栈的状态（如其尺寸或是否为空）等功能[^1]。 #### 队列的基本操作 对于队列而言，在C++中有 `std::queue` 可以利用。这里有一个例子说明怎样初始化队列并对之实施常见的动作： ```cpp #include <iostream> #include <queue> using namespace std; int main(){ queue<string> q; // 插入到队尾 q.push("hello"); q.push("world"); // 访问队首元素 cout << "队首元素为：" << q.front() << endl; // 删除队首元素 q.pop(); // 查看新的队首元素 cout << "现在的队首元素为：" << q.front() << endl; // 检查队列是否为空 if(q.empty()){ cout << "队列已清空"; } else{ cout << "\n剩余元素数量:" << q.size(); } return 0; } ``` 此段代码演示了往队列里加入成员(`push`)、获取最先放入的那个成员而不会将其移走(`front`)、实际取出最早进入者(`pop`)还有检验队伍长度或是确认是否有任何待处理条目存在等行为[^2]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值