顺序堆栈和链式堆栈的实现，用一个数组实现两个堆栈的例子

顺序堆栈的实现：

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

#define ERROR -999

typedef int ElementType;
typedef int Position;
typedef struct SNode* PtrToNode;
struct SNode {
    ElementType *Data;    //存储元素的数组
    Position top;        //栈顶指针
    int MaxSize;        //堆栈最大容量
};
typedef PtrToNode Stack;

//生成一个空栈
Stack CreateStack(int MaxSize)
{
    Stack S = (Stack)malloc(sizeof(struct SNode));
    S->Data = (ElementType*)malloc(sizeof(sizeof(struct SNode) * MaxSize));
    S->top = -1;
    S->MaxSize = MaxSize;
    return S;
}

//判断一个栈是否已满
bool IsFull(Stack S)
{
    return S->top == S->MaxSize - 1;
}

//判断一个栈是否为空
bool IsEmpty(Stack S)
{
    return S->top == -1;　　　　//这里我已开始写成了return S->top = -1;所以一直得不到正确结果
}

//压栈,返回是否压栈成功
bool Push(Stack S, ElementType X)
{
    if (IsFull(S))
    {
        printf("The stack is full!
");
        return false;
    }
    else
    {
        S->Data[++(S->top)] = X;
        return true;
    }
}

//出栈，弹栈，返回弹出的元素
ElementType Pop(Stack S)
{
    if (IsEmpty(S))
    {
        printf("The Stack is Empty!
");
        return ERROR;
    }
    else
        return (S->Data[(S->top)--]);
}

刚开始对Pop操作的返回值语句return (S->Data[(S->top)--]);存在一点疑惑，为什么程序已经把S->Data[S->top]返回回去了，
S->top还会执行自减操作（我一直认为后置版本的--运算符执行的操作是，先返回-1前的原值，再原值-1）,事实上这个运算符是先把原值拷贝一份，然后原值-1,
最后返回副本，所以这条返回语句是没有问题的，因为返回副本之前原值就已经-1了

--运算符的重载实现为：

1 ClassA operator -- (int a)        //为了与前置版本相区别，参数列表中加上int a，但是int a在函数体中不起任何作用，只起区分的作用
2 {
3     ClassA copy = *this;
4     --*this;            //先自加
5     return copy;        //再返回前置版本
6 }

链式堆栈的实现：

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

#define ERROR -999

typedef int ElementType;
typedef struct SNode* PtrToSNode;
struct SNode {
    ElementType Data;
    PtrToSNode Next;
};

typedef PtrToSNode Stack;

Stack CreateStack()
{
    Stack S = (Stack)malloc(sizeof(struct SNode));
    S->Next = NULL;
    return S;
}

bool IsEmpty(Stack S)
{
    return (S->Next == NULL);
}

bool Push(Stack S, ElementType X)
{
    PtrToSNode TmpCell;

    TmpCell = (PtrToSNode)malloc(sizeof(struct SNode));
    TmpCell->Data = X;
    TmpCell->Next = S->Next;
    S->Next = TmpCell;
    return true;
}

ElementType Pop(Stack S)
{
    PtrToSNode FirstCell;
    ElementType TopElem;
    if (IsEmpty(S))
    {
        printf("Stack is empty!
");
        return ERROR;
    }
    else
    {
        FirstCell = S->Next;
        TopElem = FirstCell -> Data;
        S->Next = FirstCell->Next;
        free(FirstCell);
        return TopElem;
    }
}

int main()
{
    Stack S = CreateStack();
    Push(S, 3);
    int a = Pop(S);
    printf("%d
", a);
    return 0;

}

用一个数组实现两个堆栈的例子：

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

#define ERROR -999

typedef int ElementType;
typedef int Position;
typedef struct SNode* PtrToNode;
struct SNode {
    ElementType *Data;    //存储元素的数组
    Position top1;        //栈顶指针
    Position top2;
    int MaxSize;        //堆栈最大容量
};
typedef PtrToNode Stack;

//生成一个空栈
Stack CreateStack(int MaxSize)
{
    Stack S = (Stack)malloc(sizeof(struct SNode));
    S->Data = (ElementType*)malloc(sizeof(sizeof(struct SNode) * MaxSize));
    S->top1 = -1;
    S->top2 = MaxSize;
    S->MaxSize = MaxSize;
    return S;
}


//压栈,返回是否压栈成功
bool Push(Stack S, ElementType X, int Tag)
{
    if (S->top2 - S->top1 == 1)
    {
        printf("The stack is full!
");
        return false;
    }
    else
    {
        if (Tag == 1)
            S->Data[++(S->top1)] = X;
        else
            S->Data[--(S->top2)] = X;
        return true;
    }
}

//出栈，弹栈，返回弹出的元素
ElementType Pop(Stack S, int Tag)
{
    if (Tag == 1)
    {
        if (S->top1 == -1)
        {
            printf("The Stack is Empty!
");
            return ERROR;
        }
        else
            return S->Data[(S->top1)--];
    }
    else
    {
        if (S->top2 == S->MaxSize)
        {
            printf("Stack 2 is empty!
");
            return ERROR;
        }
        else
            return S->Data[(S->top2)++];
    }
}


int main()
{
    Stack S = CreateStack(10);
    Push(S, 2, 1);
    int a = Pop(S, 1);
    Push(S, 3, 2);
    int b = Pop(S, 2);
    printf("%d %d
", a, b);
    return 0;
}