【算法和数据结构】_3_线性结构_栈

　　程序代码可以编译通过，未用数据进行测试。　

/*
    本程序测试线性数据结构：栈
*/

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

struct StackNode
{
    int* stack;
    int  Top;  //从1开始计数
    int  Size;
};

typedef struct StackNode STACK;
typedef enum {FALSE,TRUE} BOOL;

void CreateStack(STACK* stack,int size);
void InitStack(STACK* stack);
BOOL IsStackEmpty(STACK* stack);
BOOL IsStackFull(STACK* stack);
BOOL GetTop(STACK* stack,int* element);
BOOL Push(STACK* stack,int element);
BOOL Pop(STACK* stack);


int main(int argc,char* argv[])
{
    STACK stack;
    int size;

    stack.stack =NULL;
    puts("Enter the length of stack to create:");
    scanf("%d",&size);
    putchar('\n');
    CreateStack(&stack,size);

    getchar();
    getchar();
    return 0;
}


/*
函数功能：
    创建空栈
函数原型：
    void CreateStack(STACK* stack)
函数参数：
    STACK* stack: 指向栈的指针
    int size:要创建的栈的大小
返回值：
    无
异常：
    传递空指针
*/
void CreateStack(STACK* stack,int size)
{
    if(stack==NULL)
    {
        puts("Error.\n");
        exit(0);
    }

    if(stack->stack=(int *)malloc(sizeof(int)*size))
    {
        stack->Size=size;
        stack->Top=0;
    }
    else
    {
        puts("Error.\n");
        exit(0);
    }
}

/*
函数功能：
    初始化栈空间，将所有的栈元素初始化为零
函数原型：
    void InitStack(STACK* stack)
函数参数：
    STACK* stack：栈指针
返回值：
    无
异常：
    传递空指针
*/
void InitStack(STACK* stack)
{
    int i;

    //检测空指针
    if( NULL == stack || NULL == stack->stack)
    {
        puts("Error.\n");
        exit(0);
    }
    else
    {
        i=0;
        while(i < stack->Size)
        {
            stack->stack[i]=0;
            i++;
        }
    }
}

/*
函数功能：
    判断栈是否为空
函数原型：
    BOOL IsStackEmpty(STACK* stack)
函数参数：
    STACK* stack：栈指针
返回值：
    如果为空，则返回TRUE，否则返回FALSE
异常：
    传递空指针
*/
BOOL IsStackEmpty(STACK* stack)
{
    if(NULL==stack || stack->stack ==NULL)
    {
        puts("Error.\n");
        exit(0);
    }
    
    if(0==stack->Top)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}

/*
函数功能：
    判断是否栈满
函数原型：
    BOOL IsStackFull(STACK* stack)
函数参数：
    STACK* stack：栈指针
返回值：
    如果栈满，返回TRUE，否则返回FALSE
异常：
    传递空指针
*/
BOOL IsStackFull(STACK* stack)
{
    if(NULL==stack || stack->stack ==NULL)
    {
        puts("Error.\n");
        exit(0);
    }

    if(stack->Top==stack->Size)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }

}

/*
函数功能：
    获取栈顶元素的值
函数原型：
    BOOL GetTop(STACK* stack,int* element)
函数参数：
    STACK* stack：栈指针
返回值：
    如果可取值，返回TRUE，并设置*element=栈顶值
    否则返回FALSE，并设置*element=0；
异常：
    传递空指针
*/
BOOL GetTop(STACK* stack,int* element)
{
    if(NULL==stack || stack->stack ==NULL||element==NULL)
    {
        puts("Error.\n");
        exit(0);
    }

    if(IsStackEmpty(stack))
    {
        *element=0;
        return FALSE;
    }
    else
    {
        *element=stack->stack[stack->Top-1];
        return TRUE;
    }
}

/*
函数功能：
    压栈
函数原型：
    BOOL Push(STACK* stack,int element)
函数参数：
    STACK* stack:栈指针
    int element：入栈元素
返回值：
    如果压栈成功，返回TRUE，否则返回FALSE；
异常：
    传递空指针
*/
BOOL Push(STACK* stack,int element)
{
    if(NULL==stack || stack->stack ==NULL)
    {
        puts("Error.\n");
        exit(0);
    }

    if(IsStackFull(stack))
    {    
        //栈满，无法压栈
        return FALSE;
    }
    else
    {
        stack->stack[stack->Top]=element;
        stack->Top++;
        return TRUE;
    }

}

/*
函数功能：
    出栈
函数原型：
    BOOL Pop(STACK* stack)
函数参数：
    STACK* stack：栈指针
返回值：
    如果出栈成功，则返回TRUE，否则返回FALSE
异常：
    传递空指针
*/
BOOL Pop(STACK* stack)
{
    if(NULL==stack || stack->stack ==NULL)
    {
        puts("Error.\n");
        exit(0);
    }

    if(IsStackEmpty(stack))
    {
        return FALSE;
    }
    else
    {
        stack->Top--;
        return TRUE;
    }
}