数据结构之--链式栈

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u014183456/article/details/80249302

接上篇直接上代码

Linklist.h

#ifndef __Linklist_H__
#define __Linklist_H__

#include <stdio.h>
#include <stdlib.h>

typedef void Linklist;
typedef struct _tag_LinklistNode LinklistNode;

struct _tag_LinklistNode  //指针域定义
{
    LinklistNode* next;
};
Linklist * Linklist_Create(); //创建线性表

void Linklist_Destory(Linklist *list);

void Linklist_Clear(Linklist *list);

int Linklist_length(Linklist *list);  //返回线性表的长度

int Linklist_Insert(Linklist*list,LinklistNode * node , int pos); //插入数据 三个参数

LinklistNode * Linklist_Get(Linklist *list,int pos);

LinklistNode *Linklist_Delet(Linklist *list, int pos);


#endif

Linklist.c

#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->header.next=NULL;  //指向为空
        ret->length=0;          //长度为0
    }
    return ret;
}

void Linklist_Destory(Linklist *list)
{
   free(list);
}

void Linklist_Clear(Linklist *list)
{
  TLinklist *slist = (TLinklist *)list;
  if(slist != NULL)
  {
      slist->header.next=NULL;
      slist->length=0;
  }
}
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;
   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;
   if((slist != NULL)&&(pos>=0)&&(pos<=slist->length))
   {
       LinklistNode *current = (LinklistNode*)slist;  //指向第一个元素
       for(i=0;(i<pos)&&(current->next)!=NULL;i++)   //指针移动
       {
           current=current->next;
       }
       ret = current->next;
   }
   return  ret;
}

LinklistNode *Linklist_Delet(Linklist *list, int pos)
{
  TLinklist *slist = (TLinklist *)list;  //类型转换
   LinklistNode * ret=NULL;  //判断合法性
   int i;
   if((slist != NULL)&&(pos>=0)&&(pos<=slist->length))
   {
       LinklistNode *current = (LinklistNode*)slist;  //指向第一个元素
       for(i=0;(i<pos)&&(current->next)!=NULL;i++)   //指针移动
       {
           current=current->next;
       }
       ret = current->next;
       current->next= ret->next;

       slist->length--;
   }
   return  ret;
}

LinkStack.h

#ifndef __LinkStack.h__
#define __LinkStack.h__
#include <stdio.h>
#include <stdlib.h>

typedef void LinkStack;

LinkStack* LinkStack_Creat();  //创建链式栈

void LinkStack_Destory(LinkStack* stack);//销毁栈

void LinkStack_Clear(LinkStack* stack);//清空栈

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

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

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

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



#endif

Linkstack.c

#include"LinkStack.h"
#include "Linklist.h"

typedef struct _tag_LinkStack
{
    LinklistNode header;
    void* item;
}TLinkStackNode;


LinkStack* LinkStack_Creat()
{
    return Linklist_Create();
}

void LinkStack_Destory(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_Delet(stack,0);
   void* ret = NULL;
   if(node != NULL)
   {
       ret = node->item;
       free(node);
   }
 return ret;
}

int  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"LinkStack.h"
int main()
{
    LinkStack* stack = LinkStack_Creat();
    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));

    while(LinkStack_Size(stack)>0)
    {
        printf("%d\n",*(int*)LinkStack_Pop(stack));
    }
    LinkStack_Destory(stack);
    //printf("Hello world!\n");
    return 0;
}