数据结构之--顺序栈

栈的定义

栈是一种特殊的线性表。 
栈仅能在线性表的一端进行操作： 
栈顶(Top)：允许操作的一端 
栈底(Bottom)：不允许操作的一端

性质：后进先出(LIFO) Last In First Out 

栈的一些常用操作： 
创建栈 
销毁栈 
清空栈 
进栈 
出栈 
获取栈顶元素 
获取栈的大小

栈的顺序存储实现

栈分为顺序栈和链式栈。

顺序栈：和顺序表类似，所以我们可以直接使用顺序表的代码进行实现。

在Seqlist.h文件中：

#ifndef __Seqlist_H__
#define __Seqlist_H__

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

typedef void SeqList;
typedef void SeqListNode;

SeqList* SeqList_Creat(int capacity);  //创建线性表
void SeqList_Destory(SeqList* list); //释放空间
void SeqList_clear(SeqList *list);
int SeqList_Length(SeqList *list);  //返回list的长度
int SeqList_capacity(SeqList *list);
int SeqList_Insert(SeqList*list,SeqListNode*node,int pos);  //插入一个线性表
SeqListNode *SeqList_Get(SeqList*list,int pos);  //得到一个元素
SeqListNode *SeqList_Delet(SeqList*list,int pos);  //删除一个元素
#endif // __Seqlist_H__

在Seqlist.c文件中：

#include "Seqlist.h"
#include <malloc.h>

typedef unsigned int TseqListNode;  //创建数据int类型

typedef struct _tag_SeqList  //创建结构体
{
    int capacity;    //容量大小
    int length;      //长度
    TseqListNode *node; //数据指针
}TseqList;

SeqList* SeqList_Creat(int capacity)
{
   TseqList* ret = NULL;

   if(capacity>=0)
   {
       ret = (TseqList*)malloc(sizeof(TseqList)+sizeof(TseqListNode)*capacity); //动态分配内存大小
   }
   if(ret !=NULL)  //不等于空
   {
       ret->capacity=capacity;
       ret->length=0;   //空链表
       ret->node=(TseqListNode*)(ret+1);  //指向后面的地址
   }
   return ret;

}
void SeqList_Destory(SeqList* list) //释放空间
{
    free(list);
}
void SeqList_clear(SeqList *list)
{
    TseqList* slist = (TseqList*)list;  //类型转换

    if(slist != NULL)
    {
        slist->length = 0;
    }
}
int SeqList_Length(SeqList *list)  //返回list的长度
{
    TseqList* slist = (TseqList*)list;  //类型转换
    int ret=-1;
    if(slist != NULL)
    {
         ret = slist->length;
    }
    return ret;
}
int SeqList_capacity(SeqList *list)
{
    TseqList* slist = (TseqList*)list;  //类型转换
    int ret=-1;
    if(slist != NULL)
    {
         ret = slist->capacity;
    }
    return ret;
}
int SeqList_Insert(SeqList*list,SeqListNode*node,int pos)  //插入一个线性表
{
     TseqList* slist = (TseqList*)list;  //类型转换
     int ret = (slist!=NULL);   //把slist不为空的值赋给ret
     int i=0;

     //判断线性表是否合法
     ret = ret && (slist->length+1 <=slist->capacity);
     ret = ret &&(0<=pos); //判读插入位置是否合法

     if(ret)
     {
        if(pos>=slist->length)  //如果位置大于长度
        {
            pos=slist->length;   //放到线性表的最后
        }
        for(i=slist->length;i>pos;i--)
        {
            slist->node[i]=slist->node[i-1];   //向后推进一个数
        }
      slist->node[i]=(TseqListNode)node;    //插入值 并转换

      slist->length++; //长度加一
     }
     return ret;    //返回值
}
SeqListNode *SeqList_Get(SeqList*list,int pos)  //得到一个元素
{
     TseqList* slist = (TseqList*)list;  //类型转换
     SeqListNode * ret = NULL;
     if((slist !=NULL)&&(0<=pos)&&(pos<slist->length)) //判断合法性
     {
         ret = (TseqListNode*)(slist->node[pos]);
     }
     return ret;
}
SeqListNode *SeqList_Delet(SeqList*list,int pos)  //删除一个元素
{
    TseqList* slist = (TseqList*)list;  //类型转换
    SeqListNode *ret = SeqList_Get(slist,pos);
    int i=0;
    if(ret !=NULL)
    {
        for(i=pos+1;i<slist->length;i++)
        {
            slist->node[i-1]=slist->node[i];
        }
        slist->length--;
    }
    return ret;
}

在SeqStack.h中

#ifndef __Seqstack_H__
#define __Seqstack_H__

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

typedef void SeqStack;
SeqStack* SeqStack_Create();//创建栈

void SeqStack_Destroy(SeqStack*stack);//销毁栈

void SeqStack_Clear(SeqStack*stack);//清除栈

int SeqStack_Capacity(SeqStack*stack);//获取栈的容量大小

int SeqStack_Push(SeqStack*stack , void * item);//进栈

void*SeqStack_Pop(SeqStack*stack);//出栈

void* SeqStack_Top(SeqStack*stack); //获取栈顶元素

int SeqStack_Size(SeqStack* stack);//获取栈的大小




#endif

在Seqstack.c中

#include "Seqstack.h"
#include "Seqlist.h"

SeqStack* SeqStack_Create(int capacity)
{
    return SeqList_Creat(capacity);
}

void SeqStack_Destroy(SeqStack* stack)
{
    SeqList_Destory(stack);
}

void SeqStack_Clear(SeqStack* stack)
{
    SeqList_clear(stack);
}

int SeqStack_Push(SeqStack* stack, void* item)
{
    return SeqList_Insert(stack, item, SeqList_Length(stack));
}

void* SeqStack_Pop(SeqStack* stack)
{
    return SeqList_Delet(stack, SeqList_Length(stack) - 1);
}

void* SeqStack_Top(SeqStack* stack)
{
    return SeqList_Get(stack, SeqList_Length(stack) - 1);
}

int SeqStack_Size(SeqStack* stack)
{
    return SeqList_Length(stack);
}

int SeqStack_Capacity(SeqStack* stack)
{
    return SeqList_capacity(stack);
}

main.c中

#include <stdio.h>
#include <stdlib.h>
#include "Seqstack.h"
//#include "Seqlist.h"
int main()
{
  SeqStack* stack = SeqStack_Create(20);

  int a[10];
  int i=0;

  for(i=0;i<10;i++)
  {
      a[i]=i;
     SeqStack_Push(stack,a+i);
  }
  printf("Top:%d\n",*(int*)SeqStack_Top(stack));
  printf("capacity:%d\n",SeqStack_Capacity(stack));
  printf("Length:%d\n",SeqStack_Size(stack));

 while(SeqStack_Size(stack)>0)
 {

     printf("%d\n",*(int*)SeqStack_Pop(stack));
 }
  SeqStack_Destroy(stack);
    return 0;
}