C_数据结构_栈

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

typedef struct Node //建造节点
{
    int data;
    struct Node * pNext;
}NODE, * PNODE;

typedef struct Stack //建造栈所需要的两个参数
{
    PNODE pTop; //指向栈顶的元素
    PNODE pBottom; //指向栈底没有实际含义的元素
}STACK, * PSTACK;// PSTACK 等价于 struct Stack *

void init(PSTACK); //初始化
void push(PSTACK, int); //压栈
void traverse(PSTACK); //遍历输出
bool pop(PSTACK, int *); //出栈
void clear1(PSTACK); //清空
void clear2(PSTACK);//清空

int main(void)
{
    STACK S; //STACK 等价于 struct Stack
    int val;

    init(&S); //初始化  目的是造出一个空栈
    push(&S, ); //压栈
    push(&S, );
    push(&S, );
    push(&S, );
    push(&S, );
    push(&S, );
    traverse(&S); //遍历输出

    if ( pop(&S, &val) ) //出栈
    {
        printf("出栈成功！出栈的元素是：%d\n", val);
    }
    else
    {
        printf("出栈失败！\n");
    }

    traverse(&S); //遍历输出

    clear2(&S);
    traverse(&S); //遍历输出

    return ;
}

void init(PSTACK pS) //初始化
{
    pS->pTop = (PNODE)malloc(sizeof(NODE));
    if (NULL == pS->pTop)
    {
        printf("动态内存分配失败！\n");
        exit(-);
    }
    else
    {
        pS->pBottom = pS->pTop;
        pS->pTop->pNext = NULL; //pS->pBottom->pNext = NULL;
    }
}

void push(PSTACK pS, int val) //压栈
{
    PNODE pNew = (PNODE)malloc(sizeof(NODE));
    pNew->data = val;
    pNew->pNext = pS->pTop; //不能把 pS->Top 改为 pS->pBottom
    pS->pTop = pNew;

    return;
}

void traverse(PSTACK pS) //便利输出
{
    PNODE p = pS->pTop;
    while (p != pS->pBottom)
    {
        printf("%d ", p->data);
        p = p->pNext;
    }
    printf("\n");

    return;
}

bool empty(PSTACK pS) //判断是否空
{
    if (pS->pTop == pS->pBottom)
    {
        return true;
    }
    else
    {
        return false;
    }
}

//把PS所指向的栈出栈一次，并把出栈的元素存入pVal形参所指向的变量中，如果出栈失败返回false，否则返回true
bool pop(PSTACK pS, int * pVal)
{
    if ( empty(pS) ) // pS 形参本身保存的是 S 的地址，这里需要将S的地址发送给 empty() 函数只要发送 pS即可
    {
        return false;
    }
    else
    {
        PNODE r = pS->pTop; //需要把他定义成已 pS->pTop 为类型的地址变量
        *pVal = pS->pTop->data; //等价于 r->data
        pS->pTop = pS->pTop->pNext; //等价于 r->pNext
        free(r); //这里释放的是r所指向的动态内存
        r = NULL; //这里表示清空地址变量 r 的数据以便下次分配

        return true;
    }
}

void clear2(PSTACK pS) //清空
{
    PNODE p;
    int i;
    printf("清空的值都有：");

    while ( pS->pTop != pS->pBottom )
    {
        p = pS->pTop;
        i = p->data;
        printf("%d ", i);
        pS->pTop = p->pNext;
        free(p);
        p = NULL;
    }
    printf("\n");

    i = NULL;
    pS->pTop = pS->pBottom;
}

void clear1(PSTACK pS) //清空
{
    if  ( empty(pS) )
    {
        return;
    }
    else
    {
        PNODE p = pS->pTop;
        PNODE q = p->pNext;

        while (p != pS->pBottom)
        {
            q = p->pNext;
            free(p);
            p = q;
        }
        pS->pTop = pS->pBottom;
    }

}