用c语言写，根据栈的抽象数据类型的定义，按要求实现一个堆栈的基本功能。 要求 ①实现一个共享栈； ②实现一个链栈。 编写main()函数测试栈或队列的正确性。注释越详细越好

1. 实现一个共享栈

共享栈是指两个栈共享同一段连续的存储空间，它们在空间的两端分别向中间生长。当两个栈的栈顶指针相遇时，表示该共享栈已满。

首先，我们需要定义共享栈的数据结构：

#define MAX_SIZE 10   // 共享栈的最大容量

typedef struct {
    int data[MAX_SIZE];   // 存储数据的数组
    int top1;             // 栈1的栈顶指针
    int top2;             // 栈2的栈顶指针
} SharedStack;

接下来，我们需要实现共享栈的基本操作。

①初始化共享栈：

void initSharedStack(SharedStack *stack) {
    stack->top1 = -1;   // 栈1初始化为空
    stack->top2 = MAX_SIZE;   // 栈2初始化为空
}

②判断共享栈是否为空：

int isSharedStackEmpty(SharedStack stack, int stackNum) {
    if (stackNum == 1) {   // 判断栈1是否为空
        return stack.top1 == -1;
    } else {   // 判断栈2是否为空
        return stack.top2 == MAX_SIZE;
    }
}

③判断共享栈是否已满：

int isSharedStackFull(SharedStack stack) {
    return stack.top1 + 1 == stack.top2;
}

④向共享栈中压入元素：

int pushToSharedStack(SharedStack *stack, int stackNum, int data) {
    if (isSharedStackFull(*stack)) {   // 判断共享栈是否已满
        printf("Error: Shared stack is full.\n");
        return 0;
    }
    if (stackNum == 1) {   // 向栈1中压入元素
        stack->data[++stack->top1] = data;
    } else {   // 向栈2中压入元素
        stack->data[--stack->top2] = data;
    }
    return 1;
}

⑤从共享栈中弹出元素：

int popFromSharedStack(SharedStack *stack, int stackNum) {
    if (isSharedStackEmpty(*stack, stackNum)) {   // 判断共享栈是否为空
        printf("Error: Shared stack is empty.\n");
        return 0;
    }
    int data;
    if (stackNum == 1) {   // 从栈1中弹出元素
        data = stack->data[stack->top1--];
    } else {   // 从栈2中弹出元素
        data = stack->data[stack->top2++];
    }
    return data;
}

2. 实现一个链栈

链栈是指使用链表来实现栈的基本操作。链栈中的各个元素通过一个指针指向下一个元素，最后一个元素指向 NULL。

首先，我们需要定义链栈的数据结构：

typedef struct StackNode {
    int data;   // 存储数据的变量
    struct StackNode *next;   // 指向下一个元素的指针
} StackNode, *Stack;

接下来，我们需要实现链栈的基本操作。

①初始化链栈：

void initStack(Stack *top) {
    *top = NULL;   // 初始化链栈为空
}

②判断链栈是否为空：

int isStackEmpty(Stack top) {
    return top == NULL;
}

③向链栈中压入元素：

int pushToStack(Stack *top, int data) {
    StackNode *node = (StackNode *)malloc(sizeof(StackNode));   // 创建新的节点
    if (node == NULL) {   // 判断内存是否分配成功
        printf("Error: Memory allocation failed.\n");
        return 0;
    }
    node->data = data;   // 将数据存入节点中
    node->next = *top;   // 将新节点插入到链栈的顶部
    *top = node;
    return 1;
}

④从链栈中弹出元素：

int popFromStack(Stack *top) {
    if (isStackEmpty(*top)) {   // 判断链栈是否为空
        printf("Error: Stack is empty.\n");
        return 0;
    }
    int data = (*top)->data;   // 取出链栈顶部的元素
    StackNode *node = *top;
    *top = (*top)->next;
    free(node);   // 释放节点的内存空间
    return data;
}

最后，我们可以编写测试代码来测试共享栈和链栈的正确性。

int main() {
    // 测试共享栈
    SharedStack sharedStack;
    initSharedStack(&sharedStack);
    pushToSharedStack(&sharedStack, 1, 1);
    pushToSharedStack(&sharedStack, 2, 2);
    pushToSharedStack(&sharedStack, 1, 3);
    pushToSharedStack(&sharedStack, 2, 4);
    printf("%d\n", popFromSharedStack(&sharedStack, 2));   // 输出 4
    printf("%d\n", popFromSharedStack(&sharedStack, 1));   // 输出 3
    printf("%d\n", popFromSharedStack(&sharedStack, 2));   // 输出 2
    printf("%d\n", popFromSharedStack(&sharedStack, 1));   // 输出 1

    // 测试链栈
    Stack stack;
    initStack(&stack);
    pushToStack(&stack, 1);
    pushToStack(&stack, 2);
    pushToStack(&stack, 3);
    printf("%d\n", popFromStack(&stack));   // 输出 3
    printf("%d\n", popFromStack(&stack));   // 输出 2
    printf("%d\n", popFromStack(&stack));   // 输出 1

    return 0;
}