栈(Stack) C 语言实现

栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

一、栈的数组实现

栈的顺序存储结构通常由一个一维数组和一个记录栈顶元素位置的变量组成。

//堆栈的数组实现
#include 
#include 

#define ElementType int //存储数据元素的类型
#define MAXSIZE 1024 //存储数据元素的最大个数
#define ERROR -99 //ElementType的特殊值，标志错误

//堆栈的顺序存储结构通常由一个一维数组和一个记录栈顶元素位置的变量组成
typedef struct {
    ElementType data[MAXSIZE];
    int top;
}Stack;

//初始化栈
Stack* InitStack() {
    Stack* stack;
    stack = (Stack*)malloc(sizeof(Stack));
    if (!stack) {
        printf("空间不足\n");
        return NULL;
    }
    stack->top = -1;
    return stack;
}

int IsFull(Stack* stack) {
    if (stack->top == MAXSIZE - 1) {
        printf("堆栈已满\n");
        return 1;
    }
    return 0;
}

int IsEmpty(Stack* stack) {
    if (stack->top == -1) {
        printf("堆栈空\n");
        return 1;
    }
    return 0;
}

//入栈
void Push(Stack* stack, ElementType item) {
    if (IsFull(stack)) {
        return;
    }
    stack->data[++stack->top] = item;
}

//出栈
ElementType Pop(Stack* stack) {
    if (IsEmpty(stack)) {
        return ERROR;
    }
    return stack->data[stack->top--];
}

void PrintStack(Stack* stack) {
    printf("当前栈中的元素:\n");
    int i;
    for (i = stack->top; i >= 0; i--) {
        printf("%d\n", stack->data[i]);
    }
}


int main(int argc, const char * argv[]) {
    Stack* stack;
    stack = InitStack();
 
    Push(stack, 1);
    Push(stack, 2);
    Push(stack, 3);
    Push(stack, 4);
    Push(stack, 5);
    
    PrintStack(stack);
    
    Pop(stack);
    Pop(stack);
    
    PrintStack(stack);
    
    return 0;
}

二、栈的链表实现

栈的链式存储结构实际上就是一个单链表，叫做链栈，插入和删除操作只能在链栈的栈顶进行。那栈顶指针Top应该在链表的哪一头？我们要做插入删除操作，很显然在链头是方便操作的。

#include 
#include 

#define ElementType int
#define ERROR -99

typedef struct Node {
    ElementType data;
    struct Node* next;
}LinkStack;

//初始化堆栈
LinkStack* InitLinkStack() {
    LinkStack* s;
    s = (LinkStack*)malloc(sizeof(LinkStack));
    if (!s) {
        printf("空间不足\n");
    }
    s->next = NULL;
    return s;
}

int IsEmpty(LinkStack* s) {
    return (s->next == NULL);
}

void Push(LinkStack* s, ElementType data) {
    LinkStack* cell;
    cell = (LinkStack*)malloc(sizeof(LinkStack));
    if (!cell) {
        printf("空间不足\n");
    }
    cell->data = data;
    cell->next = s->next;
    s->next = cell;
}

ElementType Pop(LinkStack* s) {
    LinkStack* firstCell;
    ElementType topData;
    if (IsEmpty(s)) {
        printf("空栈\n");
        return ERROR;
    }
    firstCell = s->next;
    s->next = firstCell->next;
    topData = firstCell->data;
    free(firstCell);
    return topData;
}

void PrintLinkStack(LinkStack* s) {
    printf("当前栈中的元素:\n");
    LinkStack* p;
    p = s;
    while (p->next != NULL) {
        p = p->next;
        printf("%d\n",p->data);
    }
}

int main(int argc, const char * argv[]) {
    LinkStack* s;
    s = InitLinkStack();
    Pop(s);
    
    Push(s, 1);
    Push(s, 2);
    Push(s, 3);
    Push(s, 4);
    Push(s, 5);
    
    PrintLinkStack(s);
    
    Pop(s);
    Pop(s);
    
    PrintLinkStack(s);
    
    return 0;
}