链式栈（单向链式栈）：创建&初始化、入栈、出栈、计算链有效栈结点长度、获取栈顶结点、清空栈、销毁栈...

/*
    链式栈的实现：之前的代码，再free后没有对指针赋空值，以下代码作了添加，后续抽时间对之前的代码作 【释放后的指针赋空】 修改
    初始化
    入栈
    出栈
    计算栈的有效数据长度
    获取栈顶数据
    清空栈
    销毁栈

    代码均属原创，有借鉴，有优化。有错误请指出，欢迎探讨学习
*/

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

#define ElemType int

/* 链上的栈元素 */
typedef struct node
{
    ElemType data;
    struct node *pNext;
}Node;
/* 栈的链表 */
typedef struct __listStackInfo
{
    Node *pTop;
} listStackInfo;
/* 初始化栈式链 */
int initStack(listStackInfo **ppS)
{
    if (NULL == ppS)
    {
        printf("ppListStack point address is not exist\n");
        return -1;
    }

    listStackInfo *plistStack = (listStackInfo *)malloc(sizeof(listStackInfo));
    if (NULL == plistStack)
    {
        printf("pplistStack malloc fail\n");
        return -1;
    }
    plistStack->pTop = NULL;

    *ppS = plistStack;

    return 0;
}
/* 入栈 */
int pushStack(listStackInfo *pS, ElemType val)
{
    if (NULL == pS)
    {
        printf("pListStack point address NULL\n");
        return -1;
    }

    Node *pNewNode = (Node *)malloc(sizeof(Node));
    if (NULL == pNewNode)
    {
        printf("pNode NULL\n");
        return -1;
    }
    memcpy(&pNewNode->data, &val, sizeof(ElemType));
    pNewNode->pNext = pS->pTop;
    pS->pTop = pNewNode;
    
    return 0;
}
/* 出栈 */
int popStack(listStackInfo *pS, ElemType *val)
{
    if ((NULL == pS) || (NULL == val))
    {
        printf("pListStack point NULL or val point NULL\n");
        return -1;
    }

    if (NULL == pS->pTop)
    {
        printf("pListStack empty\n");
        return -1;
    }

    Node *pPopNode = pS->pTop;
    memcpy(val, &pPopNode->data, sizeof(ElemType));    
    pS->pTop = pPopNode->pNext;
    free(pPopNode);
    pPopNode = NULL;
    
    return 0;
}
/* 获取栈顶数据 */
int topStack(listStackInfo *pS, ElemType *val)
{
    if ((NULL == pS) || (NULL == val))
    {
        printf("pListStack point NULL or val point NULL\n");
        return -1;
    }

    if (NULL == pS->pTop)
    {
        printf("pListStack empty\n");
        return -1;
    }
    
    memcpy(val, &pS->pTop->data, sizeof(ElemType));
    
    return 0;
}
/* 计算栈中有效数据长度 */
int lengthOfStack(listStackInfo *pS, unsigned int *val)
{
    if ((NULL == pS) || (NULL == val))
    {
        printf("pListStack point NULL or val point NULL\n");
        return -1;
    }
    
    unsigned int tempLen = 0;
    Node *pTempNode = pS->pTop;

    while(NULL != pTempNode)
    {
        tempLen++;
        pTempNode = pTempNode->pNext;
    }
    *val = tempLen;
    
    return 0;
}
/* 清空链栈 */
int emptyStack(listStackInfo *pS)
{
    if (NULL == pS)
    {
        printf("pStack point NULL\n");
        return -1;
    }
    
    Node *pTempNode = NULL;
    while(NULL != pS->pTop)
    {
        pTempNode = pS->pTop;
        pS->pTop = pTempNode->pNext;
        free(pTempNode);
    }
    pTempNode = NULL;

    return 0;
}
/* 销毁栈 */
int destoryStack(listStackInfo **ppS)
{
    if (NULL == ppS)
    {
        printf("pStack point address is NULL\n");
        return -1;
    }
    
    if (NULL == *ppS)
    {
        printf("pStack point NULL\n");
        return -1;
    }

    emptyStack(*ppS);
    /* 关注点：1、两块动态内存需释放 2、注意释放的先后顺序 */
    free((*ppS)->pTop);
    free(*ppS);
    *ppS = NULL;

    return 0;
}

/* 测试入口 */
int main(void)
{
    listStackInfo *pNewStack = NULL;
    unsigned int length = 0;
    ElemType val = 0;
    
    initStack(&pNewStack);

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

    /* 创建10个元素的栈，入栈11次，检查软件的容错机制 */
    for (int i=0; i<11; i++)
    {
        pushStack(pNewStack, (ElemType)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);
    emptyStack(pNewStack);
    
    return 0;    
}

转载于:https://www.cnblogs.com/tedani/p/9990706.html