【数据结构】第三章 栈和队列

最新推荐文章于 2021-09-01 13:46:02 发布
最新推荐文章于 2021-09-01 13:46:02 发布
阅读量233 收藏 3
点赞数
分类专栏： 数据结构 文章标签： 数据结构 队列 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43923155/article/details/103842330
版权

1.栈的定义和特点

1.栈和队列是特殊的线性表。

2.栈是先进后出的线性表，

  • 表示：typedef struct{Type *base;Type *top; int stacksize;}SqStack
  • 其中base始终指向栈底，top随元素的添加一直指向栈顶。
  • 可以有顺序实现和链表实现。

3.栈的应用举例:

  • 数制转换
  • 括号匹配
  • 行编辑器帮助处理错误输入
  • 迷宫求解
  • 表达式求解 -
  • 实现递归

2.队列的定义和特点

队列是先进先出的线性表。可以由链表实现和顺序实现。

3.思维导图

在这里插入图片描述

4.实验报告

（1） 编程实现顺序栈的基本操作，并应用栈的基本操作，实现：
c) 四则运算表达式（中缀或后缀）的求值。（选做）
（a）进制转换

com_def.h

#include <stdio.h> 
#include <iostream>
#include <iomanip>
#include <string.h>
#include <malloc.h>
#include <process.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -1
typedef int Status;

stack_def.h

#define STACK_INIT_SIZE 100//存储空间的初始分配量
#define STACKINCREMENT 10//存储空间的分配增量
typedef int SElemType;
typedef struct{
 SElemType *base;
 SElemType *top;
 int stacksize;
}SqStack;

stack_func.h

Status InitStack(SqStack &S){
 S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));
 if(!S.base) exit(OVERFLOW);
 S.top=S.base;
 S.stacksize=STACK_INIT_SIZE;
 return OK;
}
Status StackEmpty(SqStack &S){
 return(S.base==S.top); 
}
int StackLength(SqStack S){
 return(S.top-S.base);
}
Status GetTop(SqStack S,SElemType &e){
 //若栈不空，则用e返回S的栈顶元素 
 if(S.top==S.base) return ERROR;
 e=*(S.top-1);
 return OK;
}
Status Push(SqStack &S,SElemType e){
 //插入元素e为新的栈顶元素 
 if(S.top-S.base>=S.stacksize){
  //若栈满，追加存储空间
  SElemType *newbase=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
  if(!newbase) exit(OVERFLOW);
  S.top=newbase+S.stacksize;
  S.stacksize+=STACKINCREMENT; 
 }
 *S.top++=e;//*S.top=e;S.top++;
 return OK;
}
Status Pop(SqStack &S,SElemType &e){
 if(S.top==S.base) return ERROR;
 e=*(--S.top);//--S.top;e=*S.top;
 return OK;
}
//Status DestoryStack(SqStack &S){ 
//}
void Conversion_Integer(int N,int R){
 //对于输入的任意一个非负十进制整数，打印输出与其等值的N进制数 
 int e=0;
 SqStack S;
 InitStack(S);
 while(N){
  Push(S,N%R);
  N=N/R;
 }
 while(!StackEmpty(S)){  
  Pop(S,e);
  if(e>=0&&e<=9)
  printf("%d",e);
  else
  printf("%c",e-10+'A');
 }
}
void Conversion_Decimal(float B,int R)
{
 int e;
 while(B>0.0001){
  B=B*R;
  e=(int)B;
  B=B-e;
  if(e>=0&&e<=9)
   printf("%d",e);
  else
   printf("%c",e-10+'A');
 }
}

#include "com_def.h"
#include "stack_def.h"
#include "stack_func.h"
using namespace std;
int main() {   
 float N=0;
 int R=0;
 cout<<"请输入需要转换的数值："<<endl;
 cin>>N;
 cout<<"请输入需要转换成几进制："<<endl;
 cin>>R;
 int A=0;//整数部分
 float B=0;//小数部分
 A=(int)N;
 B=N-A;
    //如果整数部分不为零，进行转换，否则输出0
 if(A>0)
 {
  Conversion_Integer(A,R);//转换整数部分，并且输出
 } 
 else
 {
  printf("0");
 } 
 printf(".");//输出小数点
    //如果小数部分部委为零，进行转换，否则输出0
 if(B>0.00001){
  Conversion_Decimal(B,R);//转换小数部分，并且输出
 }
 else
 {
  cout<<"0";
 }
 cout<<endl;
}

（b) 表达式的语法检查（括号的匹配）

com_def.h 同上

stack_def.h

#define STACK_INIT_SIZE 100//存储空间的初始分配量
#define STACKINCREMENT 10//存储空间的分配增量
typedef char SElemType;
typedef struct{
 SElemType *base;//栈底指针 
 SElemType *top;//栈顶指针 
 int stacksize;
 int length;
}SqStack;

stack_func.h

Status InitStack(SqStack &S){
 S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));
 if(!S.base) exit(OVERFLOW);
 S.top = S.base;
 S.stacksize = STACK_INIT_SIZE;
 return OK;
}//初始化空栈 
Status CreateStack(SqStack &S){
 cout<<"请输入栈中元素个数："<<endl;
 int n = 0;
 cin>>n;
 S.length = n;
 int i; 
 cout<<"请输入数据："<<endl;
 for(i = 0;i < S.length;i++){
  cin>>S.base[i];
  S.top++;
 }
 return OK;
}//建立栈 
void OutputStack(SqStack S){
 cout<<"栈为：";
 for(int i = 0;i < S.length;i++){
  cout<<S.base[i]<<" ";
 }
 cout<<endl;
}//输出栈 
void DestoryStack(SqStack S){
 free(S.base);
 S.base = NULL;
 S.top = NULL;
 S.stacksize = 0;
}//销毁栈 
Status StackEmpty(SqStack S){
 if(S.base == S.top) return TRUE;
 else return FALSE;
}//栈判空 
Status GetTop(SqStack S,SElemType &e){
 if(StackEmpty(S) == TRUE) return ERROR;
 e = *(S.top-1); 
 return OK;
}//取栈顶元素 
Status Push(SqStack &S,SElemType e){
 if(S.top - S.base >= S.stacksize){
  S.base = (SElemType *)realloc(S.base,(S.stacksize + STACKINCREMENT) * sizeof(SElemType));
  if(!S.base) exit(OVERFLOW);
  
  S.top = S.base + S.stacksize;
  S.stacksize = S.stacksize + STACKINCREMENT;
 }
 *S.top++ = e;
 S.length++;
 return OK;
}//插入新栈顶元素 
Status Pop(SqStack &S,SElemType &e){
 if(StackEmpty(S) == TRUE) return ERROR;
 e = * --S.top;
 S.length--;
 return OK;
}//删除栈顶元素 
Status StackLength(SqStack S,SElemType &e){ 
 e = S.length;
 return OK;
}//求栈的长度 

main.cpp

#include "com_def.h"
#include "stack_def.h"
#include "stack_func.h"
using namespace std;
int main() {
 SqStack S;
    SElemType e;
    char ch[100];
    char *p;
    if(InitStack(S))
    {
     printf("请输入表达式\n");
     gets(ch);
        p = ch;    
        while (*p)
            switch(*p){
         case '(':
            case '[':Push(S,*p++);
                     break;
            case ')':
            case ']':
    if(!StackEmpty(S)){
                    Pop(S,e);
                    if(*p == ')' && e != '(' || *p == '[' && e != ']'){
                        printf("左右括号不配对");
                        exit(OVERFLOW);
                    }else{
                        p++;
                        break;
                    }
                }else{
                    printf("缺乏左括号！\n");
                    exit(ERROR);
                }
            default : p++;
         }
     if(StackEmpty(S))
         printf("左右括号匹配！\n");
     else
      printf("缺少右括号！\n");
 }
 return 0; 
}

（2） 编程实现队列（链队列或循环队列）的基本操作，并应用栈和队列实现回文序列的判定。

com_def.h 如上

queue_def.h

typedef int QElemType;
typedef struct QNode{
 QElemType data;
 struct QNode  *next;
}QNode,*QueuePtr;
typedef struct
{
 QueuePtr front;
 QueuePtr rear;
}LinkQueue;//队列 

queue_func.h

using namespace std;
Status InitQueue(LinkQueue &Q){
 //建立空队列 
 Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
 if(!Q.front) exit(OVERFLOW) ;//存储空间分配失败
 Q.front->next = NULL;
 return OK;
}
Status QueueEmpty(LinkQueue &Q){
 //判断队列是否为空 
 if(Q.front==Q.rear){
  return OK;
 }else{
  return FALSE;
 }
}
Status CreateQueue(LinkQueue &Q){
 int n; 
 cout<<"请输入队列元素个数："<<endl;
 cin>>n;
 QueuePtr p;
 p = (QueuePtr)malloc(sizeof(QNode));
 if(!p) exit(OVERFLOW);
 for(int i=0;i<n;i++){
  scanf("%d",p->data);
  p=p->next;
 }
 p->next = NULL;
 Q.rear->next = p;
 Q.rear = p;
 return OK;
}
Status EnQueue(LinkQueue &Q,QElemType e){
 //插入队尾元素
 QueuePtr p;
 p = (QueuePtr)malloc(sizeof(QNode));
 if(!p) exit(OVERFLOW);
 p->data = e;
 p->next = NULL;
 Q.rear->next = p;
 Q.rear = p;
 return OK;
}
Status DeQueue(LinkQueue &Q,QElemType &e){
 //删除队头元素
 QueuePtr p;
 if(QueueEmpty(Q)) return ERROR;
 p = Q.front->next;
 e = p->data;
 Q.front->next = p->next;
 if(Q.rear == p)
 Q.rear = Q.front;
 free(p);
 return OK;
}
void OutputQueue(LinkQueue &Q){
 //输出队列
 QueuePtr p;
 p = Q.front->next;
 while(p!=NULL){
  printf("%d ",p->data);
  p = p->next;
 }
} 
Status DestroyQueue(LinkQueue Q){
 //销毁队列 
 while(Q.front){
  Q.rear = Q.front->next;
  free(Q.front);
  Q.front = Q.rear; 
 }
 return OK;
}

main

#include "com_def.h"
#include "queue_def.h"
#include "queue_func.h"
using namespace std;
int main() {
 LinkQueue Q; 
 QElemType e;
 int option;
 do{
  cout<<"————————————"<<endl;
  cout<<"* 请输入对队列的操作   *" <<endl;
  cout<<"* 1:建立空队列         *"<<endl;
  cout<<"* 2:插入队尾元素       *"<<endl;  
  cout<<"* 3:删除队头元素       *"<<endl; 
  cout<<"* 0:销毁队列并退出程序 *"<<endl; 
  cout<<"————————————"<<endl;
  cin>>option;  
  switch(option){
   case 1:
    if(InitQueue(Q)==OK){
     cout<<"初始化空队列成功！"<<endl;
    }else{
     cout<<"初始化失败！"<<endl;
    } 
    break; 
   case 2:
    cout<<"请输入想要插入的元素："<<endl;
    cin>>e; 
    if(EnQueue(Q,e)==OK){
     cout<<"插入成功！"<<endl;
     OutputQueue(Q);
     cout<<endl;
    }else{
     cout<<"插入失败！"<<endl;
    }
    break; 
   case 3:
    if(DeQueue(Q,e)==OK){
     cout<<"删除成功！被删除的元素是："<<endl;
     cout<<e<<endl;
     OutputQueue(Q);
     cout<<endl;
    }else{
     cout<<"删除失败！"<<endl;
    }
    break; 
  }
 }while(option);
 DestroyQueue(Q);
 return 0;
}
Meranchine.
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构第三章 栈和队列
马骏
06-30 645
一、栈（先进后出） 限定头的一种线性表 （是一种逻辑结构）、只能在一端操作——插入或删除。 存储结构： （1）顺序栈： （默认top所指位置为当前元素位置） 初始化 S.top = -1 （栈空） 栈顶元素是 S.data[S.top] （top指向栈顶元素） 进栈（push） 先移动top，后传值：S.data[++S.top] = x; 出栈（pop） 先取值，后移动top：x = S.data[S.top–]; 共享栈满条件 top2 - top1 = 1 时 （2）链式栈：通常用
数据结构基础系列(3)：栈和队列
09-08
数据结构课程是计算机类专业的专业基础课程，在IT人才培养中，起着重要的作用。课程按照大学计算机类专业课程大纲的要求，安排教学内容，满足需要系统学习数据结构的人。系列课程包含11个部分，本课为第3部分栈和队列，介绍在系统软件和应用软件开发中大有用途的两种特殊线性表——栈和队列的构组成、存储结构的选择，以及基本运算的实现，通过相关的应用案例介绍了这些数据结构的应用方法。
数据结构第三章栈与队列
06-11
内容经典高度概括，知识点全面集中。考试冲刺时用效果挺好的。
数据结构第三章栈和队列
05-17
栈的概念，栈的基本操作；， 2 栈的两类存储结构和它们的类型定义； 3 在栈的存储结构下，栈的基本操作的算法； 4 栈在程序设计中的应用；
数据结构第三章栈和队列3.1-3.2
11-23
3.1_1栈的基本概念.mp4将介绍栈的基本概念，3.1_2栈的顺序存储实现.mp4和3.1_3栈的链式存储实现.mp4则会分别讲解栈的两种常见实现方式——顺序存储和链式存储，它们各有优劣，适用于不同的情况。 接下来，我们转向...
数据结构第三章栈和队列3.3-3.4
最新发布
11-23
在本章中，我们将深入探讨两种基本的数据结构：栈和队列，它们在3.3至3.4部分扮演着关键角色。 首先，栈是一种后进先出（LIFO，Last In First Out）的数据结构，就像现实生活中的堆叠物品一样，最后放进去的物品...
数据结构第三章栈和队列.pdf
11-12
"数据结构第三章栈和队列" 本章节主要介绍了栈和队列这两种基本数据结构的概念、实现和应用。 一、栈的基本概念 栈是一种后进先出（Last In First Out，LIFO）的数据结构，仅允许在栈顶插入或删除元素。栈的基本...
数据结构第三章栈和队列3习题.pdf
07-29
数据结构第三章栈和队列习题 在本节中，我们将讨论栈和队列这两种基本数据结构，通过习题来深入了解它们的实现和应用。 1. 栈的实现 栈是一种后进先出（LIFO）的数据结构，栈顶元素是最新添加的元素。栈的实现...
数据结构 第3章 栈和队列.ppt
06-17
数据结构-栈和队列 栈是一种特殊的线性表，它限定仅在表尾进行插入和删除操作。栈的顶端称为栈顶，栈的底端称为栈底。栈的特点是后进先出（LIFO）或先进后出（FILO）。 栈的抽象数据类型定义（ADT）： ADT Stack...
JAVA数据结构和算法：第三章（栈和队列）
春水上行的博客
08-25 1000
栈栈是限制仅在一个位置上进行插入和删除的线性表。允许插入和删除的一端为末端，称为栈顶。另一端称为栈底。不含任何数据元素的栈称为空栈。栈又成为后进先出(LIFO)表，后进入的元素最先出来。 首先，栈是一个线性表，元素之间具有线性关系，即前驱后继关系，其次，它是一种特殊的线性表，只能在表尾进行插入和删除操作。栈的插入操作，叫作进栈（push），删除操作，叫作出栈(pop). 由于栈是一个线性表，所以我们
常用数据结构之Stack(栈)
gaobing1993的博客
09-24 565
1.理论介绍 上一篇中我们介绍了数据结构中的堆，常言道堆栈不分家，我们继续来聊聊栈这种数据结构吧。栈从本质上来讲是一种有着特殊要求的线性表，感兴趣的可以了解一下之前讲的数据结构中的线性表。既然是线性表那么其就有两种形式，一种是线性存储(像数组一样是一块连续的内存空间)，另外一种是链式存储(像链表一样是一段非连续的空间)； 栈的特殊要求就是LIFO(Last In First Out)，对，后进先出。只有栈顶的元素允许访问。还记得上一篇讲的堆吗？从本质上来讲堆也是只有顶部的...
数据结构 第三章 栈和队列
qq_48009872的博客
09-01 120
数据结构-stack的基本操作
weixin_33720452的博客
04-20 1055
包括三个文件：stack.h，stack.cpp,main.cppstack.h#include"stdio.h" #include<stdlib.h> #include<malloc.h> #include<string.h> #defineStatusint #defineSElemTypeint #defineST...
算法与数据结构复习 第三章 栈与队列（详解）
热门推荐
好学者的博客
12-02 1万+
文章目录第三章 栈与队列书面作业一、判断题二、单选题三、程序填空四、函数题 第三章 栈与队列 书面作业 一、判断题 1、在对不带头结点的链队列作出队操作时，不会改变头指针的值。 (F) 2、循环队列执行出队操作时会引起大量元素的移动。 (F) 3、不论是入队列操作还是入栈操作,在顺序存储结构上都需要考虑"溢出"情况。 (T) 4、“Circular Queue” is defined to be ...
数据结构 第三章栈和队列 思维导图
melody9494的专栏
12-29 2041
数据结构 第三章栈和队列 思维导图
数据结构经典题目
qq_43923155的博客
01-05 7628
目录
掌握数据结构第三章：栈与队列详解
本资源主要介绍了数据结构中的第三章内容——栈。栈是一种特殊的线性数据结构，其特点是只能在表的一端进行插入（进栈）和删除（出栈）操作，具有明确的栈顶和栈底，栈顶作为唯一可进行操作的端点。栈的基本概念包括...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值