共享栈

1.静态共享栈

2.奇偶共享栈

SharedStack.h

#pragma once
#include"Stack.h"
//静态共享栈
#define MaxSize 100
typedef struct SharedStack
{
    DataType data[MaxSize];/*数组长度*/
    int top1;/*栈顶1*/
    int top2;/*栈顶2*/
}SharedStack;
void SharedStackInit(SharedStack *s);
void SharedStackPush(SharedStack *s, DataType x, int StackNumber);/*把元素x压入编号为StackNumber的栈中*/
void SharedStackPop(SharedStack *s, int StackNumber);
//////////////////////////////////////////////////
//奇偶共享栈
typedef struct ShareStack_T
{
    DataType* JOUShareStack;
    int capacity;//当前已分配的存储空间大小，以元素为单位
    int top1;/*栈顶1，从0开始*/
    int top2;/*栈顶2，从1开始*/
}ShareStack_T;
void ShareStack_TInit(ShareStack_T *s);
void ShareStack_TDestory(ShareStack_T * s, int StackNumber);
void AddcapacityShareStack_T(ShareStack_T *s);
void ShareStack_TPush(ShareStack_T *s, DataType x, int StackNumber);
void ShareStack_TPop(ShareStack_T *s, int StackNumber);
DataType ShareStack_TTop(ShareStack_T *s, int StackNumber);
void ShareStack_TEmpty(ShareStack_T *s, int StackNumber);

SharedStack.c

#include "SharedStack.h"

void SharedStackInit(SharedStack * s)
{
    assert(s);
    s->top1 = -1;
    s->top2 = MaxSize;
}

void SharedStackPush(SharedStack * s, DataType x, int StackNumber)
{
    assert(s && StackNumber == 1 || StackNumber == 2);
    if (s->top1 == s->top2)/*共享栈满*/
    {
        return FALSE;
    }
    switch (StackNumber)
    {
    case 1:
        s->data[++s->top1] = x;
        break;
    case 2:
        s->data[--s->top2] = x;
        break;
    }
}

void SharedStackPop(SharedStack * s, int StackNumber)
{
    assert(s);
    if (StackNumber == 1)
    {
        if(s->top1==0)/*栈1空*/
        { 
            return FALSE;
        }
        else
        {
            s->top1--;
        }
    }
    else if(StackNumber == 2)
    {
        if (s->top2 == 0)/*栈2空*/
        {
            return FALSE;
        }
        else
        {
            s->top2++;
        }
    }
}
//////////////////////////////////////////////////////////
void ShareStack_TInit(ShareStack_T * s)
{
    assert(s);
    s->JOUShareStack = (DataType*)malloc(sizeof(DataType *)*STACK_INIT_SIZE);
    s->capacity = STACK_INIT_SIZE;
    s->top1 = -2;
    s->top2 = -1;
}
void ShareStack_TDestory(ShareStack_T * s, int StackNumber)
{
    assert(s&&StackNumber == 1 || StackNumber == 2);
    if (StackNumber == 1)
    {
        s->top1 = -2;
        if (s->top2 == -1)
        {
            free(s->JOUShareStack);
            s->JOUShareStack = NULL;
        }
    }
    else
    {
        s->top2 = -1;
        if (s->top1 == -2)
        {
            free(s->JOUShareStack);
            s->JOUShareStack = NULL;
        }
    }
}
void AddcapacityShareStack_T(ShareStack_T * s)
{
    assert(s);
    s->JOUShareStack = (DataType *)realloc(s->capacity, sizeof(DataType)*(s->capacity + STACKINCREMENT));
    if (s->JOUShareStack == NULL)/*追加空间失败*/
    {
        return FALSE;
    }
    s->capacity = s->capacity + STACKINCREMENT;/*新空间的容量*/
}

void ShareStack_TPush(ShareStack_T * s, DataType x, int StackNumber)
{
    assert(s && StackNumber == 1 || StackNumber == 2);
    if (StackNumber == 1)
    {
        if (s->top1 < s->capacity)
        {
            s->top1 += 2;
            s->JOUShareStack[s->top1] = x;
        }
        return FALSE;
    }
    else
    {
        if (s->top2 < s->capacity)
        {
            s->top2 += 2;
            s->JOUShareStack[s->top2] = x;
        }
        return FALSE;
    }
}

void ShareStack_TPop(ShareStack_T * s, int StackNumber)
{
    assert(s && StackNumber == 1 || StackNumber == 2);
    if (StackNumber == 1)
    {
        if (s->top1 == -2)/*栈1空*/
        {
            return FALSE;
        }
        s->top1 -= 2;
    }
    else
    {
        if (s->top2 == -1)/*栈2空*/
        {
            return FALSE;
        }
        s->top2 -= 2;
    }
}

DataType ShareStack_TTop(ShareStack_T * s, int StackNumber)
{
    assert(s && StackNumber == 1 || StackNumber == 2);
    if (StackNumber == 1)
    {
        return s->JOUShareStack[s->top1];
    }
    else
    {
        return s->JOUShareStack[s->top2];
    }
}

void ShareStack_TEmpty(ShareStack_T * s, int StackNumber)
{
    /*如果栈空返回FALSE，否则返回栈顶元素*/
    assert(s && StackNumber == 1 || StackNumber == 2);
    if (StackNumber == 1)
    {
        if (s->top1 == -2)
        {
            return FALSE;
        }
        else
        {
            return s->JOUShareStack[s->top1];
        }
    }
    else
    {
        if (s->top2 == -1)
        {
            return FALSE;
        }
        else
        {
            return s->JOUShareStack[s->top2];
        }
    }
}