堆栈的三种实现方式

#define STACK_TYPE int //堆栈存储的值的类型

//入栈
void push(STACK_TYPE value);

//出栈
void pop(void);

//访问栈顶元素
STACK_TYPE top(void);

//判断是否栈空
int is_empty(void);

//判断是否栈满
int is_full(void);

#include "stack.h"
#include <assert.h>  //包含了 assert宏

#define STACK_SIZE 100  //堆栈中所存元素的最大数量

static STACK_TYPE stack[STACK_SIZE];//堆栈数组
static top_element = -1;  //栈顶元素标识
//定义为static 使其只能在声明它们的源文件中被访问

//入栈push
void push(STACK_TYPE value){
        //栈满则不能再入栈，首先要判断是否栈满  
        assert(!is_full());  //assert宏，对表达式参数测试，若值为假，则打印错误信息并终止程序
        top_element +=1;
        stack[top_element] = value;  
}

//出栈pop
void pop(void){
        //栈空则不能再出栈，首先要判断是否栈空
        assert(!is_empty());
        top_element -=1;  
}

//访问栈顶元素top
STACK_TYPE top(void){
        assert(!is_empty());
        return stack[top_element];
}

//判断是否栈满is_full
int is_full(void){
        return top_element == STACK_SIZE-1;
}

//判断是否栈空is_empty
int is_empty(void){
        return top_element == -1;
}

#include "stack.h"
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <assert.h>

static STACK_TYPE *stack;//堆栈指针
static size_t static_size; //保存堆栈可容纳元素个数的变量 stack_size 存储于全局存储区BSS段，将被初始化为0
static int top_element = -1;//栈顶元素标识

//创建堆栈的函数create_stack
void create_stack(size_t size){
        assert(stack_size == 0); //若stack_size!=0则说明堆栈已经创建
        stack_size = size;  //size为堆栈可容纳元素的个数
        stack = malloc(stack_size * sizeof(STACK_TYPE));
        assert(stack != NULL);//检验堆栈是否成功创建
}

//销毁堆栈destroy_stack
void destroy_stack(void){
        assert(stack_size > 0);
        stack_size = 0;
        free(stack);   //销毁堆栈，防止内存泄露
        stack = NULL;
}

//push
void push(STACK_TYPE value){
        assert(!is_full());
        top_element +=1;
        stack[top_element] = value;
}

//pop
void pop(void){
        assert(!is_empty());
        top_element -=1;
}

//top
STACK_TYPE top(void){
        assert(!is_empty());
        return stack[top_element];
}

//is_full
int is_full(void){
        assert(stack_size > 0);
        return top_element == stack_size-1;
}

//is_empty
int is_empty(void){
        assert(stack_size > 0);
        return top_element == -1;
}

#include "stack.h"
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <assert.h>

#define FALSE 0

//定义链表节点，用于存储堆栈元素
typedef struct STACK_NODE{
        STACK_TYPE value;
        struct STACK_NODE *next;
}StackNode;

//指向堆栈第一个节点的指针
static StackNode *stack;

//用于清空堆栈的函数，防止内存泄露
void destroy_stack(void){
        while(!is_empty())
                pop();
}

//push
void push(STACK_TYPE value){
        StackNode *new_node;
        new_node = malloc(sizeof(StackNode));
        new_node->value = value;
        new_node->next = stack;
        stack = new_node;
}

//pop
void pop(void){
        StackNode *delete_node;
        assert(!is_empty());
        delete_node = stack;
        stack = stack->next;
        free(delete_node);
}

//top
Stack_TYPE top(void){
        assert(!is_empty());
        return stack->value;
}

//is_full
int is_full(void){
        return FALSEE; //堆栈长度除受内影响外，没有长度限制
}

//is_empty
int is_empty(void){
        return stack == NULL;
}