两个栈共享一个数组空间(P106Q4)

设两个栈共享一个数组空间，试写出两个栈公用的

读栈顶元算法elemtp top_dustack(dustacktp ds;,int i),

进栈操作算法void push_dustack (dustacktp ds, int i, elemt x),

及出栈算法elemtp pop_dustack(dustacktp ds, int i)

 其中i的取值是1或2，用以指示栈号。

代码：

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

typedef int ElementType;
#define FMT "%d"

typedef struct stack {
    ElementType* element; // 储存元素的顺序表
    int maxSize; // 最大储存数量
    int top[2]; // 储存两个栈的栈顶元素位置
}dustacktp;

// 对栈进行初始化
dustacktp* init(dustacktp* ds, int maxSize);
// 读取栈顶元素
ElementType top_dustack(dustacktp* ds, int i);
// 入栈
int push_dustack(dustacktp* ds, int i, ElementType x);
// 出栈
ElementType pop_dustacktp(dustacktp* ds, int i);
// 释放空间
void destory(dustacktp* ds);

// 测试函数
void test(void);


int main(int argc, char const *argv[]) {

    test();

    system("pause");
    return 0;
}


void test(void) {
    dustacktp ds;
    int maxSize = 50;
    init(&ds, maxSize);

    // 对测试的栈进行入栈操作
    // 将10, 20, 30 ...交错入栈
    ElementType t = 10;
    for (int i = 0, flag = 1; i < 100; i++, t += 10, flag = 3 - flag) {
        push_dustack(&ds, flag, t);
    }

    // 对1号栈进行出栈
    while (top_dustack(&ds, 1) != -1)  {
        printf(FMT, pop_dustacktp(&ds, 1));
        if (top_dustack(&ds, 1) != -1) {
            printf(" - ");
        }
    }
    printf("\n");
    
    // 对2号栈进行出栈
    while (top_dustack(&ds, 2) != -1)  {
        printf(FMT, pop_dustacktp(&ds, 2));
        if (top_dustack(&ds, 2) != -1) {
            printf(" - ");
        }
    
    }
    printf("\n");
    
    destory(&ds);
}

dustacktp* init(dustacktp* ds, int maxSize) {
    if ((ds->element = (ElementType*)malloc(sizeof(ElementType) * maxSize)) == NULL) {
        return NULL;
    }
    ds->maxSize = maxSize;
    ds->top[0] = 0;
    ds->top[1] = maxSize - 1;
    return ds;
}

ElementType top_dustack(dustacktp* ds, int i) {
    i--;
    if (i == 0) {
        if (ds->top[0] == 0) {
            return -1;
        }
        return ds->element[ds->top[0] - 1];
    }
    else {
            if (ds->top[1] == ds->maxSize - 1) {
                return -1;
            }
            return ds->element[ds->top[1] + 1];
    }
}

int push_dustack(dustacktp* ds, int i, ElementType x) {
    i--;
    if (ds->top[0] + 1 == ds->top[1]) {
        return -1;
    }
    
    if (i == 0) {
        ds->element[ds->top[0]++] = x;
    }else {
        ds->element[ds->top[1]--] = x;
    }
    return 0;
}

ElementType pop_dustacktp(dustacktp* ds, int i){
    i--;
    if (i == 0) {
        if (ds->top[0] == 0) {
            return -1;
        }
        return ds->element[--ds->top[0]];
    }else {
        if (ds->top[1] == ds->maxSize - 1) {
                return -1;
            }
        return ds->element[++ds->top[1]];
    }
}

void destory(dustacktp* ds) {
    free(ds->element);
}

运行结果：