栈的程序演示

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


typedef struct Node
{
    int data;
    struct Node *next;
}NODE, * PNODE;


typedef struct Stack
{
    PNODE pTop;
    PNODE pBottom;
}STACK, * PSTACK;


void init (PSTACK pS)//PSTACK 等价于 struck STACK *
{
    pS ->pTop = (PNODE) malloc (sizeof (NODE));
    if (NULL == pS ->pTop)
    {
        printf("wrong!\n");
        exit(-1);
    }
    else
    {
        pS ->pBottom = pS ->pTop;
        pS ->pBottom -> next = NULL;//pS ->pTOP -> next = NULL
        printf("Success!\n");
    }
}


void push (PSTACK pS, int val)
{
    PNODE pNew = (PNODE) malloc (sizeof (NODE));
    
    pNew ->data = val;
    pNew ->next = pS ->pTop;
    pS ->pTop = pNew;


    return ;
}


void traverse(PSTACK pS)
{
    PNODE p = pS ->pTop;


    while (p != pS ->pBottom)
    {
        printf("%d ",p ->data);
        p = p ->next;
    }
    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的地址
    {
        return false;
    }
    else
    {
         PNODE r = pS ->pTop;
         *pVal = r ->data;
         pS ->pTop = r ->next;
         free(r);
         r = NULL;


         return true;
    }
}


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


        while (p != pS ->pBottom)
        {
            q = p ->next;
            free(p);
            p = q;
        }
    }
    pS ->pTop = pS ->pBottom;
}
int main()
{
    STACK S;//STACK 等价于 struct Stack
    int val;
    init(&S);//目的是造出一个空栈
    push(&S,1);//压栈
    push(&S,2);
    push(&S,3);
    push(&S,4);
    push(&S,5);
    
    traverse(&S);//遍历输出


    //出栈
    if ( pop(&S,&val))
    {
        printf("Success!");
        printf("Pop is %d\n",val);
    }
    else
    {
        printf("Lose!\n");
    }


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


    return 0;
}