数据结构：链式栈

听了国嵌唐老师的课，用C语言实现如下：

LinkList.c

#include <stdio.h>
#include <malloc.h>
#include "LinkList.h"

typedef struct _tag_LinkList
{
  LinkListNode header;
  int length;
}TLinkList;

LinkList* LinkList_Create()
{
  TLinkList* ret = (TLinkList*)malloc(sizeof(TLinkList));
  
  if(ret != NULL)
  {
    ret->length = 0;
    ret->header.next = NULL;
  }
  
  return ret;
}

void LinkList_Destory(LinkList* list)
{
  free(list);
}

void LinkList_Clear(LinkList* list)
{
  TLinkList* sList = (TLinkList*)list;
  
  if(sList !=NULL)
  {
    sList->length = 0;
    sList->header.next = NULL;
  }
}

int LinkList_Length(LinkList* list)
{
  TLinkList* sList = (TLinkList*)list;
  int ret = -1;
  
  if(sList !=NULL)
  {
    ret = sList->length;
  }
  
  return ret;
}

int LinkList_Insert(LinkList* list,LinkListNode* node,int pos)
{
  TLinkList* sList = (TLinkList*)list;
  int ret = (sList != NULL) && (pos>=0) && (node !=NULL);
  int i = 0;
  if(ret)
  {
    LinkListNode* current = (LinkListNode*)sList;
    
    for(i=0;(i<pos)&&(current->next !=NULL);i++)
    {
      current = current->next;
    }
    
    node->next = current->next;//头插法（打印逆序） 
    current->next = node;
    
    sList->length++;
  } 
  
  return ret;
}

LinkListNode* LinkList_Get(LinkList* list,int pos)
{
  TLinkList* sList = (TLinkList*)list;
  LinkListNode* ret = NULL;
  int i = 0;
  
  if((sList != NULL) && (pos>=0) && (pos<sList->length))
  {
    LinkListNode* current = (LinkListNode*)sList;
    
    for(i = 0;i<pos;i++)
    {
      current = current->next;
    }
    
    ret = current->next;
  }
  
  return ret;
}

LinkListNode* LinkList_Delete(LinkList* list,int pos)
{
  TLinkList* sList = (TLinkList*)list;
  LinkListNode* ret = NULL;
  int i = 0;
  
  if((sList != NULL) && (pos>=0) && (pos<sList->length))
  {
    LinkListNode* current = (LinkListNode*)sList;
    
    for(i = 0;i<pos;i++)
    {
      current = current->next;
    }
    
    ret = current->next;
    current->next = ret->next;
    
    sList->length--;
  }
  
  return ret;
}  

LinkList.h

#ifndef _LINKLIST_H_
#define _LINKLIST_H_

typedef void LinkList;
typedef struct _tag_LinkListNode LinkListNode;
struct _tag_LinkListNode
{
  LinkListNode* next;
};

LinkList* LinkList_Create();//创建并返回一个空的链表

void LinkList_Destory(LinkList* list);//销毁链表表LinkList

void LinkList_Clear(LinkList* list);//清空链表

int LinkList_Length(LinkList* list);//返回链表长度

int LinkList_Insert(LinkList* list,LinkListNode* node,int pos);//在pos插入node，返回1表示插入成功

LinkListNode* LinkList_Get(LinkList* list,int pos);//获取pos位置元素，返回pos位置元素 

LinkListNode* LinkList_Delete(LinkList* list,int pos);//删除pos位置元素，返回值为被删元素 
#endif 

LinkStack.h

#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_Top(LinkStack* stack);

int LinkStack_Size(LinkStack* stack);

#endif

LinkStack.c

#include "LinkStack.h"
#include "LinkList.h"
#include <malloc.h>
#include <stdlib.h>

typedef struct _tag_LinkStackNode
{
  LinkListNode header;
  void* item;
} TLinkStackNode;

LinkStack* LinkStack_Create()
{
  return LinkList_Create();
}

void LinkStack_Destroy(LinkStack* stack)
{
  LinkStack_Clear(stack);
  LinkList_Destory(stack);
}

void LinkStack_Clear(LinkStack* stack)
{
  while(LinkStack_Size(stack)>0)
  {
    LinkStack_Pop(stack);
  }
}

int LinkStack_Push(LinkStack* stack,void* item)
{
  TLinkStackNode* node  = (TLinkStackNode*)malloc(sizeof(TLinkStackNode));
  int ret = (node != NULL) && (item != NULL);
  
  if(ret)
  {
    node->item = item;
    
    ret = LinkList_Insert(stack,(LinkListNode*)node,0);
  }
  
  if(!ret)
  {
    free(node);
  }
  
  return ret;
}

void* LinkStack_Pop(LinkStack* stack)
{
  TLinkStackNode* node  = (TLinkStackNode*)LinkList_Delete(stack,0);
  void* ret = NULL;
  
  if(node != NULL)
  {
    ret = node->item;
    
    free(node);
  }
  
  return ret;
}

void* LinkStack_Top(LinkStack* stack)
{
  TLinkStackNode* node  = (TLinkStackNode*)LinkList_Get(stack,0);
  void* ret = NULL;
  
  if(node != NULL)
  {
    ret = node->item;
  }
  
  return ret;
}

int LinkStack_Size(LinkStack* stack)
{
  return LinkList_Length(stack);
}

main.c

#include <stdio.h>
#include <stdlib.h>
#include "LinkStack.h"
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char *argv[])
{
  LinkStack* stack = LinkStack_Create();
  int a[10];
  int i = 0;
  
  for(i=0;i<10;i++)
  {
    a[i] = i;
    
    LinkStack_Push(stack,a+i);
  }
  
  printf("Top: %d\n",*(int*)LinkStack_Top(stack));
  
  printf("Length: %d\n",LinkStack_Size(stack));
  
//  LinkStack_Clear(stack);
  
  while(LinkStack_Size(stack)>0)
  {
    printf("Pop: %d\n",*(int*)LinkStack_Pop(stack));
  }
  
  LinkStack_Destroy(stack);
  
  return 0;
}

运行效果：