stack顺序存储的设计与实现

一、stack基本概念
    栈是一种特殊的线性表，栈仅能在线性表的一端进行操作，栈顶（top）:允许操作的一端；栈底（bottom）:不允许操作的一端。

二、stack的常用操作

    1. 创建栈
    2. 销毁栈

    3. 清空栈
    4. 进栈
    5. 出栈
    6. 获取栈顶元素

    7. 获取栈的大小

三、栈顺序存储的设计与实现

#ifndef _ZCH_SEQSTACK_H_
#define _ZCH_SEQSTACK_H_

typedef void SeqStack

SeqStack* Create(int capacity);

void Destroy(SeqStack* stack);

void Clear(SeqStack* stack);

int Push(SeqStack* stack, void* item);

void* Pop(SeqStack* stack);

void* Top(SeqStack* stack);

int Size(SeqStack* stack);

int Capacity(SeqStack* stack);

#endif

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

#include "zch_seqstack.h"

typedef struct _tag_SeqStack
{
    int capacity;
    int length;
    unsigned int *node;
}TSeqStack;

SeqStack* Create(int capacity)
{
    TSeqStack* ret = NULL;
    if(capacity < 0)
    {
        return NULL;
    }

    ret = (TSeqStack*)malloc(sizeof(TSeqStack) + sizeof(unsigned int) * capacity);

    if(NULL == ret)
    {
        return NULL;
    }

    memset(ret, 0, sizeof(TSeqStack) + sizeof(unsigned int) * capacity);

    ret->node = (unsigned int *)(ret + 1);
    ret->capacity = capacity;
    ret->length = 0;
    return ret;
}

void Destroy(SeqStack* stack)
{
    if(stack == NULL)
    {
    return;
    }
    free(stack);
    return;
}

void Clear(SeqStack* stack)
{
    TSeqStack* tStack = (TSeqStack*)stack;
    if(NULL == tStack)
    {
        return;
    }
    tStack->length = 0;
    return;
}

int Push(SeqStack* stack, void* item)
{
    TSeqStack* tStack = (TSeqStack*)stack;
    if(NULL == tStack || NULL == item)
    {
        return -1;
    }

    if(tStack->length >= tStack->capacity)
    {
        return -1;
    }

    tStack->node[tStack->length] = (unsigned int)item;

    tStack->length++;

    return 0;
}

void* Pop(SeqStack* stack)
{
    TSeqStack* tStack = (TSeqStack*)stack;
    if(NULL == tStack)
    {
        return NULL;
    }
    tStack->length--;
    return tStack->node[tStack->length];
}

void* Top(SeqStack* stack)
{
    TSeqStack* tStack = (TSeqStack*)stack;
    if(NULL == tStack)
    {
        return NULL;
    }
    return tStack->node[tStack->length - 1];
}

int Size(SeqStack* stack)
{
    TSeqStack* tStack = (TSeqStack*)stack;
    if(NULL == tStack)
    {
        return -1;
    }
    return tStack->length;
}

int Capacity(SeqStack* stack)
{
    TSeqStack* tStack = (TSeqStack*)stack;
    if(NULL == tStack)
    {
        return -1;
    }
    return tStack->capacity;
}