基于链式链表的栈链式存储的C风格实现

链式链表的头文件与CPP文件见前文

头文件：

#ifndef _LINKSTACK_H_
#define _LINKSTACK_H_
 
 
typedef void LinkStack;
//创建一个栈
LinkStack* LinkStack_Create();
//删除一个栈
void LinkStack_Destroy(LinkStack* stack);
//清空一个栈
void LinkStack_Clear(LinkStack* stack);
//入栈
int LinkStack_Push(LinkStack* stack, void* item);
//出栈
void* LinkStack_Pop(LinkStack* stack);
//获取栈顶元素
void* LinkStack_GetTop(LinkStack* stack);
//获取栈的长度
int LinkStack_GetSize(LinkStack* stack);
 
 
 
#endif

CPP文件：

#include "linkList.h"
#include "linkStack.h"
#include <iostream>
 
//
//需要调用前边的LinkList.H
//
using namespace std;
//定义一个抽象的栈节点模型 
//也就是用链式链表的抽象模型来存储item 以便插入元素
//就像
//struct TEMP
//{
//    LinkListNode node;
//    int a;
//    char b;
//    float c;
//    ......
//    这样的数据结构
//};
typedef struct _tag_LinkstackNode
{
    LinkListNode node;
    void* item;
 
}LinkStackNode;
 
//创建一个栈  相当于创建一个线性表
LinkStack* LinkStack_Create()
{
    return LinkList_Create();
}
//删除一个栈 相当于删除一个线性表
//先清空一个栈 再删除一个链表
void LinkStack_Destroy(LinkStack* stack)
{
    LinkStack_Clear(stack);
    LinkList_Destory(stack);
    return;
}
//清空一个栈  相当于清空一个线性表
//注意元素都是动态分配的内存
//应该先把所有元素弹出，并释放节点内存
void LinkStack_Clear(LinkStack* stack)
{
    if (stack == NULL)
    {
        return;
    }
    while(LinkStack_GetSize(stack) > 0)
    {
        LinkStack_Pop(stack);  
    }
    return;
}
//入栈 == 向链表头插入元素
int LinkStack_Push(LinkStack* stack, void* item)
{
    int ret = 0;
    //先定义一个临时LinkStackNode指针变量temp
    LinkStackNode* temp = NULL;
    //现在是想存储temp的
    //为了防止函数结束时temp被析构必须分配内存
    temp = (LinkStackNode*)malloc(sizeof(LinkStackNode));
    //异常处理
    if (temp == NULL)
    {
        cout << "Push Temp Err" << endl;
        return -1;
    }
    memset(temp, 0, sizeof(LinkStackNode));
    //将item 也就是所需要存储的信息传递给temp->item
    temp->item = item;
    //现在可以直接插入
    ret = LinkList_Insert(stack, (LinkListNode*)temp, 0);
    //异常处理
    if (ret != 0)
    {
        cout << "Fucn Insert Err" << endl;
        //为了防止内存插入失败而导致内存泄漏
        if (temp != NULL)
        {
            free(temp);
        }
        return -2;
    }
    return 0;
}
//出栈
void* LinkStack_Pop(LinkStack* stack)
{
    //定义一个中间缓存
    void* item = NULL;
    LinkStackNode* _temp = NULL; //定义一个框架
    _temp = (LinkStackNode*)LinkList_Delete(stack, 0);
    if (_temp == NULL)
    {
        return NULL;
    }
 
    item = _temp->item ;
    //因为插入时已经分配了内存
    //因此出栈时需要释放，
    free(_temp);
    return item;
}
//获取栈顶元素
void* LinkStack_GetTop(LinkStack* stack)
{
    LinkStackNode* temp = NULL; //定义一个框架
    temp = (LinkStackNode*)LinkList_Get(stack, 0);
    if (temp == NULL)
    {
        cout << "GetTOP ERR (temp = NULL) " << endl;
        return NULL;
    }
    return temp->item;
}
//获取栈的长度
int LinkStack_GetSize(LinkStack* stack)
{
    return LinkList_Length(stack);
}
 
 

测试函数：

#include <iostream>
#include "linkStack.h"
using namespace std;
 
 
int main ()
{
    int i = 0;
    int a[10];
 
    LinkStack* stack = NULL;
    stack = LinkStack_Create();
    if(stack == NULL)
    {
        return -1;
    }
    //入栈
    for (i = 0; i < 5 ; i++)
    {
        a[i] = i + 1;
        LinkStack_Push(stack, &a[i]);
    }
    //显示大小和栈顶元素
    cout << "Size: " << LinkStack_GetSize(stack) << endl;
 
    cout << "Top: "  << *((int *)LinkStack_GetTop(stack)) << endl;
 
    //出栈
    while(LinkStack_GetSize(stack) != 0)
    {
        cout << "Pop: "  << *((int *)LinkStack_Pop(stack)) << endl;
    }
    //入栈
    LinkStack_Push(stack, &a[1]);
    cout << "Size: " << LinkStack_GetSize(stack) << endl;
    //清空
    LinkStack_Clear(stack);
    cout << "After Clear Size: " << LinkStack_GetSize(stack) << endl;
    //删除一个栈
    LinkStack_Destroy(stack);
 
    system("pause");
    return 0;
}