数据结构（二）栈与队列---栈的了解和栈的顺序存储结构和实现

最新推荐文章于 2022-06-07 17:02:37 发布

weixin_30575309

最新推荐文章于 2022-06-07 17:02:37 发布

阅读量140

点赞数

文章标签：数据结构与算法操作系统

原文链接：http://www.cnblogs.com/ssyfj/p/9430717.html

版权

（一）栈的定义

栈是一种重要的线性结构。是我们前面讲过的线性表的一种具体形式

栈是限定仅在表尾进行插入和删除操作的线性表

我们把允许插入和删除的一端称为栈顶top,另一端称为栈底bottom,不含任何元素的栈称为空栈。栈又称为后进先出（Last In First Out）的线性表，简称LIFO

栈的插入操作，叫做进栈，也称为压栈，入栈
栈的删除操作，叫做出栈，也称为弹栈

（二）栈的抽象数据类型

ADT 栈(stack)
Data
    同线性表。元素具有相同的类型，相邻元素具有前驱和后继的关系。

Operation
    InitStack( *s): 初始化操作，建立一个空栈
    ClearStack( *s): 将栈清空
    StackEmpty( s): 若栈存在，返回true，否则返回false
    StackLength( s): 返回栈S的元素个数

    GetTop( s, *e): 若是栈存在且非空，用e返回S的栈顶元素
    Push( *s, e):若是栈存在，则插入新的元素e到栈S中并成为栈顶元素
    Pop( *s, *e):若是栈存在且非空，删除栈顶元素，并用e返回其值
    DestroyStack( *s): 若是栈存在，则销毁他
endADT

注意：

由于栈本身就是一个线性表，那么我们讲的线性表的顺序存储和链式存储，对于栈来说，都是适用的。

（三）栈的顺序存储结构

typedef struct
{
    ElemType *base;    //栈底指针
    ElemType *top;    //栈顶指针
    int stackSize;    //最大容量，这是可修改的
}sqStack;

（四）实现栈之前的预备知识

（1）malloc函数获取的内存，内存空间上是连续的

malloc出来的空间，只是在虚拟内存中是连续的。而从实际的物理空间到虚拟内存空间还有一个映射的关系。
这个映射是由操作系统来控制的，一般情况下，从虚拟地址无法反查到物理地址。对于连续的虚拟地址空间，也就无法得知是否物理连续。
但由于映射的不确定性，当申请一段内存空间，尤其是比较大的内存长度情况下，物理地址不连续的可能性还是相当大的。
事实上，大多数的编程不需要关注物理空间是否连续。

（2）不同类型指针的步长增长问题

对于不同类型的指针，虽然指针在内存中的大小都是4字节，
但是他们的增长的地址步长与指针本身大小无关，而是与内部储存数据类型大小有关。
例如：
int *a=(int*)malloc(100*size(int))
int b,c;
b=a;
c=a++;
b=4236536 //这是10进制下的地址
c=4236540 //增长了一个int字节大小的步长

char *base = (char *)malloc(sizeof(char) * 100);
addr1 = base;
addr2 = base+1;
------------------
addr1=5350647
addr2=5350648　　//这里增长了一个char类型字节大小的步长

int *base, *top;
base = (int *)malloc(sizeof(int) * 100);
top = base + 100;
printf("size:%d\n",top - base)　　//重点：两个指针之间相减，所得到的不是地址大小之差，而是其中含有的元素个数，是100，若是我们想要知道地址之差，可以使用int强制转换十六进制地址为一个十进制数进行减法运算，结果是400

（3）指针和所指向的数据中间的关系

我们存储的数据在指针所指向的位置开始，占用了相关大小的字节去存放数据。
所以当我们创建栈的时候，我们的栈顶指针是不能直接读取，我们往往需要先将他降一，然后才能读取那块内存空间获取数据

例如：我们要获取栈顶数据11，我们就需要先将栈顶退一，然后才能读取到数据

（4）realloc函数，再分配空间。用法和误区

realloc 
       原型：extern void *realloc(void *mem_address, unsigned int newsize); 
       用法：#include <stdlib.h> 有些编译器需要#include <alloc.h> 
       功能：改变mem_address所指内存区域的大小为newsize长度。 
       说明：如果重新分配成功则返回指向被分配内存的指针，否则返回空指针NULL。 
                 当内存不再使用时，应使用free()函数将内存块释放。 
       注意：这里原始内存中的数据还是保持不变的。

1、如果有足够空间用于扩大mem_address指向的内存块，则分配额外内存，并返回mem_address 
这里说的是“扩大”，我们知道，realloc是从堆上分配内存的，当扩大一块内存空间时， realloc()试图直接从堆上现存的数据后面的那些字节中获得附加的字节，如果能够满足，自然天下太平。也就是说，如果原先的内存大小后面还有足够的空闲空间用来分配，加上原来的空间大小＝ newsize。那么就ok。得到的是一块连续的内存。 
2、如果原先的内存大小后面没有足够的空闲空间用来分配，那么从堆中另外找一块newsize大小的内存。 
并把原来大小内存空间中的内容复制到newsize中。返回新的mem_address指针。（数据被移动了）。 
老块被放回堆上。

注意：

1、返回值可能与ptr的值不同，如果是不同的话，那么realloc函数完成后，ptr指向的旧内存已被free掉了，会自动为我们释放，所以我们不需要关心。只需要释放新的内存地址即可
2、如果返回NULL值，则分配不成功，而原来的ptr指向的内存还没有被free掉，要求程序显式free.

（五）栈的顺序存储结构实现

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

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

#define STACK_INIT_SIZE 100    //定义栈的初始大小
#define STACK_INCR_SIZE 10    //定义栈的增长大小

typedef int ElemType;
typedef int Status;

typedef struct
{
    ElemType *base;    //栈底指针
    ElemType *top;    //栈顶指针
    int stackSize;    //最大容量，这是可修改的
}sqStack;

//四个基础操作
Status InitStack(sqStack *s);    //初始化操作，建立一个空栈
Status ClearStack(sqStack *s);    //将栈清空
Status StackEmpty(sqStack s);    //若栈存在，返回true，否则返回false
int StackLength(sqStack s);        //返回栈S的元素个数

Status GetTop(sqStack s, ElemType *e);    //若是栈存在且非空，用e返回S的栈顶元素
Status Push(sqStack *s, ElemType e);    // 若是栈存在，则插入新的元素e到栈S中并成为栈顶元素
Status Pop(sqStack *s, ElemType *e);    //若是栈存在且非空，删除栈顶元素，并用e返回其值
Status DestroyStack(sqStack *s);        //若是栈存在，则销毁他

int main()
{
    sqStack sk;
    int i;
    ElemType e;
    sk.base = sk.top = NULL;    //用于判断是否存在
    //初始化空栈
    printf("1.InitStack\n");
    InitStack(&sk);
    printf("2.Push 1-5\n");
    for (i = 1; i <= 5; i++)
        Push(&sk, i);
    printf("3.Pop number for three times\n");
    for (i = 1; i <= 3;i++)
    {
        Pop(&sk, &e);
        printf("Pop %d: %d\n",i, e);
    }
    GetTop(sk, &e);
    printf("4.Get Top:%d\n",e);
    printf("5.Push 6-10\n");
    for (i = 6; i <= 10; i++)
        Push(&sk, i);
    printf("6.Get stack length:%d\n", StackLength(sk));
    printf("7.Pop number for six times\n");
    for (i = 1; i <= 6; i++)
    {
        Pop(&sk, &e);
        printf("Pop %d: %d\n",i, e);
    }
    if (!StackEmpty(sk))
    {
        printf("8.Stack is not Empty\n");
        ClearStack(&sk);
        printf("9.Stack is Clear\n");
    }
    printf("10.Stack Empty:%d\n",StackEmpty(sk));
    printf("11.destroy Stack");
    DestroyStack(&sk);

    system("pause");
    return 0;
}

//初始化操作，建立一个空栈
Status InitStack(sqStack *s)
{
    s->base = (ElemType *)malloc(STACK_INIT_SIZE*sizeof(ElemType));
    if (!s->base)
        return ERROR;
    s->top = s->base;    //最开始，栈顶就是栈底
    s->stackSize = STACK_INIT_SIZE;
    return OK;
}

//将栈清空,将栈顶指针移动到栈底即可，容量大小不要修改，数据不需要清空，数据入栈会覆盖
Status ClearStack(sqStack *s)
{
    if (s == NULL)
        return ERROR;
    s->top = s->base;
    return OK;
}

//若栈存在，返回true，否则返回false
Status StackEmpty(sqStack s)
{
    if (s.base == s.top)
        return TRUE;
    return FALSE;
}

//返回栈S的元素个数
int StackLength(sqStack s)
{
    int length = s.top - s.base;    //指针之间运算，是按照其中数据大小字节来算的
    return length;
}

//若是栈存在且非空，用e返回S的栈顶元素,注意：只是获取栈顶数据，不出栈
Status GetTop(sqStack s, ElemType *e)
{
    if (!e || StackEmpty(s) || !s.base)
        return ERROR;
    *e = *(s.top - 1);
    return OK;
}

//入栈操作：若是栈存在，则插入新的元素e到栈S中并成为栈顶元素
Status Push(sqStack *s, ElemType e)
{
    ElemType* newStack;
    if (!s->base)
        return ERROR;

    if (s->top-s->base>=s->stackSize)    //栈满，需要再分配
    {
        newStack = (ElemType *)realloc(s->base, (s->stackSize + STACK_INCR_SIZE)*sizeof(ElemType));    //重新分配大小
        if (!newStack)    //若是分配失败，会返回NULL
        {
            free(s->base);
            exit(0);    //分配失败，直接退出
        }
        s->base = newStack;
        //分配后需要将栈顶指针进行移动到新的位置
        s->top = s->base + s->stackSize;
    }
    *(s->top) = e;
    s->top++;
    return OK;
}

//若是栈存在且非空，删除栈顶元素（只需要将栈顶指针下移即可），并用e返回其值
Status Pop(sqStack *s, ElemType *e)
{
    if (!s->base || !e || StackEmpty(*s))
        return ERROR;
    *e = *(--s->top);
    return OK;
}

//若是栈存在，则销毁他（直接将栈底指针释放即可，置为空）
Status DestroyStack(sqStack *s)
{
    if (!s->base)    //若是栈存在
    {
        s->stackSize = 0;
        free(s->base);
        s->base = s->top = NULL;
    }
    return OK;
}

（六）应用：进制转换

Status Bin2Dec(sqStack* s,int *val);    //二进制转十进制
Status Bin2Oct(sqStack* s, sqStack* sv);    //二进制转八进制
Status Bin2Hex(sqStack* s, sqStack* sv);    //二进制转十六进制

int main()
{
    sqStack sk;
    sqStack valsk;　　//接收转换为8进制或者16进制的数，需要再使用一个栈
    int dec;　　//接收转换为10进制数值
    char ch;
    ElemType e;
    sk.base = sk.top = NULL;    //用于存放二进制字符串
    valsk.base = valsk.top = NULL;    //用于存放八进制和十六进制值
    //初始化空栈
    InitStack(&sk);
    InitStack(&valsk);
    scanf("%c", &ch);
    while (ch!='#')
    {
        Push(&sk, ch);
        scanf("%c", &ch);
    }
    getchar();    //消除键盘缓冲区中的回车符

　　 //这里修改后可以测试其他进制转换，注意：转换10进制不需要用到第二个栈
    if (Bin2Hex(&sk, &valsk))
        while (!StackEmpty(valsk))
        {
            Pop(&valsk, &ch);
            printf("%c", ch);
        }

　　 DestroyStack(&sk);
　　 DestroyStack(&valsk);

    system("pause");
    return 0;
}

//二进制转十进制
Status Bin2Dec(sqStack* s, int *val)
{
    int i,key,length,v=0;
    char ch;

    if (!val || StackEmpty(*s))
        return ERROR;

    length = StackLength(*s);

    for (i = 0; i < length;i++)
    {
        Pop(s, &ch);
        key = ch - 48;
        v += key*pow(2, i);
    }
    *val = v;
    return OK;
}

//二进制转八进制
Status Bin2Oct(sqStack* s, sqStack* sv)
{
    char ord[3] = { 0 };
    char ch;
    int i,length,val;

    if (!s || !sv)
        return ERROR;

    if (!StackEmpty(*sv))
        ClearStack(sv);

    while (!StackEmpty(*s))
    {
        memset(ord, '0', 3);
        val = 0;
        length = StackLength(*s);
        if (length >= 3)
            for (i = 2; i >= 0; i--)
                Pop(s, &ord[i]);
        else
            for (i = 2; i >= 3 - length; i--)
                Pop(s, &ord[i]);

        for (i = 0; i < 3;i++)
            val += (ord[2 - i] - 48)*pow(2, i);
        Push(sv, (char)(val+48));
    }
    return OK;
}

//二进制转十六进制
Status Bin2Hex(sqStack* s, sqStack* sv)
{
    char hex[4] = { 0 };
    char ch;
    int i, length, val;

    if (!s || !sv)
        return ERROR;

    if (!StackEmpty(*sv))
        ClearStack(sv);

    while (!StackEmpty(*s))
    {
        memset(hex, '0', 4);
        val = 0;
        length = StackLength(*s);
        if (length >= 4)
            for (i = 3; i >= 0; i--)
                Pop(s, &hex[i]);
        else
            for (i = 3; i >= 4 - length; i--)
                Pop(s, &hex[i]);

        for (i = 0; i < 4; i++)
            val += (hex[3 - i] - 48)*pow(2, i);
        if (val < 10)
            Push(sv, (char)(val + 48));
        else
            Push(sv, 'A' + val - 10);

    }
    return OK;
}

（七）栈的顺序存储实现另法：使用数组

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

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

#define MAXSIZE 100

typedef int ElemType;
typedef int Status;

typedef struct
{
    ElemType data[MAXSIZE];
    int top;
}sqStack;

//四个基础操作
Status InitStack(sqStack *s);    //初始化操作，建立一个空栈
Status ClearStack(sqStack *s);    //将栈清空
Status StackEmpty(sqStack s);    //若栈存在，返回true，否则返回false
int StackLength(sqStack s);        //返回栈S的元素个数

Status GetTop(sqStack s, ElemType *e);    //若是栈存在且非空，用e返回S的栈顶元素
Status Push(sqStack *s, ElemType e);    // 若是栈存在，则插入新的元素e到栈S中并成为栈顶元素
Status Pop(sqStack *s, ElemType *e);    //若是栈存在且非空，删除栈顶元素，并用e返回其值
Status DestroyStack(sqStack *s);        //若是栈存在，则销毁他

int main()
{
    sqStack sk;
    int i;
    ElemType e;

    //初始化空栈
    printf("1.InitStack\n");
    InitStack(&sk);
    printf("2.Push 1-5\n");
    for (i = 1; i <= 5; i++)
        Push(&sk, i);
    printf("3.Pop number for three times\n");
    for (i = 1; i <= 3;i++)
    {
        Pop(&sk, &e);
        printf("Pop %d: %d\n",i, e);
    }
    GetTop(sk, &e);
    printf("4.Get Top:%d\n",e);
    printf("5.Push 6-10\n");
    for (i = 6; i <= 10; i++)
        Push(&sk, i);
    printf("6.Get stack length:%d\n", StackLength(sk));
    printf("7.Pop number for six times\n");
    for (i = 1; i <= 6; i++)
    {
        Pop(&sk, &e);
        printf("Pop %d: %d\n",i, e);
    }
    if (!StackEmpty(sk))
    {
        printf("8.Stack is not Empty\n");
        ClearStack(&sk);
        printf("9.Stack is Clear\n");
    }
    printf("10.Stack Empty:%d\n",StackEmpty(sk));
    printf("11.destroy Stack");
    DestroyStack(&sk);

    system("pause");
    return 0;
}

//初始化操作，建立一个空栈
Status InitStack(sqStack *s)
{
    if (!s)
        return ERROR;
    memset(s->data, 0, MAXSIZE*sizeof(ElemType));
    s->top = -1;
    return OK;
}

//将栈清空,将栈顶指针移动到栈底即可，数据不需要清空，数据入栈会覆盖
Status ClearStack(sqStack *s)
{
    if (!s)
        return ERROR;
    s->top = -1;
    return OK;
}

//若栈存在，返回true，否则返回false
Status StackEmpty(sqStack s)
{
    if (s.top == -1)
        return OK;
    return FALSE;
}

//返回栈S的元素个数
int StackLength(sqStack s)
{
    return s.top+1;
}

//若是栈存在且非空，用e返回S的栈顶元素,注意：只是获取栈顶数据，不出栈
Status GetTop(sqStack s, ElemType *e)
{
    if (s.top = -1||!e)
        return ERROR;
    *e = s.data[s.top];
    return OK;
}

//入栈操作：若是栈存在，则插入新的元素e到栈S中并成为栈顶元素
Status Push(sqStack *s, ElemType e)
{
    if (s->top + 1 == MAXSIZE||!s)
        return ERROR;
    s->top++;
    s->data[s->top] = e;
    return OK;
}

//若是栈存在且非空，删除栈顶元素（只需要将栈顶指针下移即可），并用e返回其值
Status Pop(sqStack *s, ElemType *e)
{
    if (s->top == -1||!s||!e)
        return ERROR;
    *e = s->data[s->top];
    s->top--;
    return OK;
}

//若是栈存在，则销毁他,数据清空
Status DestroyStack(sqStack *s)
{
    if (!s)
        return ERROR;
    memset(s->data, 0, MAXSIZE*sizeof(ElemType));
    s->top = -1;
    return OK;
}

引申：两栈共享空间

对于我们使用数组来构造顺序栈，有一个很大的缺陷，就是需要事先确定数组的存储空间大小，不够的话扩容不方便，太多了又过于浪费空间。
于是设计出来合适的大小数组，将他的空间从两头分别当做一个栈。就可以最大限度的利用数组空间。

例如：一个栈需要的空间大概为50-150，多数情况是在100以下，有少数情况会超过100。
那么当我们使用两个栈时，若是声明两个150空间的数组。则空间浪费较多。
不如一次声明200空间大小供两个栈共同使用。虽然有满栈的情况，不过出现情况不大。而且会最大程度利用了栈的空间。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

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

#define MAXSIZE 10

typedef int ElemType;
typedef int Status;

//两栈共享空间结构
typedef struct
{
    ElemType data[MAXSIZE];
    int top1;    //栈1 栈顶指针 指向数组开始 从做向右
    int top2;    //栈2 栈顶指针 指向数组结尾 从右向左
}sqDoubleStack;

//四个基础操作
Status InitStack(sqDoubleStack *s);    //初始化操作，建立一个空栈
Status ClearStack(sqDoubleStack *s, int stackNumber);    //将栈清空
Status StackEmpty(sqDoubleStack s, int stackNumber);    //若栈存在，返回true，否则返回false
int StackLength(sqDoubleStack s, int stackNumber);        //返回栈S的元素个数

Status GetTop(sqDoubleStack s, ElemType *e, int stackNumber);    //若是栈存在且非空，用e返回S的栈顶元素
Status Push(sqDoubleStack *s, ElemType e, int stackNumber);    // 若是栈存在，则插入新的元素e到栈S中并成为栈顶元素
Status Pop(sqDoubleStack *s, ElemType *e, int stackNumber);    //若是栈存在且非空，删除栈顶元素，并用e返回其值
Status DestroyStack(sqDoubleStack *s);        //若是栈存在，则销毁他

int main()
{
    sqDoubleStack sk;
    int i;
    Status st;
    ElemType e;

    //初始化空栈
    printf("1.InitStack\n");
    InitStack(&sk);
    printf("2.Push 1-10\n");
    for (i = 1; i <= 11; i++)
    {
        st=Push(&sk, i, i % 2 + 1);
        if (st == ERROR)
            printf("2.Push %d to stack-%d failure!\n", i, i % 2 + 1);
    }
    printf("3.Pop number for three times\n");
    for (i = 1; i <= 5; i++)
    {
        Pop(&sk, &e,i%2+1);
        printf("Pop stack-%d: %d\n", i%2+1, e);
    }
    GetTop(sk, &e,1);
    printf("4.Get stack-1 Top:%d\n", e);
    GetTop(sk, &e, 2);
    printf("4.Get stack-2 Top:%d\n", e);

    printf("5.Get stack-1 length:%d\n", StackLength(sk,1));
    if (!StackEmpty(sk,1))
    {
        printf("8.Stack-1 is not Empty\n");
        ClearStack(&sk,1);
        printf("9.Stack-1 is Clear\n");
    }

    printf("5.Get stack-2 length:%d\n", StackLength(sk, 2));
    if (!StackEmpty(sk, 2))
    {
        printf("8.Stack-2 is not Empty\n");
        ClearStack(&sk, 2);
        printf("9.Stack-2 is Clear\n");
    }
    
    printf("10.Stack-1 Empty:%d\n", StackEmpty(sk,1));
    printf("10.Stack-2 Empty:%d\n", StackEmpty(sk, 2));
    printf("11.destroy Stack");
    DestroyStack(&sk);

    system("pause");
    return 0;
}

//初始化操作，建立一个空栈
Status InitStack(sqDoubleStack *s)
{
    if (!s)
        return ERROR;
    memset(s->data, 0, MAXSIZE*sizeof(ElemType));
    s->top1 = -1;
    s->top2 = MAXSIZE;
    return OK;
}

//将栈清空,stackNumber为0，两个都清空，为1清空栈1,2清空栈2
Status ClearStack(sqDoubleStack *s, int stackNumber)
{
    if (!s)
        return ERROR;
    if (stackNumber == 0)
    {
        s->top1 = -1;
        s->top2 = MAXSIZE;
    }
    else if (stackNumber==1)
    {
        s->top1 = -1;
    }
    else if (stackNumber==2)
    {
        s->top2 = MAXSIZE;
    }
    return OK;
}

//若两个栈都不存在，返回true，否则返回false
Status StackEmpty(sqDoubleStack s, int stackNumber)
{
    if (stackNumber == 0)
    {
        if (s.top1 == -1 && s.top2 == MAXSIZE)
            return OK;
    }
    else if (stackNumber == 1)
    {
        if (s.top1 == -1)
            return OK;
    }
    else if (stackNumber == 2)
    {
        if (s.top2 == MAXSIZE)
            return OK;
    }
    return FALSE;
}

//返回栈S的元素个数,是指两个栈的总长
int StackLength(sqDoubleStack s,int stackNumber)
{
    int length = 0;
    if (stackNumber == 0)
        length=(s.top1 + 1) + (MAXSIZE - s.top2);
    else if (stackNumber == 1)
        length = s.top1 + 1;
    else if (stackNumber == 2)
        length = MAXSIZE - s.top2;
    return length;
}

//若是栈存在且非空，用e返回S的栈顶元素,注意：只是获取栈顶数据，不出栈
Status GetTop(sqDoubleStack s, ElemType *e,int stackNumber)
{
    if (!e)
        return ERROR;
    if (stackNumber == 1)
        if (s.top1 == -1)
            return ERROR;
        else
            *e = s.data[s.top1];
    else if (stackNumber == 2)
        if (s.top2 == MAXSIZE)
            return ERROR;
        else
            *e = s.data[s.top2];
    return OK;
}

//入栈操作：若是栈存在，则插入新的元素e到栈S中并成为栈顶元素
Status Push(sqDoubleStack *s, ElemType e, int stackNumber)
{
    if (!s)
        return ERROR;
    if (s->top1 + 1 == s->top2)    //栈满，不允许插入
        return ERROR;
    
    if (stackNumber == 1)
        s->data[++s->top1] = e;
    else if (stackNumber==2)
        s->data[--s->top2] = e;
    
    return OK;
}

//若是栈存在且非空，删除栈顶元素（只需要将栈顶指针下移即可），并用e返回其值
Status Pop(sqDoubleStack *s, ElemType *e, int stackNumber)
{
    if (StackEmpty(*s, stackNumber)||!s || !e)
        return ERROR;
    
    if (stackNumber == 1)
        *e = s->data[s->top1--];
    else if (stackNumber==2)
        *e = s->data[s->top2++];
    return OK;
}

//若是栈存在，则销毁他,两个栈都销毁
Status DestroyStack(sqDoubleStack *s)
{
    if (!s)
        return ERROR;
    memset(s->data, 0, MAXSIZE*sizeof(ElemType));
    s->top1 = -1;
    s->top2 = MAXSIZE;
    return OK;
}

（八）两种顺序结构栈的比较

方法一的空间是malloc出来的一块连续空间，操作稍微复杂些。但是当栈满时，可以进行扩展。
方法二除了使用简单，对于栈的扩展方面欠缺。
推荐第一种，了解第二种即可

（九）栈的应用：括号匹配

对于()[]{}都是正确的[),{],(}都是匹配失败的，注意：对于引号里面的括号不进行匹配,()[]'(]'()是正确的

int main()
{
    sqStack sk;
    ElemType e;
    char ch;
    sk.base = sk.top = NULL;    //用于判断是否存在
    //初始化空栈,用于存放()[]{}''""这几个数据，的左半边进行匹配
    InitStack(&sk);
    scanf("%c", &ch);
    while (ch!='#')
    {
        if (GetTop(sk, &e))
        {
            if ((e == '"'&&ch != '"') || (e == '\''&&ch != '\''))    //若是在单双引号之间的括号全部舍去
                goto GS;
            if ((e == '"'&&ch == '"') || (e == '\''&&ch == '\''))    //匹配单双引号，优先级是最高的
            {
                Pop(&sk, &e);    //弹出单双引号
                goto GS;
            }
            if ((e == '('&&ch == ')') || (e == '['&&ch == ']') || (e == '{'&&ch == '}'))
            {
                Pop(&sk, &e);    //弹出匹配好的括号
                goto GS;
            }
            if ((ch == ')'&&e != '(') || (ch == ']'&&e != '[') || (ch == '}'&&e != '{'))    //这是当我们获取的右半边括号与栈顶不匹配时，直接退出,退出时栈不为空
                break;
        }
        else   //没有栈顶元素
        {
            if (ch == ')' || ch == ']' || ch == '}')    //没有栈顶元素时，若是我们获取的括号是右半边直接匹配失败
            {
                Push(&sk, ch);    //这里必须放一个东西入栈，以保证不为空，为一会判断做准备，至于入栈的数据随意
                break;
            }
        }
        if (ch == '('||ch=='['||ch=='{'||ch=='\'' || ch == '"')
            Push(&sk, ch);
    GS:
        scanf("%c", &ch);
    }
    getchar();
    
    if (StackEmpty(sk))
        printf("match success!");
    else
        printf("match failure!");
    system("pause");
    return 0;
}

转载于:https://www.cnblogs.com/ssyfj/p/9430717.html

weixin_30575309

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
数据结构（二）栈与队列---栈的了解和栈的顺序存储结构和实现

（一）栈的定义栈是一种重要的线性结构。是我们前面讲过的线性表的一种具体形式栈是限定仅在表尾进行插入和删除操作的线性表我们把允许插入和删除的一端称为栈顶top,另一端称为栈底bottom,不含任何元素的栈称为空栈。栈又称为后进先出（Last In First Out）的线性表，简称LIFO栈的插入操作，叫做进栈，也称为压栈，入栈栈的删除操作，叫做出栈，...
复制链接

扫一扫