在一个数组中实现两个堆栈

最新推荐文章于 2021-11-16 16:40:46 发布

小白～

最新推荐文章于 2021-11-16 16:40:46 发布

阅读量866

点赞数

分类专栏：数据结构文章标签：栈

本文链接：https://blog.csdn.net/weixin_41423494/article/details/83350541

版权

数据结构专栏收录该内容

21 篇文章 3 订阅

订阅专栏

题目要求：

。将编号为0和1的两个栈放于一个数组空间V [米]中，底栈分别处于数组的两端当第0号栈的栈顶指针顶[0] = - 1时该栈为空;当第1号栈的栈顶指针顶[1] = M时，该栈为空。两个栈从两端向中间增长试编写双栈初始化，判断栈空，栈满，进栈和。。出栈等算法的函数双栈数据结构的定义如下：

typedef struct 
{
    int top[2],bot[2];  //栈顶和栈低指针
    SElemType *V;   //栈数组
    int m;    //栈最大可容纳元素个数
}DblSatck;

分析题目可知一个数组实现两个栈，判断空栈的条件是顶[0] = - 1个顶[1] = M数组空间是有限的，当顶[0] + 1 =顶[1]的时候就表明数组已经用完，就是栈满了。所以我们不需要使用机器人[]，只需要顶[]就可以判断空栈，满栈。也可以对栈进行操作。

下面是我整个程序的代码：

#include<stdio.h>
#include<stdlib.h>
#define empty -2;
#define error -1;
typedef int SElemType;
typedef enum{FULL,NOTFULL,OK,ERROR,EMPTY,NOTEMPTY} bool;
typedef struct{
    int top[2],bot[2];
    SElemType *V;
    int m;
}DblStack,*Stack;

bool judeStackFull(Stack s);
bool judeStackEmpty(Stack s,int Tag);
Stack InitStack(Stack s,int n);
bool push(Stack s,SElemType X,int Tag);
SElemType Pop(Stack s,int Tag);
int main(){
    Stack s=NULL;
    int m,n;
    scanf("%d",&m);
    s=InitStack(s,m);
    bool p;
    p=judeStackEmpty(s,0);
    if(p==EMPTY)
        printf("0 is EMPTY\n");
    if(p==NOTEMPTY)
        printf("0 is NOTEMPTY\n");
    if(p==ERROR)
        printf("Tag is error\n");
    p=judeStackEmpty(s,1);
    if(p==EMPTY)
        printf("1 is EMPTY\n");
    if(p==NOTEMPTY)
        printf("1 is NOTEMPTY\n");
    if(p==ERROR)
        printf("Tag is error\n");
    
    p=judeStackFull(s);
    if(p==FULL)
        printf("FULL\n");
    if(p==NOTFULL)
        printf("NOTFULL\n");
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        p=push(s,i,0);
        if(p==FULL)
            printf("FULL\n");
        else if(p==OK)
            printf("push is OK\n");
        else if(p==ERROR)
            printf("tag is error\n");
    }
    p=judeStackEmpty(s,0);
    if(p==EMPTY)
        printf("0 is EMPTY\n");
    if(p==NOTEMPTY)
        printf("0 is NOTEMPTY\n");
    if(p==ERROR)
        printf("Tag is error\n");
    p=judeStackEmpty(s,1);
    if(p==EMPTY)
        printf("1 is EMPTY\n");
    if(p==NOTEMPTY)
        printf("1 is NOTEMPTY\n");
    if(p==ERROR)
        printf("Tag is error\n");
    
    p=judeStackFull(s);
    if(p==FULL)
        printf("FULL\n");
    if(p==NOTFULL)
        printf("NOTFULL\n");
    int c;
    scanf("%d",&c);
    for(int i=0;i<c;i++){
        p=push(s,i,1);
        if(p==FULL)
            printf("FULL\n");
        else if(p==OK)
            printf("push is OK\n");
        else if(p==ERROR)
            printf("tag is error\n");
    }
    p=judeStackEmpty(s,0);
    if(p==EMPTY)
        printf("0 is EMPTY\n");
    if(p==NOTEMPTY)
        printf("0 is NOTEMPTY\n");
    if(p==ERROR)
        printf("Tag is error\n");
    p=judeStackEmpty(s,1);
    if(p==EMPTY)
        printf("1 is EMPTY\n");
    if(p==NOTEMPTY)
        printf("1 is NOTEMPTY\n");
    if(p==ERROR)
        printf("Tag is error\n");
    
    p=judeStackFull(s);
    if(p==FULL)
        printf("FULL\n");
    if(p==NOTFULL)
        printf("NOTFULL\n");
    
    for(int i=0;i<n;i++){
        SElemType e;
        e=Pop(s,0);
        printf("%d\n",e);
    }
    for(int i=0;i<c;i++){
        SElemType e;
        e=Pop(s,1);
        printf("%d\n",e);
    }
    p=judeStackEmpty(s,0);
    if(p==EMPTY)
        printf("0 is EMPTY\n");
    if(p==NOTEMPTY)
        printf("0 is NOTEMPTY\n");
    if(p==ERROR)
        printf("Tag is error\n");
    p=judeStackEmpty(s,1);
    if(p==EMPTY)
        printf("1 is EMPTY\n");
    if(p==NOTEMPTY)
        printf("1 is NOTEMPTY\n");
    if(p==ERROR)
        printf("Tag is error\n");
    
    p=judeStackFull(s);
    if(p==FULL)
        printf("FULL\n");
    if(p==NOTFULL)
        printf("NOTFULL\n");
        
    
}

bool judeStackFull(Stack s){
    if(s->top[0]+1==s->top[1])
        return FULL;
    return NOTFULL;
}

bool judeStackEmpty(Stack s,int Tag){
    if(Tag==0){
        if(s->top[0]==-1)
            return EMPTY;
        return NOTEMPTY;
    }
    else if(Tag==1){
        if(s->top[1]==s->m)
            return EMPTY;
        return NOTEMPTY;
    }
    else
        return ERROR;
}


Stack InitStack(Stack s,int n){
    s=(Stack)malloc(sizeof(DblStack));
    s->V=(SElemType*)malloc(n*sizeof(SElemType));
    s->top[0]=-1;
    s->top[1]=n;
    s->m=n;
    return s;
}

bool push(Stack s,SElemType X,int Tag){
    if(Tag==0){
        if(s->top[0]+1==s->top[1])
            return FULL;
        s->V[++s->top[0]]=X;
        return OK;
    }
    else if(Tag==1){
        if(s->top[0]+1==s->top[1])
            return FULL;
        s->V[--s->top[1]]=X;
        return OK;
    }
    else
        return ERROR;
}

SElemType Pop(Stack s,int Tag){
    SElemType e;
    if(Tag==0){
        if(s->top[0]==-1)
            return empty;
        e=s->V[s->top[0]--];
        return e;
    }
    else if(Tag==1){
        if(s->top[1]==s->m)
            return empty;
        e=s->V[s->top[1]++];
        return e;
    }
    else
        return error;
}

下面逐个讲解算法：

一，判断空栈

bool judeStackEmpty(Stack s,int Tag){
//Tag表示需要判断哪一个栈，0或者1
    if(Tag==0){
        if(s->top[0]==-1)      //判断0栈，为-1表示空栈返回EMPTY，否者返回NOTEMPTY
            return EMPTY;
        return NOTEMPTY;
    }
    else if(Tag==1){
        if(s->top[1]==s->m)      //判断1栈，为m表示空栈返回EMPTY，否则返回NOTMEMPTY
            return EMPTY;
        return NOTEMPTY;
    }
    else                    //如果Tag既不是0也不是1，返回ERROE
        return ERROR;       
}

二，判断满栈

bool judeStackFull(Stack s){
//判断栈是否已满
    if(s->top[0]+1==s->top[1])  //表明栈已满
        return FULL;            //漫栈就反回FULL
    return NOTFULL;          //否则返回NOTFULL
}

只要顶[0] + 1 =顶[1];

三，栈的初始化

Stack InitStack(Stack s,int n){
//对栈进行初始化
    s=(Stack)malloc(sizeof(DblStack));  //分配内存空间
    s->V=(SElemType*)malloc(n*sizeof(SElemType));  //对数组分配内存空间
    s->top[0]=-1;      //将0栈初始化为空栈
    s->top[1]=n;       //将1栈初始化为空栈
    s->m=n;            //记录下栈最大容量
    return s;
}

初始化栈，需要分配内存空间，对数组分配内存空间。将两个栈初始化为空栈，记录下最大容量。

四，进栈

bool push(Stack s,SElemType X,int Tag){
//将一个元素压入指定的栈中
    if(Tag==0){                
        if(s->top[0]+1==s->top[1])   //判断栈是否已满
            return FULL;
        s->V[++s->top[0]]=X;          //将指针上移一位，数据进栈
        return OK;
    }
    else if(Tag==1){ 
        if(s->top[0]+1==s->top[1])
            return FULL;
        s->V[--s->top[1]]=X;         //将指针下移一位，元素进栈
        return OK;
    }
    else
        return ERROR;    //选择的栈错误
}

1，进展需要先判断是进的哪一个栈

2，然后判断是否已经栈满。

3，进栈：0栈先指针上移一位在将元素进入，1栈先指针下移一位，再将元素进入。

五，出栈

SElemType Pop(Stack s,int Tag){
//将指定的栈顶元素弹出
    SElemType e;
    if(Tag==0){
        if(s->top[0]==-1)     //判断是否为空栈
            return empty;
        e=s->V[s->top[0]--];     //弹出栈顶元素，然后栈顶指针下移一位
        return e;
    }
    else if(Tag==1){
        if(s->top[1]==s->m)     //判断是否为空栈
            return empty; 
        e=s->V[s->top[1]++];     //先将栈顶元素弹出，然后栈顶指针上移一位。      
        return e;
    }
    else
        return error;      //指定的栈错误
}

1，判断哪一个栈

2，判断是否为空栈

3，出栈：0栈：先弹出栈顶元素，然后栈顶指针减一; 1栈：先弹出栈顶元素然后指针加一

小白～

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
在一个数组中实现两个堆栈

题目要求：。将编号为0和1的两个栈放于一个数组空间V [米]中，底栈分别处于数组的两端当第0号栈的栈顶指针顶[0] = - 1时该栈为空;当第1号栈的栈顶指针顶[1] = M时，该栈为空。两个栈从两端向中间增长试编写双栈初始化，判断栈空，栈满，进栈和。。出栈等算法的函数双栈数据结构的定义如下：typedef struct { int top[2],bot[2]; //栈顶和...
复制链接

扫一扫