数据结构 线性链表栈

#ifndef _MY_LINKSTACK_H_
#define _MY_LINKSTACK_H_

typedef void LinkStack;

//创建链表栈
LinkStack* LinkStack_Create();

//销毁链表栈
int LinkStack_Destroy(LinkStack** stack);

//清空链表栈
int LinkStack_Clear(LinkStack* stack);

//压栈
int LinkStack_Push(LinkStack* stack, void* item);

//出栈
void* LinkStack_Pop(LinkStack* stack);

//获取栈顶元素
void* LinkStack_Top(LinkStack* stack);

//获取栈的大小
int LinkStack_Size(LinkStack* stack);

#endif //_MY_LINKSTACK_H_

//链式栈代码实现
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include"LinkList.h"//调用链表动态库
#include"linkstack.h"

/*
自己构造结构体的必要性
链表栈是调用线性链表动态库实现的  线性链表必须要求结构体中有LinkNode类型的属性
但是用户未必会让自己的结构体带这个属性，必须由栈实现方法里带上
*/
typedef struct _TLinkStack{
    LinkNode node;
    void * item;
}TLinkStack;

//创建链表栈
LinkStack* LinkStack_Create(){
    return (LinkStack*)LinkList_Create();
}

//销毁链表栈
int LinkStack_Destroy(LinkStack** stack){
    int ERRO_MSG = 0;
    /*
    删除的时候，先清空链表，然后再删除
    */
    ERRO_MSG=LinkStack_Clear(*stack);
    //销毁链表
    ERRO_MSG = LinkList_Destroy(stack);
    return ERRO_MSG;
}

//清空链表栈
/*
因为TLinkStack是我们帮用户创建的，不是用户自己的结构体，所以用户不可能会释放，只能由我们来实现

必须循环遍历  一个个的删除
*/
int LinkStack_Clear(LinkStack* stack){
    int ERRO_MSG = 0;
    while (LinkList_Length(stack)){
        //一个个删除元素  从第一个开始删除  减少遍历次数
        TLinkStack * temp = (TLinkStack *)LinkList_Delete(stack, 0);
        if (temp!=NULL)
        {
            free(temp);
            temp = NULL;
        }
    }
    //将元素个数置零
    ERRO_MSG = LinkList_Clear(stack);
    return ERRO_MSG;
}

//压栈
/*
对于链表而言，从尾部插入，需要遍历前面的所有节点，还是从头结点插入比较效率
*/
int LinkStack_Push(LinkStack* stack, void* item){
    int ERRO_MSG = 0;
    //临时变量必须malloc
    TLinkStack * tstack = (TLinkStack *)malloc(sizeof(TLinkStack));
    if (tstack==NULL)
    {
        ERRO_MSG = -1;
        printf("分配内存失败！erro msg:%d \n", ERRO_MSG);
        return ERRO_MSG;
    }
    //初始化内存
    memset(tstack, 0, sizeof(TLinkStack));
    //将用户数据赋值到内存中
    tstack->item = item;
    //用头插法插入元素
    ERRO_MSG=LinkList_Insert(stack, (LinkNode *)tstack, 0);
    return ERRO_MSG;
}

//出栈
void* LinkStack_Pop(LinkStack* stack){
    //删除栈顶元素
    TLinkStack *tstack = (TLinkStack *)LinkList_Delete(stack, 0);
    //定义返回变量
    void * ret = NULL;
    if (tstack!=NULL)
    {
        ret = tstack->item;
        free(tstack);
        tstack = NULL;
    }
    return ret;
}

//获取栈顶元素
void* LinkStack_Top(LinkStack* stack){
    //定义返回变量
    void * ret = NULL;
    //获取第0个节点元素
    TLinkStack *tstack = (TLinkStack *)LinkList_Get(stack, 0);
    if (tstack!=NULL)
    {
        ret = tstack->item;
    }
    return ret;
}

//获取栈的大小
int LinkStack_Size(LinkStack* stack){
    return LinkList_Length(stack);
}

//链表栈的测试代码
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include"linkstack.h"

typedef struct _Student{
    char name[30];
    int age;
}Student;

void Test(){
    Student s1, s2, s3, s4, s5;
    int numx = 0, i = 0, ret = 0;
    strcpy(s1.name, "小米");
    s1.age = 11;
    strcpy(s2.name, "小刚");
    s2.age = 12;
    strcpy(s3.name, "小红");
    s3.age = 10;
    strcpy(s4.name, "啸天");
    s4.age = 13;
    strcpy(s5.name, "莲华");
    s5.age = 12;
    LinkStack *stack = NULL;
    //创建栈
    stack = LinkStack_Create();
    //压栈
    ret = LinkStack_Push(stack, &s1);
    if (ret != 0)
    {
        printf("入栈失败！\n");
        return;
    }
    ret = LinkStack_Push(stack, &s2);
    if (ret != 0)
    {
        printf("入栈失败！\n");
        return;
    }
    ret = LinkStack_Push(stack, &s3);
    if (ret != 0)
    {
        printf("入栈失败！\n");
        return;
    }
    ret = LinkStack_Push(stack, &s4);
    if (ret != 0)
    {
        printf("入栈失败！\n");
        return;
    }
    ret = LinkStack_Push(stack, &s5);
    if (ret != 0)
    {
        printf("入栈失败！\n");
        return;
    }
    numx = LinkStack_Size(stack);
    //出栈
    for (i = 0; i < numx; i++)
    {
        Student *temp = (Student *)LinkStack_Pop(stack);
        printf("我的名字是%s；我的年龄是%d\n", temp->name, temp->age);
    }
    //清空栈
    ret = LinkStack_Clear(stack);
    if (ret != 0)
    {
        printf("销毁链表失败！\n");
        return;
    }
    //销毁栈
    LinkStack_Destroy(&stack);
}



void main(){
    Test();
    system("pause");
}