堆栈——C语言（链表）

想必你已经看完了我写的堆栈的数组版本，接下来，就好好看看链表怎么实现堆栈吧

1.首先定义一个堆栈接口（stack.h）

/*
** 一个堆栈模块的接口
*/
#include <stddef.h>

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

/*
** push
** 把一个新值压入堆栈中，它的参数是被压入的值。
*/
void push(STACK_TYPE value);

/*
** pop
** 从堆栈中弹出一个值，并将之返回
*/
STACK_TYPE pop(void);

/*
** top
** 返回堆栈顶部元素的值，但不对堆栈进行修改
*/
STACK_TYPE top(void);

/*
** is_empty
** 如果堆栈为空，返回TURE,否则返回FLASE
*/
int is_empty(void);

/*
** is_full
** 如果堆栈已满，返回TURE,否则返回FLASE
*/
int is_full(void);

/*
** len
** 返回堆栈已存储元素个数
*/
int len(void);

/*
** ---------------------接下来声明动态数组堆栈(链表堆栈)部分---------------------------
*/

/*
** create_stack
** 创建堆栈，参数指定堆栈可以保存多少元素
** 注意：这个函数并不用于静态数组版本的堆栈，链表实现用不到这个函数
*/
void create_stack(size_t size);

/*
** destroy_stack
** 摧毁堆栈，释放堆栈所使用的内存
** 注意：这个函数并不用于静态数组版本的堆栈
*/
void destroy_stack(void);

2.在另外一个文件（l_stack.c）中实现具体函数操作

/*
** 一个用链表实现的堆栈，这个堆栈没有长度限制
*/
#include "stack.h"
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <assert.h>

#define False 0

/*
** 定义一个结构存储堆栈元素，其中next指向堆栈下一个元素
** 注意：结构体数据类型的成员可以是自身，但只能是指针类型
** 因为指针的大小可以确定，如果不是用的指针（把*去掉），
** 编译器就不知道这个结构体数据有多大（无限套娃），就会报错
*/
typedef struct STACK_NODE{
    STACK_TYPE value;
    struct STACK_NODE *next;
}StackNode;

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

/*
** create_stack没用
*/

/*
** destroy_stack
*/
void destroy_stack(void){
    // while( !is_empty() ){
    //     pop();
    // }
    stack = NULL;
}

/*
** push
*/
void push(STACK_TYPE value){
    StackNode *new_node;
    new_node = malloc(sizeof(StackNode));
    assert(new_node != NULL);
    new_node->value = value; //箭头"->"访问操作符的左边只能为指向结构体的指针
    new_node->next = stack;
    stack = new_node;
}

/*
** pop
*/
STACK_TYPE pop(void){
    StackNode *first_node;
    assert( !is_empty() );
    first_node = stack;
    stack = first_node->next;
    return first_node->value;
}

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

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

/*
** is_full
*/
int is_full(void){
    return False;
}

/*
** len
*/
int len(void){
    if(is_empty()){
        return 0;
    }
    else{
        int i = 0;
        StackNode *find_node;
        find_node = stack;
        do{
            i++;
            find_node = find_node->next;
        }while(find_node != NULL);
        return i;
    }
}

3.最后编写一个主函数（l_main.c）测试堆栈操作

#include "l_stack.c"

#define T "True"
#define F "False"

int main(){
    push(6);
    push(3);
    push(2);
    push(4);
    push(5);
    printf("栈顶元素为：%d\n",top());
    printf("堆栈为空吗？%s\n",is_empty()?T:F);
    printf("堆栈为满吗？%s\n",is_full()?T:F);
    printf("堆栈现在存储了%d个值\n",len());
    printf("堆栈弹出了%d\n",pop());
    printf("堆栈现在存储了%d个值",len());
    return 0;
}

控制台输出：

栈顶元素为：5
堆栈为空吗？False  
堆栈为满吗？False  
堆栈现在存储了5个值
堆栈弹出了5        
堆栈现在存储了4个值

总结：至此，我已经用静态数组，动态数组，链表共3种方法实现了堆栈，如有不对的地方，欢迎大家指点一二，强烈安利大家去看《C与指针》这本书，很牛逼的。