(全网最细）顺序栈详解＋实例解析

<阿睿>

已于 2022-05-30 15:19:01 修改

阅读量3.4k

点赞数 12

分类专栏：数据结构和算法文章标签：数据结构链表 c语言

于 2022-05-27 21:51:33 首次发布

本文链接：https://blog.csdn.net/qq_45288176/article/details/125010881

版权

数据结构和算法专栏收录该内容

10 篇文章 2 订阅

订阅专栏

一：栈的介绍

1：什么是栈（Stack）？

栈是一种常用的、重要的数据结构
栈是一种限定插入和删除只能在表的 "端点”进行的线性表，此端点就在队尾

如图：只能在队尾进行插入或删除

2：栈的特点

后进先出LIFO

类比：洗碗盘子子弹弹夹子弹出列

图示：栈就好比一个这样的特殊容器

心中有图撸码自然神

3：栈的相关概念

1：基本概念

1：表示

”表尾(即an端)称为栈顶Top;表头(即a端)称为栈底Base

例如:栈s=(a1, a2, ....... an-1, an)
a1称为栈底元素
an称为栈顶元素
2.逻辑结构
与同线性表相同，仍为一一对应关系。
3.存储结构
用顺序栈和链栈存储均可，但以顺序栈更常见
4.运算规则
只能在栈顶运算，且访问结点时依照后进先出(LIFO) 的原则。
5.实现方式
关键是编写入栈和出栈函数，具体实现依顺序栈或链栈的不同而不同。

2：基本操作和图示(如图为顺序栈实例)

插入元素到栈顶(即表尾)的操作，称为入栈。一般表示为压入：PUSH (x)

从栈顶(即表尾)删除最后一个元素的操作，称为出栈。 一般表示为弹出：POP（X)

补：如图：栈顶指针先指向最后一个元素（a3），再实现出栈操作 概括为：e=*--S.top

4：栈的应用

■数制转换                    ■行编辑程序
■函数调用                    ■迷宫求解
■递归调用的实             ■表达式求值
■括号匹配的检验         ■八皇后问题

三：栈的表示和操作实现

1：栈的抽象数据结构类型的定义

补：解释图中数据关系：ai-1是ai的前驱，ai是ai-1的后继 |类比子弹入弹 ai-1先进入 ai后进入

2：主要函数介绍

Status InitStack(SqStack &S) 初始化栈
Status GetTopStack(SqStack S, ElemType &e) 获取栈顶元素，参数e存放栈顶元素的值
Status PushStack(SqStack &S, ElemType e) 进栈，将元素e入栈
Status PopStack(SqStack &S, ElemType &e) 出栈，出栈的元素存放在参数e中
Status EmptyStack(SqStack S) 判断栈是否为空
Status LengthStack(SqStack S) 获取栈的实际长度
Status DestroyStack(SqStack &S) 销毁栈
Status StackTraverse(SqStack S) 遍历栈，打印每个元素

3.1 (重要)顺序栈的表示和操作

1：了解顺序栈

补：top指针指向栈顶元素an的上一位的下标位置

stacksize:栈的最大容量

2：特殊标志：栈空和栈满

空栈：可以添加新元素，并且无法出栈（下溢）

栈满（上溢）：无法添加新元素

解决：1报错 2:开辟新空间

3：栈的数据类型定义和操作

1 顺序栈的表示

#define stack_INIT_SIZE     100

typedef struct {
       SElemType *base;   //栈底指针
       SElemType *top;     //栈顶指针
       int stacksize;       //栈空间栈可用最大空间
}Sqstack;

理解：

2 顺序栈的初始化

Status iniStack(Sqstack &S){
    S.base = (SElemType*)malloc(stack_INIT_SIZE*sizeof(SElemType));

    //S.base =new SElemType[stack_INIT_SIZE];
if(!S.base) exit(OVERFLOW);
    S.top =S.base;
    S.stacksize=stack_INIT_SIZE;
}

如图：初始化要点 1：栈空 top=base 2：top base 指针指向第一个元素 3：stacksize的赋值

补：判断栈是否为空（如上图）

//判栈空
bool Empty(SqStack S){
    if(S.top == -1){
        return true;
    }else{
        return false;
    }
}

3 栈的长度

int StackLength( SqStack S){

return S.top - S.base;

}

4 清空栈

Status ClearStack(SqStack S) {

if(S.base) S.top=S.base;

return OK;

}

5 销毁顺序栈

Status DestroyStack(SqStack &S){

        if(S.base){

                delete S.base;

                S.stacksize = 0;

                S.top=S.base =NULL;

        }

        return OK;

}

销毁顺序栈：3步结构体内部3个变量的值并释放两个指针空间的地址

6：顺序栈入栈

顺序栈入栈的步骤

1：是否栈满（上溢），是不能添加新元素 => 2：元素e压入栈顶 => 3：指针+1

Status push(Sqstack &S,SElemType e){
    if(S.base-S.top==stacksize)
        return ERROR;
    *S.top++=e;
    return OK;
}

7 顺序栈的出栈

顺序栈出栈的步骤

1：是否栈空（下溢）=> 2：栈顶指针-1 => 3：取栈顶元素e值

Status pop(Sqstack &S,SElemType &e){
    if(S.base==S.top)//等价 if(StackEmpty(S))
        return ERROR;
    e=*--S.top;
    return OK;
}

四：栈的算法利用

1：实现R进制转换

本题要求实现十进制转R（R<10 && R>0）进制。

#include <stdio.h>
#include <malloc.h>
typedef int Status;
typedef int SElemType;
#define stack_INIT_SIZE     100
#define stackINCREMENT 10
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef struct {
       SElemType *base;   //栈底指针
       SElemType *top;     //栈顶指针
       int stacksize;       //栈空间
}Sqstack;
Sqstack S;
Status iniStack(Sqstack &S);
Status push(Sqstack &S,SElemType x);
Status pop(Sqstack &S,SElemType &e);
void conversion(int n,int R);
int main()
{
    int N,R;
    scanf("%d",&N); //输入十进制数
    scanf("%d",&R); //输入要转换的进制
    if(R<0||R>=10) //判断R是否合法
    {
        printf("illegal input");
        return ERROR;
    }
    //printf("开始");
    conversion(N,R); //进制转换
    return OK;
}

/* 请在这里填写答案 */

Status iniStack(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;
}
Status push(Sqstack &S,SElemType x){
    if(S.base-S.top==stack_INIT_SIZE)
        return ERROR;
    *S.top++=x;
    return OK;
}
Status pop(Sqstack &S,SElemType &e){
    if(S.base==S.top)
        return ERROR;
    e=*--S.top;
    return OK;
}
bool StackEmpty(Sqstack &S)
{
   if (S.top == S.base) return false;
   return true;
}
void conversion(int n,int R){
   int e;Sqstack S;
   iniStack(S);
//   printf("开始");
    //printf("%d",n);
    while(n>=R){
        push(S,n%R);
        n/=R;
        //printf("%d",n);
    }
    push(S,n);
   // printf("push结束");
    while(S.base!=S.top){
        pop(S,e);
        printf("%d",e);
    }
}

2：实现后缀表达式（逆波兰式）

在一行中输入一个以回车结束的非空后缀表达式，回车不属于表达式的一部分，操作数和运算符都以空格分隔，运算数为不超过100的正整数，运算符仅有+、-、*、/ 四种，题目保证输入的是合法的后缀表达式形式。

#include <stdio.h>
#include <malloc.h>
#include <iostream>
using namespace std;
typedef int Status;
typedef int SElemType;
#define stack_INIT_SIZE     3000000
#define stackINCREMENT 10
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef struct {
      long long int *base;   //栈底指针
      long long int *top;     //栈顶指针
       int stacksize;       //栈空间
}Sqstack;
Sqstack S;
Status iniStack(Sqstack &S){
    S.base = (long long int*)malloc(stack_INIT_SIZE*sizeof(long long int));
//   if(!S.base) exit(OVERFLOW);
    S.top =S.base;
    S.stacksize=stack_INIT_SIZE;
}
Status push(Sqstack &S,long long int x){
    if(S.base-S.top==stack_INIT_SIZE)
        return ERROR;
    *S.top++=x;
    return OK;
}
Status pop(Sqstack &S,long long int &e){
    if(S.base==S.top)
        return ERROR;
    e=*--S.top;
    return OK;
}
bool StackEmpty(Sqstack &S)
{
   if (S.top == S.base) return false;
   return true;
}
void conversion(int n,int R){
   long long int e;Sqstack S;
   iniStack(S);
//   printf("开始");
    //printf("%d",n);
    while(n>=R){
        push(S,n%R);
        n/=R;
        //printf("%d",n);
    }
    push(S,n);
   // printf("push结束");
    while(S.base!=S.top){
        pop(S,e);
        printf("%d",e);
    }
}

int A(char* str)
{
    int i = 0;
    Sqstack Numbers;
    iniStack(Numbers);
    SElemType number_to_push;
   long long int num1, num2;
    while (str[i] != '\0') {
        if (str[i] != ' ') {
            if (str[i] >= '0' && str[i] <= '9') {
                number_to_push = 0;
                while (str[i] != ' ' && str[i]) {
                    number_to_push = number_to_push * 10 + (str[i] - '0');
                    i++;
                }
                push(Numbers, number_to_push);
            } else {
                pop(Numbers, num2);
                pop(Numbers, num1);
                switch (str[i]) {
                case '+': {
                    num1 += num2;
                    break;
                }
                case '-': {
                    num1 -= num2;
                    break;
                }
                case '*': {
                    num1 *= num2;
                    num1=num1%1000000007;
                    break;
                }
                case '/': {
                    num1 /= num2;
                    break;
                }
                case '%': {
                    num1 %= num2;
                    break;
                }
                }
                push(Numbers, num1%1000000007);
            }
        }
        i++;
    }
    pop(Numbers, num1);
    return num1;
}
int main(){
        Sqstack S;
        iniStack(S);
        int num1;
        char num[300000];
//       scanf("%s",&num);
       gets(num);
       //cin.getline(num,300000);
       printf("%s",num);
        num1=A(num);
        printf("%d",num1);
}

<阿睿>

关注

12
点赞
踩
48

收藏

觉得还不错? 一键收藏
0
评论
(全网最细）顺序栈详解＋实例解析

目录一：栈的介绍1：什么是栈（Stack）？2：栈的特点3：栈的相关概念1：基本概念2：基本操作和图示(如图为顺序栈实例)4：栈的应用三：栈的表示和操作实现1：栈的抽象数据结构类型的定义2：主要函数介绍3.1顺序栈的表示和操作1：了解顺序栈2：特殊标志：栈空和栈满3：栈的数据类型定义和操作一：栈的介绍1：什么是栈（Stack）？栈是一种常用的、重要的数据结构栈是一种限定插入和删除只能在表的 "端点”进行的线性表，此端点就在队.
复制链接

扫一扫