栈（笔记）

我不要麦克风

已于 2023-04-13 10:42:28 修改

阅读量91

点赞数 1

分类专栏：数据结构文章标签：开发语言 c语言

于 2023-03-26 21:07:10 首次发布

本文链接：https://blog.csdn.net/ztt19990421/article/details/129758081

版权

数据结构专栏收录该内容

6 篇文章 0 订阅

订阅专栏

1.1栈的概念及结构

栈:一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端
称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO (Last In First out)的原则，如下图。
压栈:栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈:栈的删除操作叫做出栈。出数据也在栈顶。

数组栈

数组栈结构比链式栈要好一点。

链式栈
如果用尾做栈顶，尾插尾删，要设计成双向链表，否则删除数据效率低；
如果用头做栈顶，头插头删，就可以设计成单链表。

//Stack.h
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int STDataType;
typedef struct Stack
{
   STDataType* a;
   int top;
   int capacity;
}ST;
void StackInit(ST* ps);
void StackDestory(ST* ps);
void StackPush(ST* ps,STDataType x);
void StackPop(ST* ps);
STDataType StackTop(ST* ps);//取栈顶数据
int StackSize(ST* ps);
bool StackEmpty(ST* ps);//判断栈是不是为空

//Test.c
#include "Stack.h"
void TestStack1()
{
    ST st;
    StackInit(&st);
    StackPush(&st,1);
    StackPush(&st,2);
    StackPush(&st,3);
    StackPush(&st,4);
    StackPop(&st);
    StackPop(&st);
    StackPop(&st);
    StackPop(&st);
    StackDestory(&st);
}
void TestStack2()
{
    ST st;
    StackInit(&st);
    StackPush(&st,1);
    StackPush(&st,2);
    StackPush(&st,3);
    StackPush(&st,4);
    //遍历栈里面的数据
    while(!StackEmpty(&t))//不为空就继续
    {
        printf("%d",StackTop(&st));//先取栈顶数据，把栈顶数据取了才能取到下一个
        StackPop(&st);//把当前栈顶数据pop掉，取下一个
    }
    StackDestory(&st);
}
int main()
{
    TestStack1();
    TestStack2()
    return 0;
}

//Stack.c
#include "Stack.h"
//初始化
void StackInit(ST* ps)
{
    assert(ps);//结构体的指针不能为空
    ps->a=NULL;
    ps->top=0;//初始化时，top给的是0，意味着top指向栈顶数据的下一个
    //ps->top=-1  初始化时，top给的是-1，意味着top指向栈顶数据
    ps->capacity=0;
}
//销毁栈
void StackDestory(ST* ps)
{
    assert(ps);
    free(ps->a);
    ps->a=NULL;
    ps->top=ps->capacity=0;
}
//数据进栈
void StackPush(ST* ps,STDataType x)
{
    assert(ps);
    if(ps->top==ps->capacity)//栈满
    {
        int newCapacity=ps->capacity==0?4:ps->capacity*2;//增容，若capacity如初始化时为0，扩容四个空间，否则扩容到原来的2倍
        STDataType* tmp=realloc(ps->a,sizeof(STDataType)*newCapacity); //realloc有空间就扩容，没有就相当于malloc
        if(tmp==NULL)
        {
           printf("realloc fail\n");
           exit(-1);//增容失败
        }
        ps->a=tmp;//开辟空间成功
        ps->capacity=newCapacity;
    }
    ps->a[ps->top]=x;//先把数据放在top位置
    ps->top++;//指向下一个位置
}
//出栈
void StackPop(ST* ps)
{
    assert(ps);
    assert(ps->top>0);//表示还有数据，不为空
    ps->top--;
}
//取栈顶数据
STDataType StackTop(ST* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));//表示还有数据，不为空
    return ps->a[ps->top-1];
}
//栈的大小
int StackSize(ST* ps)
{
    assert(ps);
    return ps->top;
}
//判断栈是不是为空
bool StackEmpty(ST* ps)
{
    assert(ps);
    return ps->top==0;//为空返回真
}

1.2栈的例题

①有效的括号（定义一个栈，先初始化再销毁）

1.左括号，入栈

2.右括号，出栈匹配跟右括号匹配

typedef char STDataType;
typedef struct Stack
{
   STDataType* a;
   int top;
   int capacity;
}ST;
void StackInit(ST* ps);
void StackDestory(ST* ps);
void StackPush(ST* ps,STDataType x);
void StackPop(ST* ps);
STDataType StackTop(ST* ps);//取栈顶数据
int StackSize(ST* ps);
bool StackEmpty(ST* ps);//判断栈是不是为空
void StackInit(ST* ps)
{
    assert(ps);//结构体的指针不能为空
    ps->a=NULL;
    ps->top=0;//初始化时，top给的是0，意味着top指向栈顶数据的下一个
    //ps->top=-1  初始化时，top给的是-1，意味着top指向栈顶数据
    ps->capacity=0;
}
//销毁栈
void StackDestory(ST* ps)
{
    assert(ps);
    free(ps->a);
    ps->a=NULL;
    ps->top=ps->capacity=0;
}
//数据进栈
void StackPush(ST* ps,STDataType x)
{
    assert(ps);
    if(ps->top==ps->capacity)//栈满
    {
        int newCapacity=ps->capacity==0?4:ps->capacity*2;//增容，若capacity如初始化时为0，扩容四个空间，否则扩容到原来的2倍
        STDataType* tmp=realloc(ps->a,sizeof(STDataType)*newCapacity); //realloc有空间就扩容，没有就相当于malloc
        if(tmp==NULL)
        {
           printf("realloc fail\n");
           exit(-1);//增容失败
        }
        ps->a=tmp;//开辟空间成功
        ps->capacity=newCapacity;
    }
    ps->a[ps->top]=x;//先把数据放在top位置
    ps->top++;//指向下一个位置
}
//出栈
void StackPop(ST* ps)
{
    assert(ps);
    assert(ps->top>0);//表示还有数据，不为空
    ps->top--;
}
//取栈顶数据
STDataType StackTop(ST* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));//表示还有数据，不为空
    return ps->a[ps->top-1];
}
//栈的大小
int StackSize(ST* ps)
{
    assert(ps);
    return ps->top;
}
//判断栈是不是为空
bool StackEmpty(ST* ps)
{
    assert(ps);
    return ps->top==0;//为空返回真
}
bool isValid(char * s){
    ST st;
    StackInit(&st);//定义一个栈，先初始化再销毁
    //到\0停止
    while(*s)
    {
       if(*s=='('||*s=='{'||*s=='[')
       {
         StackPush(&st,*s);//进栈
         ++s;  
       }
       else
       {
         //遇到右括号了，但是栈里面没有数据，说明前面没有左括号，不匹配，返回false
         if( StackEmpty(&st))
         {
            StackDestory(&st);
            return false;
         }
         STDataType top=StackTop(&st);//取栈顶元素
         StackPop(&st);//弹出
         if((*s=='}'&&top!='{')||(*s==')'&&top!='(')||(*s==']'&&top!='['))
         {
            StackDestory(&st);//不destory就会内存泄漏
            return false;//不匹配
         }
         else
         {
            ++s;//匹配，继续往下走
         }
       }
    }
    //如果栈不是空，说明栈中还有左括号未出
    //没有匹配,返回的是false
    bool ret=StackEmpty(&st);//取完判断栈是不是为空
    StackDestory(&st);
    return ret;//栈是空的说明匹配完了，就为真
}