栈

前一篇文章介绍了线性表：那这一篇就不在具体介绍了。

Stack基本概念

栈是一种  特殊的线性表  
栈仅能在线性表的一端进行操作
栈顶(Top)：允许操作的一端
栈底(Bottom)：不允许操作的一端
栈的规则：后进先出或者(先进后出)

seqlist.h

    #ifndef  __MY_SEQLIST_H__ 
    #define __MY_SEQLIST_H__
    typedef void SeqList;
    typedef void SeqListNode;
    SeqList* SeqList_Create(int capacity);
    void SeqList_Destroy(SeqList* list);
    void SeqList_Clear(SeqList* list);
    int SeqList_Length(SeqList* list);
    int SeqList_Capacity(SeqList* list);
    int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);
    SeqListNode* SeqList_Get(SeqList* list, int pos);
    SeqListNode* SeqList_Delete(SeqList* list, int pos);
    #endif

seqlist.c

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "seqlist.h"


//在结构体中套1级指针
//
typedef struct _tag_SeqList
{
    int length;
    int capacity;
    unsigned int *node;   //int* node[]
}TSeqList;

SeqList* SeqList_Create(int capacity)
{
    int ret = 0;
    TSeqList *tmp = NULL;

    tmp = (TSeqList *)malloc(sizeof(TSeqList));
    if (tmp == NULL)
    {
        ret = -1;
        printf("func SeqList_Create() err:%d \n", ret);
        return NULL;
    }
    memset(tmp, 0, sizeof(TSeqList));

    //根据capacity 的大小分配节点的空间
    tmp->node = (unsigned int *)malloc(sizeof(unsigned int *) * capacity);
    if (tmp->node  == NULL)
    {
        ret = -2;
        printf("func SeqList_Create() err: malloc err %d \n", ret);
        return NULL;
    }
    tmp->capacity = capacity;
    tmp->length = 0;
    return tmp;
}

void SeqList_Destroy(SeqList* list)
{
    TSeqList *tlist = NULL;
    if (list == NULL)
    {
        return ;
    }
    tlist = (TSeqList *)list;
    if (tlist->node != NULL)
    {
        free(tlist->node);
    }

    free(tlist);

    return ;
}

//清空链表 //回到初始化状态
void SeqList_Clear(SeqList* list)
{
    TSeqList *tlist = NULL;
    if (list == NULL)
    {
        return ;
    }
    tlist = (TSeqList *)list;
    tlist->length = 0; 
    return ;
}

int SeqList_Length(SeqList* list)
{
    TSeqList *tlist = NULL;
    if (list == NULL)
    {
        return -1;
    }
    tlist = (TSeqList *)list;
    return tlist->length;
}

int SeqList_Capacity(SeqList* list)
{

    TSeqList *tlist = NULL;
    if (list == NULL)
    {
        return -1;
    }
    tlist = (TSeqList *)list;
    return tlist->capacity;
}

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)
{
    int i =0, ret = 0;
    TSeqList *tlist = NULL;

    if (list == NULL || node==NULL ||  pos<0)
    {
        ret = -1;
        printf("fun SeqList_Insert() err:%d \n", ret);
        return ret;
    }
    tlist = (TSeqList*)list;

    //判断是不是满了
    if (tlist->length >= tlist->capacity)
    {
        ret = -2;
        printf("fun SeqList_Insert() (tlist->length >= tlist->capacity) err:%d \n", ret);
        return ret;
    }

    //容错修正  6个长度 容量20;用户pos10位置插入..
    if (pos>=tlist->length)
    {
        pos = tlist->length; //
    }

    //1 元素后移
    for(i=tlist->length; i>pos; i--)
    {
        tlist->node[i] = tlist->node[i-1];
        //a[7] = a[6]
    }
    // i = 3
    // 2插入元素
    tlist->node[pos] = (unsigned int )node;
    tlist->length ++;
    return 0;
}

SeqListNode* SeqList_Get(SeqList* list, int pos)
{
    int i =0;
    SeqListNode *ret = 0;
    TSeqList *tlist = NULL;

    if (list == NULL ||  pos<0)
    {
        printf("fun SeqList_Get() err:%d \n", ret);
        return NULL;
    }
    tlist = (TSeqList*)list;

    ret = (void *)tlist->node[pos];
    return ret;
}

SeqListNode* SeqList_Delete(SeqList* list, int pos)
{
    int i = 0;
    SeqListNode *ret = 0;
    TSeqList *tlist = NULL;

    if (list == NULL ||  pos<0) //检查
    {
        printf("fun SeqList_Delete() err:%d \n", ret);
        return NULL;
    }
    tlist = (TSeqList*)list;

    ret = (SeqListNode *)tlist->node[pos]; //缓存pos的位置

    for (i=pos+1; i<tlist->length; i++)  //pos位置后面的元素前移
    {
        tlist->node[i-1] = tlist->node[i];
    }
    tlist->length --;
    return ret;
}

stack.h

#ifndef _MY_STACK_H_
#define _MY_STACK_H_

typedef void Stack;

Stack* Stack_Create(int capacity);

void Stack_Destroy(Stack* stack);

void Stack_Clear(Stack* stack);

int Stack_Push(Stack* stack, void* item);

void* Stack_Pop(Stack* stack);

void* Stack_Top(Stack* stack);

int Stack_Size(Stack* stack);

int Stack_Capacity(Stack*stack);

#endif

stack.c

#include "SeqStack.h"
#include"seqlist.h"



//创建栈 相当于 创建线性表
Stack* Stack_Create(int capacity)
{
    return SeqList_Create(capacity) ;
}
// 销毁栈 相当于 销毁线性表
void Stack_Destroy(Stack* stack)
{
     SeqList_Destroy(stack);
}
// 清除栈 相当于 清除线性表
void Stack_Clear(Stack* stack)
{

     SeqList_Clear(stack);
}
//向栈中压入元素 相当于 向链表的尾部插入元素
int Stack_Push(Stack* stack, void* item)
{

    return SeqList_Insert(stack,item,SeqList_Length(stack));
}
//向栈中删除元素 相当于 向链表的尾部删除元素
void* Stack_Pop(Stack* stack)
{

    return SeqList_Delete(stack,SeqList_Length(stack)-1);
}
//获取栈顶元素
void* Stack_Top(Stack* stack)
{

    return SeqList_Get(stack,SeqList_Length(stack)-1);
}
//获取栈的大小
int Stack_Size(Stack* stack)
{

    return SeqList_Length(stack);
}
//获取栈的容量
int Stack_Capacity(Stack*stack)
{
    return SeqList_Capacity(stack);
}

测试程序 main.c

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


int main()
{
    Stack* stack = NULL;
    int i = 0;
    int a[10];
    int tmp = 0;
    stack = Stack_Create(10);
    if(stack == NULL)
    {
        return;
    }
    for(i = 0;i<5;i++)
    {
        a[i] = i+1;
        Stack_Push(stack, &a[i]);
    }
    printf("Capacity:%d\n",Stack_Capacity(stack));
    printf("Length:%d\n",Stack_Size(stack));
    printf("Top:%d\n",*((int*)Stack_Top(stack)));
    while(Stack_Size(stack)>0)
    {
        tmp = *((int*)Stack_Pop(stack));
        printf("Pop:%d\n",tmp);
    }

    system("pause");
    return 0;
}

就这么简单。栈的应用后面篇介绍2个列子