数据结构入门之———离散存储结构【链表】——栈

数据结构入门之———离散存储结构【链表】——栈

郝斌——数据结构

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

typedef struct Node
{
    int data;
    struct Node * pNext;
}NODE,*PNODE;   //PNODE  等价与struct Node *

typedef struct Stack        //设想栈类似一个箱子
{
    PNODE pTop;         //pTop指向箱子的入口
    PNODE pBottom;         //pBottom指向箱子底部的下一个元素
}STACK,*PSTACK;         //PSTACK  等价与struct Stack *

void init(PSTACK pS);               /*初始化栈:目的是造出一个空栈*/
void push(PSTACK pS,int val);           /*操作：压栈*/
void traverse(PSTACK);                  /*操作：遍历栈*/
bool pop(PSTACK pS,int *pVal);          /*操作：出栈*/
bool empty(PSTACK pS);                   /*操作：判断此栈是否是空栈*/
void clear_STACK(PSTACK pS);                /*操作：清空栈，回到创建栈的状态，即一个空栈*/

int main(void)
{
    STACK S;        //STACK 等价于 struct Stack
    int val;
    init(&S);      //初始化栈:目的是造出一个空栈
    push(&S,1);     //压栈
    push(&S,2);
    push(&S,3);
    push(&S,4);
    push(&S,6);
    traverse(&S);
    clear_STACK(&S);  //清空
    
    if(pop(&S,&val))
    {
        printf("出栈成功！出栈的元素是：%d\n",val);
    }
    else
    {
        printf("出栈失败!\n");
    }
    traverse(&S);         //遍历
//    clear_STACK(&S);  //清空
//    traverse(&S);
    
        
    return 0;
}
/*操作：创建一个空栈*/
/*前提条件：建木箱子的木板*/
/*后置条件：一个空箱子*/
void init(PSTACK pS)
{
    
    pS->pTop = (PNODE)malloc(sizeof(NODE));
    if(NULL == pS->pTop)
    {
        printf("动态内存分配失败！\n");
        exit(-1);
    }
    else
    {
        pS->pBottom = pS->pTop;
        pS->pTop->pNext = NULL;     //pS->pBottom->pNext = NULL;
    }
    
}
/*操作：压栈*/
/*前提条件：已经建好一个空箱子，要存入箱子的值val，该箱子的入口地址*/
/*后置条件：使箱子的入口指针指向当前压栈的地址，成为新的入口*/
void push(PSTACK pS,int val)
{
    PNODE pNew = (PNODE)malloc(sizeof(NODE));       //创建一个新的节点
    pNew->data = val;
    pNew->pNext = pS->pTop;     //pNew->pNext = pS->pTop;空栈时可这样写，非空时禁止！
    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形参所指向的变量中，如果出栈失败，返回fasle，否则返回true*/
/*操作：出栈*/
/*前提条件：该箱子的入口地址，指向待出栈的值的指针pVal*/
/*后置条件：返回是否成功出栈*/
bool pop(PSTACK pS,int *pVal)
{
    if(empty(pS))
    {
        return false;
    }
    else
    {
        PNODE r = pS->pTop;
        *pVal = r->data;
        pS->pTop = pS->pTop->pNext;
        free(r);
        r = NULL;
        
        return true;
    }
}

/*操作：清空栈，回到创建栈的状态，即一个空栈*/
/*前提条件：该箱子的入口地址*/
/*后置条件：使栈为空*/
void clear_STACK(PSTACK pS)       //清空
{
    if(empty(pS))
    {
        return;
    }
    else
    {
        PNODE p = pS->pTop;
        PNODE q = NULL;
        
        while(p != pS->pBottom)
        {
            q = p->pNext;
            free(p);
            p = q;
        }
        pS->pTop = pS->pBottom;
    }
    return ;
}

程序运行示例：
————————————————————————————
6 4 3 2 1
出栈失败!

Program ended with exit code: 0
————————————————————————————