顺序栈与两栈共享空间-C语言实现

栈是一种只能允许在栈顶插入数据与删除数据的数据结构，其实这就是一种特殊的线性表，特殊在 只能在表尾进行增减元素，上代码

#include <stdio.h>

#define MAXSIZE 20                    //栈空间大小
typedef int SElemType;                //元素类型
typedef int Status;                    //返回值类型
#define OK 1                        //操作成功
#define ERROR 0                        //操作失败

typedef struct                        //顺序栈的数据结构
{
    SElemType date[MAXSIZE];        //栈元素数据
    int top;                        //栈顶指针
}SeqStack;                            //栈名

/*入栈操作*/
Status Push(SeqStack *S, SElemType e)
{
    if(S->top == MAXSIZE-1)                //判断栈是否已满
        return ERROR;
    S->date[++S->top] = e;                //栈顶指针加1，栈顶元素等于e
    return OK;
}

/*出栈操作*/
Status Pop(SeqStack *S, SElemType *e)
{
    if(S->top == -1)                    //判断栈是否为空
        return ERROR;
    *e = S->date[S->top--];                //将栈顶元素赋值与e，并将栈顶指针减1
    return OK;
}


void main()
{
    SeqStack S;            //创建栈S
    S.top = -1;            //栈顶指针为-1,栈为空
    int e;                //入栈与出栈的元素

    while(true)
    {
        printf("请选择对顺序栈的操作：
");
        printf("1.入栈
");
        printf("2.出栈
");
        printf("3.退出
");
        int a;
        scanf("%d", &a);
        switch(a)
        {
            case 1:
                printf("请输入入栈的元素：");
                scanf("%d", &e);
                if(Push(&S, e))
                    printf("入栈成功
");
                else
                    printf("入栈失败
");
                break;
            case 2:
                if(Pop(&S, &e))
                    printf("出栈的元素为：%d
",e);
                else
                    printf("栈空
");
                break;
            case 3:
                return;
            default:
                printf("选择错误
");
                break;
        }
    }
}

顺序栈中有一类比较特殊的栈，就是两个数据类型一样的栈可以共享同一个数组空间，从而可以节约内存空间。

#include<stdio.h>
#define MAXSIZE 100                            //栈空间大小
typedef int ElemType;                        //元素类型
typedef int Status;                            //返回值类型
#define OK 1                                //操作成功
#define ERROR 0                                //操作失败

typedef struct                                //共享栈结构体
{
    ElemType date[MAXSIZE];                    //栈元素
    int top1;                                //栈1栈顶指针
    int top2;                                //栈2栈顶指针
}SeqDoubleStack;                            //栈名


/*双向栈的入栈操作*/
Status Push(SeqDoubleStack *S, int flag, ElemType e)
{
    if(S->top1 + 1 == S->top2)                //判断栈是否已满
        return ERROR;
    if(flag == 1)                            //若flag等于1，则对栈1操作
        S->date[++S->top1] = e;                //将栈1指针加1，并赋值为e
    if(flag == 2)                            //若为2，对栈2操作
        S->date[--S->top2] = e;                //将栈2指针减1，并赋值为e
    return OK;
}

/*双向栈的出栈操作*/
Status Pop(SeqDoubleStack *S, int flag, ElemType *e)
{
    if(flag == 1 && S->top1 != -1)            //若flag为1且栈1栈顶不是-1
    {
        *e = S->date[S->top1--];            //将栈顶元素赋值给e，并将栈顶减1
        return OK;
    }
    if(flag == 2 && S->top2 != MAXSIZE)        //若flag为2且栈2栈顶不是MAXSIZE
    {
        *e = S->date[S->top2++];            //将栈顶元素赋值给e，并将栈顶加1
        return OK;
    }
    return ERROR;
}

void main()
{
    SeqDoubleStack S;            //创建栈S
    S.top1 = -1;            //栈顶1指针为-1,栈为空
    S.top2 = MAXSIZE;        //栈顶2指针为MAXSIZE,栈为空
    int e;                //入栈与出栈的元素

    while(true)
    {
        printf("请选择对顺序栈的操作：
");
        printf("1.栈1入栈
");
        printf("2.栈2入栈
");
        printf("3.栈1出栈
");
        printf("4.栈2出栈
");
        printf("5.退出
");
        int a;
        scanf("%d", &a);
        switch(a)
        {
            case 1:
                printf("请输入入栈1的元素：");
                scanf("%d", &e);
                if(Push(&S, 1, e))
                    printf("入栈成功
");
                else
                    printf("入栈失败
");
                break;
            case 2:
                printf("请输入入栈2的元素：");
                scanf("%d", &e);
                if(Push(&S, 2, e))
                    printf("入栈成功
");
                else
                    printf("入栈失败
");
                break;
            case 3:
                if(Pop(&S, 1, &e))
                    printf("出栈的元素为：%d
",e);
                else
                    printf("栈空
");
                break;
            case 4:
                if(Pop(&S, 2, &e))
                    printf("出栈的元素为：%d
",e);
                else
                    printf("栈空
");
                break;
            case 5:
                return;
            default:
                printf("选择错误
");
                break;
        }
    }
}

使用这种结构时，大多是这两个栈的空间需求有相反关系，使得在一个栈的元素个数增多时，另一个栈的元素个数会相对减少，比如股票的买卖可以使用这种结构，因为你买入的时候，就一定是有人卖出了；你挣钱的时候，就一定是有人赔钱了。如果这两个栈没有什么关系，那么对于内存的节省是不明显的，因为随时都有溢出的可能，那这就没有什么意义了。