设有两个栈 s1,s2 都采用顺序栈方式，并共享一个存储区[0,..,maxsize-1]，为了尽量 利用空间，减少溢出的可能，可采用栈顶相向，迎面增长的存储方式的代码

### 回答1：
如下:

#define maxsize 100    //假设栈的最大长度为100
typedef struct {
    int data[maxsize];   //存储栈的数组
    int top1;           //栈1的栈顶
    int top2;           //栈2的栈顶
} ShareStack;

//初始化两个栈的栈顶指针
void InitStack(ShareStack &S) {
    S.top1 = -1;
    S.top2 = maxsize;
}

//判断栈1是否为空
bool Stack1Empty(ShareStack S) {
    if(S.top1 == -1) {
        return true;
    } else {
        return false;
    }
}

//判断栈2是否为空
bool Stack2Empty(ShareStack S) {
    if(S.top2 == maxsize) {
        return true;
    } else {
        return false;
    }
}

//入栈操作
bool Push(ShareStack &S, int elem, int stackNumber) {
    if(S.top1 + 1 == S.top2) {  //栈满，不能入栈
        return false;
    }
    if(stackNumber == 1) {      //对栈1进行入栈操作
        S.top1++;          //栈1的栈顶指针加1
        S.data[S.top1] = elem; //将元素elem压入栈1
    } else if(stackNumber == 2) { //对栈2进行入栈操作
        S.top2--;          //栈2的栈顶指针减1
        S.data[S.top2] = elem; //将元素elem压入栈2
    }
    return true;
}

//出栈操作
bool Pop(ShareStack &S, int &elem, int stackNumber) {
    if(stackNumber == 1) {       //从栈1中出栈
        if(Stack1Empty(S)) {
            return false;           //栈空，无法出栈
        }
        elem = S.data[S.top1];   //取出栈1的栈顶元素
        S.top1--;               //栈1的栈顶指针减1
    } else if(stackNumber == 2) { //从栈2中出栈
        if(Stack2Empty(S)) {
            return false;           //栈空，无法出栈
        }
        elem = S.data[S.top2];   //取出栈2的栈顶元素
        S.top2++;               //栈2的栈顶指针加1
    }
    return true;
}

希望能解答您的问题！

### 回答2：
设定两个栈s1和s2的栈顶指针top1和top2，初始值分别为-1和maxsize。

入栈操作：
- 对于栈s1，如果top1+1小于top2，则元素可以入栈，将元素放在top1+1的位置，并将top1加1。
- 对于栈s2，如果top2-1大于top1，则元素可以入栈，将元素放在top2-1的位置，并将top2减1。

出栈操作：
- 对于栈s1，如果top1大于等于0，则可以执行出栈操作，将栈顶元素返回，并将top1减1。
- 对于栈s2，如果top2小于maxsize，则可以执行出栈操作，将栈顶元素返回，并将top2加1。

判断栈空操作：
- 对于栈s1，如果top1等于-1，则栈s1为空。
- 对于栈s2，如果top2等于maxsize，则栈s2为空。

判断栈满操作：
- 如果top1+1等于top2，则栈已满。

通过以上操作，可以实现两个栈的顺序存储，并尽量利用空间，减少溢出的可能。

### 回答3：
首先，需要定义两个栈的结构体:

#define MAXSIZE 300
typedef struct{
    int data[MAXSIZE];
    int top1;
    int top2;
}SharedStack;

其中，data数组用于存储栈的元素，top1和top2分别表示栈1和栈2的栈顶元素位置。接下来定义初始化函数initSharedStack()，这个函数将栈1和栈2的栈顶位置分别初始化为0：

void initSharedStack(SharedStack *stack){
    stack->top1 = 0;
    stack->top2 = MAXSIZE - 1;
}

两个栈共享一个存储区，因此需要定义推入元素的操作push()。当往栈1中推入元素时，栈1的栈顶位置top1递增；当往栈2中推入元素时，栈2的栈顶位置top2递减：

void push(SharedStack *stack, int stackNum, int element){
    if(stackNum == 1){
        if(stack->top1 < stack->top2){
            stack->data[stack->top1++] = element;
        }else{
            printf("栈1已满，无法推入元素\n");
        }
    }else if(stackNum == 2){
        if(stack->top2 > stack->top1){
            stack->data[stack->top2--] = element;
        }else{
            printf("栈2已满，无法推入元素\n");
        }
    }else{
        printf("栈的编号无效\n");
    }
}

最后，定义一个弹出元素的操作pop()。当从栈1弹出元素时，栈1的栈顶位置top1递减，并返回栈顶元素；当从栈2弹出元素时，栈2的栈顶位置top2递增，并返回栈顶元素：

int pop(SharedStack *stack, int stackNum){
    int element;
    if(stackNum == 1){
        if(stack->top1 > 0){
            element = stack->data[--stack->top1];
        }else{
            printf("栈1为空，无法弹出元素\n");
        }
    }else if(stackNum == 2){
        if(stack->top2 < MAXSIZE - 1){
            element = stack->data[++stack->top2];
        }else{
            printf("栈2为空，无法弹出元素\n");
        }
    }else{
        printf("栈的编号无效\n");
    }
    return element;
}

这样，我们就可以使用这两个栈了。使用方法如下：

int main(){
    SharedStack stack;
    initSharedStack(&stack);
    push(&stack, 1, 1); // 向栈1推入元素1
    push(&stack, 2, 2); // 向栈2推入元素2
    int element1 = pop(&stack, 1); // 从栈1弹出元素并存储到element1中
    int element2 = pop(&stack, 2); // 从栈2弹出元素并存储到element2中
    printf("element1 = %d, element2 = %d\n", element1, element2);
    return 0;
}

这样就实现了利用空间的最大化和减少溢出可能性的栈结构。