• 顺序栈与两栈共享空间-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;
            }
        }
    }

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

  • 相关阅读:
    2017-3-7 leetcode 66 119 121
    2017-3-6 leetcode 118 169 189
    2017-3-5 leetcode 442 531 533
    c++ std
    2017-3-4 leetcode 414 485 495
    2017-3-3 leetcod 1 35 448
    想做手游
    编程规范
    1165: 零起点学算法72——首字母变大写
    1164: 零起点学算法71——C语言合法标识符(存在问题)
  • 原文地址:https://www.cnblogs.com/yurui/p/9514401.html
Copyright © 2020-2023  润新知