三、栈

最新推荐文章于 2022-07-29 15:32:11 发布
最新推荐文章于 2022-07-29 15:32:11 发布
阅读量137 收藏
点赞数
分类专栏： 数据结构_C语言描述
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lsssssssssssy/article/details/104933891
版权

目录

栈

  • 限定仅在表尾进行插入和删除操作的线性表
  • 对于某个出栈的元素，在它之前进栈却晚出栈的元素必定按逆序出栈
  • LIFO

ADT

ADT 栈(stack)
Data
    同线性表。元素具有相同的类型，相邻元素具有前驱和后堆关系。
Operation
    InitStack ( *S )：初始化操作.建立一个空栈S。
    DestroyStack ( *S )：若栈存在，則销毁它。
    ClearStack (*S)：将栈清空。
    StackEmpty ( S ):若栈为空，返回true,否則返回 false。
    GetTop (S,*e)：若栈存在且非空，用e返回S的栈顶元素。
    Push (*S,e)：若栈S存在，插入新元素e到栈S中并成为栈頂元素。
    Pop (*S,*e)：删除栈S中栈顶元素，并用e返回其值。
    StackLength (S)：返回回栈S的元素个数。
endADT

顺序栈

  • top变量表示栈顶元素在数组中的位置
  • 栈有一个元素： top == 0
  • 空栈： top == -1
  • 满栈： top == MAXSIZE - 1

存储结构

typedef int SElemType    // 假设为int
typedef struct
{
	SElemType data[MAXSIZE];
	int top;             // 用于栈顶指针
}SqStack;

Push

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status;

/* 将e进栈 */ 
Status Push(SqStack *s, SElemType e)     // 传入结构指针、待插入元素e
{
	if(S->top == MAXSIZE - 1)    // 栈满
	{
		return ERROR;
	}
	S->top++;
	S->data[S->top]=e;
	return OK;
}

POP

Status Pop(SqStack *S, SElemType *e)
{
	if(S->top == 1){             // 空栈
		return ERROR;
	}
	*e = S->data[S->top];
	S->top--;
	return OK;
}

共享栈

  • 从数组两端向中间靠拢
  • 栈1空：top1 == -1
  • 栈2空：top2 == n
  • 栈满：top1 + 1 == top2
  • 应用背景：两个栈空间需求有相反关系 且 数据类型要相同

存储结构

typedef struct{
	SElemType data[MAXSIZE];
	int top1;
	int top2;
}SqDoubleStack;

Push

Status Push(SqDoubleStack *s, SElemType e, int stackNumber){
	if(S->top1+1 == S->top2){            // 栈满
		return ERROR;
	}
	if(stackNumber == 1){                // 入栈1
		S->data[++S->top1]=e;            // 先top+1
	}else if(stackNumber == 2){          // 入栈2
		S->data[--S->top2]=e;
	}
	return OK;

Pop

Status Pop(SqDoubleStack *S, SElemType *e, int stackNumber){
	if(stackNumber == 1){
		if(S->top1 == -1){                 // 栈1空
			return ERROR;
		}
		*e=S->data[S->top1--];             // 后top-1
	}
	else if(stackNumber == 2){
		if(S->top2 == MAXSIZE){            // 栈2空
			return ERROR;
		}
		*e=S->data[S->top2++];             // 后top-1
	}
	return OK;
}

链栈

  • 不带头结点的单链表
  • 栈顶在头部
  • 内存够用则不存在栈满的情况
  • 空栈：top == NULL
  • 内存开销大，如果栈大小变化显著，用链栈，否则用顺序栈

存储结构

teypedef struct StackNode  
{
	SElemType data;	             // 存放栈的数据
	struct StackNode *next;
} StackNode, *LinkStackPtr;      // 同时声明一个结构指针

teypedef struct LinkStack   
{
	LinkStackPrt top;	         // top指针
	int count;		             // 栈元素计数器
}LinkStack;

Push

/* 元素值为e的新结点是s，插入e */
Status Push(LinkStack *S, SElemType e)
{
	LinkStackPtr s = (LinkStackPtr) malloc (sizeof(StackNode));
	s->data = e;
	s->next = S->top;     // 把当前的栈顶元素赋值给新结点的直接后继
	S->top = s;
	S->count++;
	return OK;
}

Pop

/* 删除S的栈顶元素，用e返回其值 ，，释放p */
Status Pop(LinkStack *S, SElemType *e)
{
	LinkStackPtr p;           // p存储待删除栈顶结点
	if( StackEmpty(*S) )      // 判断是否为空栈
		return ERROR;
	*e = S->top->data;
	p = S->top;
	S->top = S->top->next;    // 将栈顶指针下移
	free(p);
	S->count--;
	return OK;
}

栈的应用

递归

  • 【递归函数】：调用自己的函数
  • 必须要有出口

斐波那契数列

/* 打印前40个斐波那契数列 */
int Fbi(int i){
	if( i<2 )
		return i == 0 ? 0 : 1;
	return Fbi(i-1)+Fbi(i-2);
}
int main(){
	int i;
	fot( int i=0; i<40; i++){
		print("%d ", Fbi(i));
	}
	return 0;
}

四则运算表达式求值

逆波兰计算器

#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>

#define STACK_INIT_SIZE 20
#define STACKINCREMENT  10
#define MAXBUFFER       10

typedef double ElemType;
typedef struct
{
    ElemType *base;
    ElemType *top;
    int stackSize;
}sqStack;

void InitStack(sqStack *s)
{
    s->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
    if( !s->base )
        exit(0);

    s->top = s->base;
    s->stackSize = STACK_INIT_SIZE;
}

void Push(sqStack *s, ElemType e)
{
    // 栈满，追加空间
    if( s->top - s->base >= s->stackSize )
    {
        s->base = (ElemType *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));
        if( !s->base )
            exit(0);

        s->top = s->base + s->stackSize;
        s->stackSize = s->stackSize + STACKINCREMENT;
    }

    *(s->top) = e;      // 存放数据
    s->top++;
}

void Pop(sqStack *s, ElemType *e)
{
    if( s->top == s->base )
        return;

    *e = *--(s->top);   // 将栈顶元素弹出并修改栈顶指针
}

int StackLen(sqStack s)
{
    return (s.top - s.base);
}

int main()
{
    sqStack s;
    char c;
    double d, e;
    char str[MAXBUFFER];
    int i = 0;

    InitStack( &s );

    printf("请按逆波兰表达式输入待计算数据，数据与运算符之间用空格隔开，以#作为结束标志: \n");
    scanf("%c", &c);

    while( c != '#' )
    {
        while( isdigit(c) || c=='.' )  // 用于过滤数字
        {
            str[i++] = c;
            str[i] = '\0';
            if( i >= 10 )
            {
                printf("出错：输入的单个数据过大！\n");
                return -1;
            }
            scanf("%c", &c);
            if( c == ' ' )
            {
                d = atof(str);
                Push(&s, d);
                i = 0;
                break;
            }
        }

        switch( c )
        {
            case '+':
                Pop(&s, &e);
                Pop(&s, &d);
                Push(&s, d+e);
                break;
            case '-':
                Pop(&s, &e);
                Pop(&s, &d);
                Push(&s, d-e);
                break;
            case '*':
                Pop(&s, &e);
                Pop(&s, &d);
                Push(&s, d*e);
                break;
            case '/':
                Pop(&s, &e);
                Pop(&s, &d);
                if( e != 0 )
                {
                    Push(&s, d/e);
                }
                else
                {
                    printf("\n出错：除数为零！\n");
                    return -1;
                }
                break;
        }

        scanf("%c", &c);
    }

    Pop(&s, &d);
    printf("\n最终的计算结果为：%f\n", d);

    return 0;
}

中缀转后缀（逆波兰）表示法

  • 【逆波兰RPN】：不需要括号的后缀表示方法
#include <stdio.h>
#include <stdlib.h>

#define STACK_INIT_SIZE 20
#define STACKINCREMENT  10

typedef char ElemType;
typedef struct
{
    ElemType *base;
    ElemType *top;
    int stackSize;
}sqStack;

void InitStack(sqStack *s)
{
    s->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
    if( !s->base )
        exit(0);

    s->top = s->base;
    s->stackSize = STACK_INIT_SIZE;
}

void Push(sqStack *s, ElemType e)
{
    // 栈满，追加空间
    if( s->top - s->base >= s->stackSize )
    {
        s->base = (ElemType *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));
        if( !s->base )
            exit(0);

        s->top = s->base + s->stackSize;
        s->stackSize = s->stackSize + STACKINCREMENT;
    }

    *(s->top) = e;      // 存放数据
    s->top++;
}

void Pop(sqStack *s, ElemType *e)
{
    if( s->top == s->base )
        return;

    *e = *--(s->top);   // 将栈顶元素弹出并修改栈顶指针
}

int StackLen(sqStack s)
{
    return (s.top - s.base);
}

int main()
{
    sqStack s;
    char c, e;

    InitStack( &s );

    printf("请输入中缀表达式，以#作为结束标志：");
    scanf("%c", &c);

    while( c != '#' )
    {
        while( c>='0' && c<='9' )
        {
            printf("%c", c);
            scanf("%c", &c);
            if( c<'0' || c>'9' )
            {
                printf(" ");
            }
        }

        if( ')' == c )
        {
            Pop(&s, &e);
            while( '(' != e )
            {
                printf("%c ", e);
                Pop(&s, &e);
            }
        }
        else if( '+'==c || '-'==c )
        {
            if( !StackLen(s) )
            {
                Push(&s, c);
            }
            else
            {
                do
                {
                    Pop(&s, &e);
                    if( '(' == e )
                    {
                        Push(&s, e);
                    }
                    else
                    {
                        printf("%c ", e);
                    }
                }while( StackLen(s) && '('!=e );
                Push(&s, c);
            }
        }
        else if( '*'==c || '/'==c || '('==c )
        {
            Push(&s, c);
        }
        else if( '#'== c )
        {
            break;
        }
        else
        {
            printf("\n出错：输入格式错误！\n");
            return -1;
        }

        scanf("%c", &c);
    }

    while( StackLen(s) )
    {
        Pop(&s, &e);
        printf("%c ", e);
    }

    return 0;
}
lssssssssy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法之栈
weixin_33860737的博客
06-27 89
2019独角兽企业重金招聘Python工程师标准>>> ...
顺序栈的入栈与出栈-----（c语言）
sdmdnf的博客
05-02 8528
/栈底//栈顶//分配栈的值}Sqstack;//定义栈此处定义栈的最大值为10，当然如果需要后续分配更大的内存空间，可以使用realloc函数增加新的空间（作者还没学会使用）。
王道3.1 顺序栈以及链式栈
沉晨尘宸的博客
07-29 1328
4.采用链式存储的栈称为链栈，链栈便于多个栈共享存储空间和提高其效率，且不存在栈满上溢的情况。通常采用单链表实现，并且所有操作都是在单链表的表头进行的。在本文中主要是介绍了顺序栈下的一些基本操作，关于链栈的实现与单链表类似，5.n个不同元素进栈，出栈元素不同排列个数为，例如，五个元素就有=42种。②栈底bottom固定的，不允许进行插入和删除的另一端。6.栈的基本操作初始化、判空、出栈、进栈、读栈、销毁栈。由于初始设置S.top=-1，故栈顶指针先加一，再入栈。3.栈只能对栈顶进行操作。...
《数据结构》—— 顺序栈、链栈、共享栈的基础知识
博樽
09-15 1247
栈的逻辑基础与代码。
栈的顺序链式及共享栈的实现
m0_49218627的博客
06-01 1057
1.栈的定义注意栈是个操作受限的线性表栈又被称为后进先出的线性表，简称为LIOF（last in first out）其特殊之处在于限制了这个线性表的插入和删除位置，他始终只在当前栈顶进行操作。数学性质： 个不同的元素进栈，出栈元素的不同排列的个数为 。上述公式也是灰常经典的 ，可采用的数学归纳法去证明。个人感觉顺序栈这块出题也就在卡特兰数出了其他没啥难度基本操作同时栈这个逻辑结构还分为了顺序栈，共享栈和链栈三种实现方式栈的ADT定义： 顺序栈的清空： 顺序栈的销毁： 顺序栈的初始化： 顺序栈的判满操作：
数据结构实验三栈和队列的应用.docx
11-12
【标题】: 数据结构实验三栈和队列的应用 【描述】: 该文档是关于数据结构中栈和队列应用的一个实验指导，旨在帮助学习者深入理解这两种基础数据结构的特性和操作。 【标签】: 互联网 【知识点】: 1. **栈**: -...
实验三栈和队列.cpp
11-30
实验三栈和队列.cpp
实验三 栈和队列的应用.pdf
11-10
【栈和队列的基本概念】 栈（Stack）是一种后进先出（Last In First Out, LIFO）的数据结构，常用于处理临时存储和快速访问的需求。它的主要操作包括入栈（Push）、出栈（Pop）、查看栈顶元素（Get Top）和判断栈...
实验三 栈和队列的应用.docx
11-10
【栈和队列的基础知识】 栈和队列是两种常用的数据结构，在计算机科学和编程中具有广泛的应用。栈（Stack）被称为后进先出（LIFO, Last In First Out）结构，而队列（Queue）则遵循先进先出（FIFO, First In First ...
顺序表示的栈——顺序栈3——共享栈
凌空的桨
11-21 2219
在使用顺序栈时，定义空间过大，可能造成有些栈空闲，空间并没有有效利用。为了使栈的空间能充分利用，可以让多个栈共享一个足够大的连续存储空间，通过移动栈顶指针，从而使多个栈空间互相补充，存储空间得到有效利用，这就是共享栈的设计思想。   最常见的是两个栈的共享。栈的共享原理是利用栈低固定，栈顶迎面增长的方式。可通过两个栈共享一个一维数组实现，两个栈的栈低设置在数组的两端，当有元素进栈时，栈顶位置从栈...
【C++】栈和队列
cout0
12-01 722
顺序栈 #include <iostream> #include <stdlib.h> using namespace std; #define MAXSIZE 100 //顺序栈初始化时分配的存储空间长度 typedef struct{ char *base; //栈底指针,栈中元素为字符 char *top; //栈顶指针 int stacksi...
栈和队列都是限制存取点的线性结构_栈的练习以及解析
weixin_39588911的博客
12-03 3348
The Practice Of Stack栈的练习01栈是()。A.顺序存储的线性结构 B.链式存储的非线性结构C.限制存取点的线性结构 D.限制存储点的非线性结答案：B解析：线性表、栈和队列的逻辑结构都是相同的，都属于线性结构，只是它们对数据的运算不同，从而表现出不同的特点。02()不是栈的基本操作。A.删除栈顶元素 B.删除栈底元素C.判断栈是否为空 ...
栈的基本操作
zhang21722668的博客
08-28 486
/************************************/ //Stack.h #define MAXSIZE 10 typedef int SDataType; typedef struct Stack { SDataType _array[MAXSIZE]; int _top; //标记栈顶元素 }Stack; //初始化 void StackIn...
特殊的线性表：栈的基本操作（顺序栈、链栈）
lesileqin的博客
03-11 964
栈和队列是两种特殊的线性结构，从数据结构的角度来看，栈和队列也是线性表。他们的特点在于仅限在表头或者表尾进行插入或者删除的操作。栈和队列都是特殊的线性结构，所以他们的实现方式也包括顺序存储和链式存储两种方式。 栈（stack） 栈是限定仅在表尾进行插入和删除操作的线性表。 因此我们把允许插入和删除的一段叫做栈顶（top），另一端称作栈底（bottom）。没有任何数据元素的栈叫做空栈。 ...
栈，顺序栈，链栈的基础概念
diviner_s的博客
02-02 3731
栈——后进先出 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 栈的定义 栈（stack）：是限定仅在表尾进行插入或删...
数据结构与算法 －顺序栈及其相关算法
越陌度阡
05-29 1030
顺序栈及常用名词 1.顺序栈－即栈的顺序实现。 2.栈容量－栈中可存放的最大元素个数。 3.栈顶指针 top－指示当前栈顶元素在栈中的位置。 4. 栈空－栈中无元素时，表示栈空； 5.栈满－数组空间已被占满时，称栈满； 6.下溢－当栈空时，再要求作出栈运算，则称“下溢”； 7.上溢－当栈满时，再要求作进栈运算，则称“上溢”。 顺序栈的类型定义 const int maxsize=6; typedef struct seqstack { DataType da......
数据结构第三章 栈和队列
马骏
06-30 651
一、栈（先进后出） 限定头的一种线性表 （是一种逻辑结构）、只能在一端操作——插入或删除。 存储结构： （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）链式栈：通常用
多栈共享--双端顺序栈为代表
zaiyang遇见
03-05 580
双端栈： 特性：栈低位置不变，而栈顶位置动态变化。 申请一个共享的一维数组空间s[M],将两个栈的栈低分别放在一维数组的两端，分别是0，M-1。 双端顺序栈的存储结构： #define M 100 typedef struct { StackElementType Stack[M];/*Stack[M]为栈区*/ StackElementType top[2];/*top[0]和t...
数据结构：基于顺序存储的共享栈
成龙大侠的博客
03-24 757
顺序存储的共享栈本质上就是把一个数组两端分别当成一个栈，这两个栈共用一块存储空间。 #include <stdio.h> #include <stdlib.h> #define MaxSize 20 #define ElemType int typedef struct{ ElemType data[MaxSize]; int top0; // 0号栈顶指针...
头歌实践教学平台数据结构 第2关：队列的基本操作实验三 栈与队列python答案
最新发布
10-29
头歌实践教学平台是一个在线教育平台，提供了丰富的计算机编程课程。其中包括数据结构课程，第2关是关于队列的基本操作实验。在这个实验中，你需要掌握队列的基本操作，包括入队、出队、判断队列是否为空、获取队列...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值