基于链式链表的栈链式存储的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) > )
     {
         LinkStack_Pop(stack);
     }
     return;
 }
 //入栈 == 向链表头插入元素
 int LinkStack_Push(LinkStack* stack, void* item)
 {
     int ret = ;
     //先定义一个临时LinkStackNode指针变量temp
     LinkStackNode* temp = NULL;
     //现在是想存储temp的
     //为了防止函数结束时temp被析构必须分配内存
     temp = (LinkStackNode*)malloc(sizeof(LinkStackNode));
     //异常处理
     if (temp == NULL)
     {
         cout << "Push Temp Err" << endl;
         return -;
     }
     memset(temp, , sizeof(LinkStackNode));
     //将item 也就是所需要存储的信息传递给temp->item
     temp->item = item;
     //现在可以直接插入
     ret = LinkList_Insert(stack, (LinkListNode*)temp, );
     //异常处理
     if (ret != )
     {
         cout << "Fucn Insert Err" << endl;
         //为了防止内存插入失败而导致内存泄漏
         if (temp != NULL)
         {
             free(temp);
         }
         return -;
     }
     return ;
 }
 //出栈
 void* LinkStack_Pop(LinkStack* stack)
 {
     //定义一个中间缓存
     void* item = NULL;
     LinkStackNode* _temp = NULL; //定义一个框架
     _temp = (LinkStackNode*)LinkList_Delete(stack, );
     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, );
     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 = ;
     int a[];

     LinkStack* stack = NULL;
     stack = LinkStack_Create();
     if(stack == NULL)
     {
         return -;
     }
     //入栈
     for (i = ; i <  ; i++)
     {
         a[i] = i + ;
         LinkStack_Push(stack, &a[i]);
     }
     //显示大小和栈顶元素
     cout << "Size: " << LinkStack_GetSize(stack) << endl;

     cout << "Top: "  << *((int *)LinkStack_GetTop(stack)) << endl;

     //出栈
     while(LinkStack_GetSize(stack) != )
     {
         cout << "Pop: "  << *((int *)LinkStack_Pop(stack)) << endl;
     }
     //入栈
     LinkStack_Push(stack, &a[]);
     cout << "Size: " << LinkStack_GetSize(stack) << endl;
     //清空
     LinkStack_Clear(stack);
     cout << "After Clear Size: " << LinkStack_GetSize(stack) << endl;
     //删除一个栈
     LinkStack_Destroy(stack);

     system("pause");
     return ;
 }