栈

#ifndef _SEQUENCESTACK_H_
#define _SEQUENCESTACK_H_

#include<stdlib.h>

#define  SUCCESS  10000
#define  FAILURE  10001
#define  TRUE     10002
#define  FALSE    10003

#define SIZE 10

typedef int ElemType;

struct stack
{
    int top;
    ElemType *data;
};

typedef struct stack Stack;

int StackInit(Stack  **s);

#endif

#include"SequenceStack.h"
#include<stdio.h>

int main()
{
    Stack *stack;
    int ret,i;

    ret=StackInit(&stack);
    if(ret==SUCCESS)
    {
        printf("Init Sequence Stack Success !\n");
    }
    else
    {
        printf("Failure!\n");
    }
    
    ret=StackEmpty(stack);
    if(ret==TRUE)
    {
        printf("stack is empty!\n");
    }
    else if(ret=FALSE)
    {
        printf("stack is not empty!\n");
    }

    for(i=0;i<10;i++)
    {
        ret=push(stack,i+1);
        if(SUCCESS==ret)
        {
            printf("Push %d Success !\n",i+1);
        }
        else if(FAILURE==ret)
        {
            printf("Push %d Failure!\n",i+1);
        }
    }
    
    ret=GetTop(stack);
    if(FAILURE==ret)
    {
        printf("Get Top Failure!\n");
    }
    else
    {
        printf("Top is %d\n",ret);
    }

    for(i=0;i<5;i++)
    {
        ret=pop(stack);
        if(ret==FAILURE)
        {
            printf("pop Failure!\n");
        }
        else
        {
            printf("pop Success!\n");
        }
    }

    ret=StackClear(stack);
    if(ret=SUCCESS)
    {
        printf("clear success!\n");
    }
    else
    {
        printf("clear failure!\n");
    }
	
	ret=GetTop(stack);
    if(FAILURE==ret)
    {
        printf("Get Top Failure!\n");
    }
    else
    {
        printf("Top is %d\n",ret);
    }

    ret=StackDestroy(&stack);
    if(ret==SUCCESS)
    {
        printf("Destroy Success!\n");
    }
    else
    {
        printf("Destroy Failure!\n");
    }

    return 0;
}

#include"SequenceStack.h"

int StackInit(Stack **s)
{
    (*s)=(Stack*)malloc(sizeof(Stack)*1);
    if(NULL==(*s))
    {
        return FAILURE;
    }

    (*s)->top=-1;
    (*s)->data=(ElemType*)malloc(sizeof(ElemType)*SIZE);
    if(NULL==(*s)->data)
    {
        return FAILURE;
    }
    return SUCCESS;
}

int StackEmpty(Stack *s)
{
    return (s->top == -1)? TRUE : FALSE;
}

int push(Stack *s,ElemType e)
{
    if(NULL ==s||s->top==9)
    {
        return FAILURE;
    }

    s->data[s->top+1]=e;
    s->top++;

    return SUCCESS;
}

int GetTop(Stack *s)
{
    if(s->top==-1)
    {
        return FAILURE;
    }
    return s->data[s->top];
}

int pop(Stack *s)
{    
    if(s->top==-1)
    {
        return FAILURE;
    }
    s->top--;

    return SUCCESS;
}

int StackClear(Stack *s)
{
    if(NULL==s)
    {
        return FAILURE;
    }

    s->top=-1;

    return SUCCESS;
}

int StackDestroy(Stack **s)
{
    if(s==NULL||*s==NULL)
    {
        return FAILURE;
    }

    free((*s)->data);
    free(*s);
    *s=NULL;

    return SUCCESS;
}