C语言--栈的链式存储

上篇博客实现了栈的顺序存储，今天来实现栈的链式存储。

上代码：

includes.h：

#ifndef __INCLUDES_H__
#define __INCLUDES_H__

#ifdef __cpluscplus  
extern "C" {  
#endif  
  
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include "chain_stack.h"
#include "test.h"
  
#ifdef __cplusplus  
}  
#endif  

#endif

chain_statck.h：

#ifndef __CHAIN_STACK_H__
#define __CHAIN_STACK_H__

#ifdef __cpluscplus  
extern "C" {  
#endif  

#define STACK_SIZE_MAX   1024
#define EMPTY_STACK_FLAG 0
#define STACK_DATA_ERROR -1
#define STACK_IS_EMPTY   1
#define STACK_NOT_EMPTY  0

struct  stack_node 
{
    //只维护指针域
    struct stack_node *next;
};
//栈的结构体
struct  LStack
{
    struct stack_node pHeader;  //头结点
    int m_size;   //栈的大小
};

typedef void *chain_stack;

//初始化栈
chain_stack init_chain_stack(void);
//入栈
void push_chain_stack(chain_stack stack,void *data);
//出栈
void pop_chain_stack(chain_stack stack);
//获取栈顶元素
void * top_chain_stack(chain_stack stack);
//栈的大小
int size_chain_stack(chain_stack stack);
//判断栈是否为空
int is_empty_chain_stack(chain_stack stack);
//销毁栈
void destroy_chain_stack(chain_stack stack);
  
#ifdef __cplusplus  
}  
#endif  

#endif

chain_statck.c：

#include "includes.h"


//初始化栈
chain_stack init_chain_stack(void)
{
    struct LStack *my_stack = malloc(sizeof(struct LStack));

    if(NULL == my_stack)
    {
        return NULL;
    }

    //头结点指向为空
    my_stack->pHeader.next = NULL;
    //初始化栈的大小
    my_stack->m_size = 0;

    return my_stack;
}
//入栈
void push_chain_stack(chain_stack stack,void *data)
{
    if(NULL == stack)
    {
        return ;
    }

    if(NULL == data)
    {
        return ;
    }

    //入栈就是头插
    struct LStack *my_stack = stack;
    
    //先拿到用户数据的前四个字节
    struct stack_node *my_node = data;
    //入栈
    my_node->next = my_stack->pHeader.next;
    my_stack->pHeader.next = my_node;

    //更新栈的大小
    my_stack->m_size++;   
}
//出栈
void pop_chain_stack(chain_stack stack)
{
    if(NULL == stack)
    {
        return ;
    }

    //如果是空栈，不执行出栈
    struct LStack *my_stack = stack;
    if(my_stack->m_size <= 0)
    {
        return ;
    }
    
    //执行出栈
    //保存第一个有数据的结点（栈顶元素）
    struct stack_node *pFirst = my_stack->pHeader.next;
    my_stack->pHeader.next = pFirst->next;
    //更新栈的大小
    my_stack->m_size--;
}
//获取栈顶元素
void * top_chain_stack(chain_stack stack)
{
    if(NULL == stack)
    {
        return ;
    }

    struct LStack *my_stack = stack;
    //如果是空栈 返回NULL
    if(EMPTY_STACK_FLAG == my_stack->m_size)
    {
        return NULL;
    }

    //将第一个有数据的结点返回
    return my_stack->pHeader.next;
}
//栈的大小
int size_chain_stack(chain_stack stack)
{
    if(NULL == stack)
    {
        return STACK_DATA_ERROR;
    }

    struct LStack *my_stack = stack;

    return my_stack->m_size;
}
//判断栈是否为空
int is_empty_chain_stack(chain_stack stack)
{
    if(NULL == stack)
    {
        return STACK_DATA_ERROR;  //真
    }

    struct LStack *my_stack = stack;
    if(my_stack->m_size <= 0)
    {
        return STACK_IS_EMPTY;    //真
    }
    
    return STACK_NOT_EMPTY;  //返回假，代表不是空栈
}

//销毁栈
void destroy_chain_stack(chain_stack stack)
{
    if(NULL == stack)
    {
        return;
    }

    free(stack);
    stack = NULL;
}

test.h

#ifndef __TESE_H__
#define __TESE_H__

#ifdef __cpluscplus  
extern "C" {  
#endif  

//测试结构体
struct Person
{
    struct stack_node node;
    char name[64];
    int age;
};

//功能测试
void function_test(void);
  
#ifdef __cplusplus  
}  
#endif  

#endif

test.c

#include "includes.h"

void function_test(void)
{ 
    int stack_size;
    //准备出6个person数据
    struct Person p1 ={NULL,"AAA",18};
    struct Person p2 ={NULL,"BBB",20};
    struct Person p3 ={NULL,"CCC",30};
    struct Person p4 ={NULL,"DDD",28};
    struct Person p5 ={NULL,"EEE",43};
    struct Person p6 ={NULL,"FFF",19};

    //初始化栈
    chain_stack stack = init_chain_stack();

    //入栈
    push_chain_stack(stack,&p1);
    push_chain_stack(stack,&p2);
    push_chain_stack(stack,&p3);
    push_chain_stack(stack,&p4);
    push_chain_stack(stack,&p5);
    push_chain_stack(stack,&p6);

    //如果栈不为空 访问栈顶元素并出栈
    while (STACK_NOT_EMPTY == is_empty_chain_stack(stack))
    {
        //栈顶元素
        struct Person *p_top = top_chain_stack(stack);
        printf("栈顶元素：\n 姓名：%s,年龄：%d\n",p_top->name, p_top->age);
    
        //出栈
        pop_chain_stack(stack);
    }

    //当前栈的大小
    stack_size = size_chain_stack(stack);
    printf("栈的大小：%d\n",stack_size);
    
    //销毁栈
    destroy_chain_stack(stack);
}

main.c

#include "includes.h"

//主函数
int main(void)
{
    //功能测试
    function_test();
    
    return 0;
}

运行结果：