数据结构实验4

题目：设计两个栈 S1、S2 都采用顺序栈方式，并且共享一个存储区[0，MaxLen-1]， 为了尽量利用空间，减少溢出的可能，可采用栈顶相向、迎面增长的存储方式，如图 2-1 所示。设计一个有关栈的入栈和出栈算法。

test.h

#include <stdio.h>  
#include <stdlib.h>  
#include <malloc.h>   
typedef struct
{
    DataType stack[MaxLen];
    int top[2];
}SequenStack;
typedef int DataType;
#define INT1 "左端栈的栈顶元素是：%d，右端栈的栈顶元素是:%d\n"
#define INT2 "%5d"
void InitStack(SequenStack *S)
/*共享栈的初始化*/
{
    S->top[0]=0;
    S->top[1]=MaxLen-1;
}
int GetTop(SequenStack S, DataType *e,int flag)   
/*取栈顶元素。将栈顶元素值返回给e，并返回1表示成功；否则返回0表示失败。*/
{
    switch(flag)
    {
    case 1:         /*为1，表示要取左端栈的栈顶元素*/
        if(S.top[0]==0)
            return 0;
        *e=S.stack[S.top[0]-1];
        break;
    case 2:         /*为2，表示要取右端栈的栈顶元素*/
        if(S.top[1]==MaxLen-1)
            return 0;
        *e=S.stack[S.top[1]+1];
        break;
    default:
        return 0;            
    }
    return 1;
}
int PushStack(SequenStack *S,DataType e,int flag)
/*将元素e入共享栈。进栈成功返回1，否则返回0*/
{
    if(S->top[0]==S->top[1]+1)        /*如果共享栈已满*/
        return 0;                 /*返回0，进栈失败*/
    switch(flag)
    {
    case 1:                /*当flag为1，表示将元素进左端的栈*/
        S->stack[S->top[0]]=e;    /*元素进栈*/
        S->top[0]++;            /*修改栈顶指针*/
        break;
    case 2:            /*当flag为2，表示将元素要进右端的栈*/
        S->stack[S->top[1]]=e;    /*元素进栈*/
        S->top[1]--;            /*修改栈顶指针*/
        break;
    default:
        return 0;
    }
    return 1;                     /*返回1，进栈成功*/
}
int PopStack(SequenStack *S,DataType *e,int flag)
{
    switch(flag)             /*在出栈操作之前，判断哪个栈要进行出栈操作*/
    {
    case 1:             /*为1，表示左端的栈需要出栈操作*/
        if(S->top[0]==0)    /*左端的栈为空*/
            return 0;     /*返回0，出栈操作失败*/
        S->top[0]--;        /*修改栈顶指针，元素出栈操作*/
        *e=S->stack[S->top[0]];    /*将出栈的元素赋给e*/
        break;
    case 2:             /*为2，表示右端的栈需要出栈操作*/
        if(S->top[1]==MaxLen-1)    /*右端的栈为空*/
            return 0;             /*返回0，出栈操作失败*/
        S->top[1]++;                /*修改栈顶指针，元素出栈操作*/
        *e=S->stack[S->top[1]];    /*将出栈的元素赋给e*/
        break;
    default:
        return 0;
    }
    return 1; /*返回1，出栈操作成功*/
}
int StackEmpty(SequenStack S,int flag)
/*判断栈是否为空。如果栈为空，返回1；否则，返回0。*/
{
    switch(flag)
    {
    case 1:         /*为1，表示判断左端的栈是否为空*/
        if(S.top[0]==0)
            return 1;
        break;
    case 2:         /*为2，表示判断右端的栈是否为空*/
        if(S.top[1]==MaxLen-1)
            return 1;
        break;
    default:
        printf("输入的flag参数错误!");
        return -1;            
    }
    return 0;
}

test.c

#include<stdio.h>
#include<stdlib.h>
#define MaxLen 15
typedef int DataType;
#define INT1 "左端栈的栈顶元素是：%d，右端栈的栈顶元素是:%d\n"
#define INT2 "%5d"
#include "test.h"        /*包含共享栈的基本类型定义和基本操作实现*/
void main()
{
    SequenStack S;            /*定义一个共享栈*/
    int i;
    DataType a[]={1,2,3,4,5,6,7,8,9,0};
    DataType b[]={10};
    DataType e1,e2;
    InitStack(&S);                    /*初始化共享栈*/
    for(i=0;i<sizeof(a)/sizeof(a[0]);i++)    /*将数组a中元素依次进左端栈*/
    {
        if(PushStack(&S,a[i],1)==0)
        {
            printf("栈已满，不能入栈!");
            return;
        }
    }
    for(i=0;i<sizeof(b)/sizeof(b[0]);i++)    /*将数组b中元素依次进右端栈*/
    {
        if(PushStack(&S,b[i],2)==0)
        {
            printf("栈已满，不能入栈!");
            return;
        }
    }    
    if(GetTop(S,&e1,1)==0)
    {
        printf("栈已空");
        return;
    }
    if(GetTop(S,&e2,2)==0)
    {
        printf("栈已空");
        return;
    }
    printf(INT1,e1,e2);
    printf("左端栈的出栈的元素次序是：");
    
    while(!StackEmpty(S,1))    /*将左端栈元素出栈*/
    {
        PopStack(&S,&e1,1);
        printf(INT2,e1);    
    }
    printf("\n");
    printf("右端栈的出栈的元素次序是：");
    while(!StackEmpty(S,2))    /*将右端栈元素出栈*/
    {
        PopStack(&S,&e2,2);
        printf(INT2,e2);
    }
    printf("\n");    
}