一个数组实现两个栈（共享栈）（扩容）

  一个数组实现两个栈的具体方法：一个数组实现两个栈（共享栈）但是上述方法的缺陷是数组的大小是恒定的，当数组满的时候就无法进行入栈操作。这篇博客我们将讲一下数组如何扩容？

---

  实现方法：一个数组实现两个栈=====>>下标为0的位置为栈1的栈底，栈2的栈底在下标最大的位置上。栈1向左扩展，栈2向后扩展。若数组已满则增容。

  首先定义一个共享栈的结构体：

#define DataType int 
typedef struct SharedStack
{
    DataType *data;
    int capacity;//容量   
    int top1;
    int top2;   
}sharedstack;

---

共享栈的初始化

//共享栈初始化
void InitShared(sharedstack *s)
{
    assert(s);
    s->capacity = 5;
    s->top1 = 0;
    s->top2 = s->capacity - 1;
    s->data = (DataType *)malloc(s->capacity*sizeof(DataType));
}

---

入栈：
  入栈之前先扩容

void ExpandCapacity(sharedstack *s)
{
    DataType *Newnode = NULL;
    int newcapacity = 0;
    int i = 0;
    if (s->top1 <= s->top2)
    {
        //不用扩容，直接返回
        return ;
    }
    newcapacity = s->capacity * 2;
    Newnode = (DataType*)malloc(newcapacity*sizeof(DataType));
    if (Newnode == NULL)
    {
        printf("新空间开辟失败！\n");
        return ;
    }
    //搬移元素
    for (i = 0; i < s->top1; i++)
    {
        Newnode[i] = s->data[i];
    }

    for (i = s->capacity - 1; i>s->top2; i--)
    {
        Newnode[i+s->capacity]=s->data[i];
    }
    s->top2 = s->top2 + s->capacity;
    s->capacity = newcapacity;

    //释放之前的空间
    free(s->data);
    s->data = Newnode;
}
//入栈
void PushSharedStack(sharedstack *s, DataType d, int which)
{
    assert(s);
    ExpandCapacity(s);
    if (which == 1)
    {
        s->data[s->top1++] = d;
    }
    else
    {
        s->data[s->top2--] = d;
    }
}

• which==1即栈1。
• 为什么重新开辟空间不用realloc？？
  

---

出栈：
  栈1的栈顶-1，栈2的栈顶+1；

void PopSharedStack(sharedstack *s, int which)
{
    assert(s);
    if (which == 1)
    {
        if (s->top1 == 0)
        {
            printf("栈1空！\n");
            return;
        }
        else
        {
            s->top1--;
        }
    }
    else
    {
        if (s->top2 == s->capacity - 1)
        {
            printf("栈2空！\n");
            return;
        }
        else
        {
            s->top2++;
        }
    }
}

---

栈顶元素：

DataType SharedStackTop(sharedstack *s, int which)
{
    assert(s);
    if (which == 1)
    {
        if (s->top1 == 0)
        {
            printf("栈1空！\n");
            return -1;
        }
        else
            return s->data[s->top1 - 1];
    }
    else
    {
        if (s->top2 == s->capacity - 1)
        {
            printf("栈2空！\n");
            return -1;
        }
        else
            return s->data[s->top2 + 1];
    }
}

---

栈元素个数：

int SharedStackSize(sharedstack *s, int which)
{
    assert(s);
    if (which == 1)
    {
        return s->top1;
    }
    else
        return s->capacity - s->top2 - 1;
}

---

                            整体代码：

.h文件

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>

#define DataType int 
typedef struct SharedStack
{
    DataType *data;
    int capacity;//容量   
    int top1;
    int top2;   
}sharedstack;
//共享栈初始化
void InitShared(sharedstack *s);
//栈顶
DataType SharedStackTop(sharedstack *s, int which);
//栈长短
int SharedStackSize(sharedstack *s, int which);
//入栈
void PushSharedStack(sharedstack *s, DataType d, int which);
//出栈
void PopSharedStack(sharedstack *s, int which);

.c文件

#include"share.h"
//共享栈初始化
void InitShared(sharedstack *s)
{
    assert(s);
    s->capacity = 5;
    s->top1 = 0;
    s->top2 = s->capacity - 1;
    s->data = (DataType *)malloc(s->capacity*sizeof(DataType));
}
//扩容
void ExpandCapacity(sharedstack *s)
{
    DataType *Newnode = NULL;
    int newcapacity = 0;
    int i = 0;
    if (s->top1 <= s->top2)
    {
        //不用扩容，直接返回
        return ;
    }
    newcapacity = s->capacity * 2;
    Newnode = (DataType*)malloc(newcapacity*sizeof(DataType));
    if (Newnode == NULL)
    {
        printf("新空间开辟失败！\n");
        return ;
    }
    //搬移栈1元素
    for (i = 0; i < s->top1; i++)
    {
        Newnode[i] = s->data[i];
    }
    //搬移栈2元素
    for (i = s->capacity - 1; i>s->top2; i--)
    {
        Newnode[i+s->capacity]=s->data[i];
    }
    //改变栈2的栈顶和容量
    s->top2 = s->top2 + s->capacity;
    s->capacity = newcapacity;

    //释放之前的空间
    free(s->data);
    s->data = Newnode;
}
//入栈
void PushSharedStack(sharedstack *s, DataType d, int which)
{
    assert(s);
    ExpandCapacity(s);
    if (which == 1)
    {
        s->data[s->top1++] = d;
    }
    else
    {
        s->data[s->top2--] = d;
    }
}
//出栈
void PopSharedStack(sharedstack *s, int which)
{
    assert(s);
    if (which == 1)
    {
        if (s->top1 == 0)
        {
            printf("栈1空！\n");
            return;
        }
        else
        {
            s->top1--;
        }
    }
    else
    {
        if (s->top2 == s->capacity - 1)
        {
            printf("栈2空！\n");
            return;
        }
        else
        {
            s->top2++;
        }
    }
}
//栈顶元素
DataType SharedStackTop(sharedstack *s, int which)
{
    assert(s);
    if (which == 1)
    {
        if (s->top1 == 0)
        {
            printf("栈1空！\n");
            return -1;
        }
        else
            return s->data[s->top1 - 1];
    }
    else
    {
        if (s->top2 == s->capacity - 1)
        {
            printf("栈2空！\n");
            return -1;
        }
        else
            return s->data[s->top2 + 1];
    }
}
//栈长短
int SharedStackSize(sharedstack *s, int which)
{
    assert(s);
    if (which == 1)
    {
        return s->top1;
    }
    else
        return s->capacity - s->top2 - 1;
}

测试文件

#include"share.h"

void TestSharedStack()
{

    sharedstack s;
    //共享栈初始化
    InitShared(&s);

    //栈1入栈
    PushSharedStack(&s, 1, 1);
    PushSharedStack(&s, 2, 1);
    PushSharedStack(&s, 3, 1);
    PushSharedStack(&s, 4, 1);

    //栈2入栈
    PushSharedStack(&s, 5, 2);
    PushSharedStack(&s, 6, 2);
    PushSharedStack(&s, 7, 2);
    PushSharedStack(&s, 8, 2);

    //栈1栈顶
    printf("栈1栈顶=%d\n", SharedStackTop(&s, 1));
    //栈2栈顶
    printf("栈2栈顶=%d\n", SharedStackTop(&s, 2));
    //栈1长短
    printf("栈1长=%d\n", SharedStackSize(&s, 1));
    //栈2长短
    printf("栈2长=%d\n", SharedStackSize(&s, 2));


    //栈1出栈
    PopSharedStack(&s, 1);
    PopSharedStack(&s, 1);
    //栈2出栈
    PopSharedStack(&s, 2);

    //栈1栈顶
    printf("栈1栈顶=%d\n", SharedStackTop(&s, 1));
    //栈2栈顶
    printf("栈2栈顶=%d\n", SharedStackTop(&s, 2));
    //栈1长短
    printf("栈1长=%d\n", SharedStackSize(&s, 1));
    //栈2长短
    printf("栈2长=%d\n", SharedStackSize(&s, 2));
}
int main()
{
    TestSharedStack();
    system("pause");
    return 0;
}

运行结果：