数据结构之栈和队列面试题（4）一个数组实现两个栈

一个数组实现两个栈意思就是共享栈，怎么实现。具体大约有三种方法
方法一： 两个栈从数组的中间开始，分别向数组第一个元素，和数组最后一个元素方向入栈，到达边界就说明栈满了

方法二：两个栈分别从数组的开头和结尾开始向中间，当两个栈相遇，就说明栈满了

方法三：从第零个位置开始偶数是一个栈，奇数是一个栈，当到达数组最后一个元素的时候，说明栈满了

综合上面几个方法，我们可以知道，方法二是最简单的，所以我们采取第二种方法来建立共享栈

下面是具体的代码实现

#pragma once 
#include<stdio.h>
#inlcude<stdlib.h>
#include<stddef.h>
#define MAXSIZE 10000
#define HEADER printf("\n============%s===========\n",__FUCTION__)
typedef char stacktype;
typedef struct sharestack{
    stacktype data[MAXSIZE];//定义一个数组最大值，方便以后修改
    size_t stack1;//定义栈一的指向
    size_t stack2;//第二个栈的指向
}sharestack;
void sharestack1init(sharestack *s);//初始化
void sharestack2init(sharestack *s);
void sharestack1destroy(sharestack *s);//销毁栈
void sharestack2destroy(sharestack *s);
void sharestack1push(sharestack *s);//入栈
void sharestack2push(sharestack *s);
void sharestack1pop(sharestack *s);//出栈
void sharestack2pop(sharestack *s);
int sharestack1top(sharestack *s,stacktype *value);//取栈顶元素
int sharestack2top(sharestack *s,stacktype *value);

做好的相关的工作，就要开始一一实现我们的功能了

初始化函数

#include<stdio.h>
#include"sharestack.h"
void sharestack1init(sharestack *s)
{
    if(s == NULL)
    {
        return;
    }
    s->stack1 = 0;
}
void sharestack2init(sharestack *s)
{
    if(s == NULL)
    {
        return;
    }
    s->stack2 = MAXSIZE;
}

打印函数

void print1(sharestack *s)
{
    if(s == NULL)
    {
        return;
    }
    if(s->stack1 == 0 || s->stack2 == 0)
    {
        return;
    }
    size_t i = 0;
    for(;i < s->stack1;i++)
    {
        printf("%c ",s->data[i]);
    }
    printf("\n");
}
void print2(sharestack *s)
{
    if(s == NULL)
    {
        return;
    }
    if(s->stack2 == MAXSIZE || s->stack1 == MAXSIZE)
    {
        return;
    }
    size_t i = MAXSIZE-1;
    for(;i >= s->stack2;i--）
    {
        printf("%c ",s->data[i]);
    }
    printf("\n");
}

入栈函数

void sharestack1push(sharestack *s,stacktype value)
{
    if(s == NULL)
    {
        return;
    }
    if(s->stack1 >= s->stack2)
    {
        return;
    }
    s->data[s->stack1++] = value;
}
void sharestack2push(sharestack *s,stacktype value)
{
    if(s == NULL)
    {
        return;
    }
    if(s->stack2 <= s->stack1)
    {
        return;
    }
    s->data[--s->stack2] = value;
}

出栈函数

void sharestack1pop(sharestack *s)
{
    if(s == NULL)
    {
        return;
    }
    if(s->stack1 == 0 || s->stack2 == 0)
    {
        return;
    }
    --s->stack1;
}
void sharestack2pop(sharestack *s)
{
    if(s == NULL)
    {
        return;
    }
    if(s->stack2 == MAXSIZE || s->stack1 == MAXSIZE)
    {
        return;
    }
    ++s->stack2;
}

取栈顶元素

int sharestack1top(sharestack *s,stacktype *top)
{
    if(s == NULL || top == NULL)
    {
        return 0;
    }
    if(s->stacl1 == 0 || s->stack2 == 0)
    {
        return 0;
    }
    *top = s->data[s->stack1-1];
    return 1;
}
int sharestack2top(sharestack *s,stacktype *top)
{
    if(s == NULL || top == NULL)
    {
        return 0;
    }
    if(s->stack2 == MAXSIZE || s->stack1 == MAXSIZE)
    {
        return 0;
    }
    *top = s->data[s->stack2];
    return 1;

}

销毁栈

void sharestack1destroy(sharestack *s)
{
    if(s == NULL)
    {
        return;
    }
    s->stack1 = 0;
}
void sharestack2destroy(sharestack *s)
{
    if(s == NULL)
    {
        return;
    }
    s->stack2 = MAXSIZE;
}

下面是测试函数以及结果验证

---

如有错误请指出，谢谢