順序棧：創建&初始化、入棧、出棧、計算棧中有效數據長度、獲取棧頂數據、清空棧、銷毀棧

/*
    順序棧的實現：
    初始化
    入棧
    出棧
    計算棧的有效數據長度
    獲取棧頂數據
    清空棧
    銷毀棧
*/

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

#define ElemType int

typedef struct __stackInfo
{
    ElemType *pData;
    unsigned int top;
    unsigned int capacity;
} stackInfo;
/* 初始化 */
int initStack(stackInfo **ppS, unsigned int size)
{
    if (NULL == ppS)
    {
        printf("ppNewStack point address is not exist\n");
        return -1;
    }

    stackInfo *pNewStack = (stackInfo *)malloc(sizeof(stackInfo));
    if (NULL == pNewStack)
    {
        printf("ppNewStack malloc fail\n");
        return -1;
    }

    pNewStack->pData = (ElemType *)malloc(sizeof(ElemType)*size);
    if (NULL == pNewStack->pData)
    {
        printf("ppNewStack databuf malloc fail\n");
        
        /* 前面幾篇代碼就少了這里，務必要小心，記個坑： 一旦直接推出，則泄漏內存pNewStack */
        free(pNewStack);
        return -1;
    }
    
    pNewStack->capacity = size;
    pNewStack->top = 0;

    *ppS = pNewStack;

    return 0;
}
/* 入棧 */
int pushStack(stackInfo *pS, int val)
{
    if (NULL == pS)
    {
        printf("pStack point NULL\n");
        return -1;
    }
    
    if (pS->capacity == pS->top)
    {
        printf("pStack full\n");
        return -1;
    }
    
    pS->pData[pS->top] = val;
    pS->top++;
    
    return 0;
}
/* 出棧 */
int popStack(stackInfo *pS, int *val)
{
    if ((NULL == pS) || (NULL == val))
    {
        printf("pStack point NULL or val point NULL\n");
        return -1;
    }
    
    if (pS->top <= 0)
    {
        printf("pStack empty\n");
        return -1;
    }
    
    pS->top--;
    *val = pS->pData[pS->top];
    
    return 0;
}
/* 獲取棧頂數據 */
int topStack(stackInfo *pS, int *val)
{
    if ((NULL == pS) || (NULL == val))
    {
        printf("pStack point NULL or val point NULL\n");
        return -1;
    }

    if (0 >= pS->top)
    {
        printf("pStack empty\n");
        return -1;
    }
    
    *val = pS->pData[pS->top - 1];
    
    return 0;
}
/* 計算棧中有效數據長度 */
int lengthOfStack(stackInfo *pS, unsigned int *val)
{
    if ((NULL == pS) || (NULL == val))
    {
        printf("pStack point NULL or val point NULL\n");
        return -1;
    }
    
    *val = pS->top;
    
    return 0;
}
/* 清空棧 */
int emptyStack(stackInfo *pS)
{
    if (NULL == pS)
    {
        printf("pStack point NULL\n");
        return -1;
    }
    
    while(pS->top)
    {
        /* 小技巧：如果賦值為0即0，如果賦值為FF，因16、32位平台的區別，鑒於可移植性考慮，賦值為0按位取反 */
        pS->top--;
    }

    return 0;
}
/* 銷毀棧 */
int destoryStack(stackInfo **ppS)
{
    if (NULL == ppS)
    {
        printf("pStack point address is not exist\n");
        return -1;
    }
    
    if (NULL == *ppS)
    {
        printf("pStack point NULL\n");
        return -1;
    }

    emptyStack(*ppS);
    /* 關注點：1、兩塊動態內存需釋放 2、注意釋放的先后順序 3、N組結構體的釋放，一次調用無法全部釋放 */
    free((*ppS)->pData);
    free(*ppS);

    return 0;
}

/* 測試入口 */
int main(void)
{
    stackInfo *pNewStack = NULL;
    unsigned int length = 0;
    int val = 0;
    
    initStack(&pNewStack, 10);

    lengthOfStack(pNewStack, &length);
    printf("pNewStack valid length: %d\n", length);

    /* 創建10個元素的棧，入棧11次，檢查軟件的容錯機制 */
    for (int i=0; i<11; i++)
    {
        pushStack(pNewStack, i);
        lengthOfStack(pNewStack, &length);
        printf("pNewStack valid length: %d\n", length);
    }
    /* 入棧10個數據，出棧11次，檢查軟件的容錯機制 */
    for (int i=0; i<11; i++)
    {
        topStack(pNewStack, &val);
        printf("pNewStack top data: %d\n", val);
        popStack(pNewStack, &val);
        printf("popStack data: %d\n", val);
    }

    emptyStack(pNewStack);
    lengthOfStack(pNewStack, &length);
    printf("pNewStack valid length: %d\n", length);

    destoryStack(&pNewStack);
    
    return 0;    
}