[郝斌] 数据结构C语言—栈

1. 定义：一种可以实现“先进先出”的存储结构

2. 分类：静态栈和动态栈

3. 算法：压栈和出栈

4. 应用：函数调用，中断，表达式求值，内存分配，缓冲处理，迷宫

如下是进行数据结构--栈的程序实现，实现了栈空间数据

初始化： 初始化之后的结果是Stack的pTop和pTail指向一个空的头节点。

压栈：压栈要求pTop不断指向刚输入的有效节点，pTail只指向无效的头节点不动。

出栈：出栈会输出要删除节点的数据，随后删除节点。

遍历：从 struct Stack中的pTop开始不断向下遍历，输出每个节点的数据。

判空：当pTop等于pTail指向同一个节点时候，就表示栈空间为空。

清空：不断删除每个节点，释放栈空间，让pTop和pTail指向同一个节点。

pTop和pTail本身就是一个指针节点，就会指向一个栈空间的头和尾，并不需要用pTop->pNext去指向栈空间的头，这是第一次编程时候所犯的错误。

栈的数据结构的实现相当于是功能简化版本的链表实现。

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

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

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

void init_stack(PSTACK pstackNode);
bool push_stack(PSTACK pstackNode, int val);
bool pop_stack(PSTACK pstackNode, int* returnVal);
void show_stack(PSTACK pstackNode);
bool empty_stack(PSTACK pstackNode);
void clear_stack(PSTACK pstackNode);

int main()
{
    STACK Stack;
    int returnVal = 0;
    init_stack(&Stack);
    push_stack(&Stack, 2);
    push_stack(&Stack, 6);
    push_stack(&Stack, 27);
    push_stack(&Stack, 26);
    show_stack(&Stack);

    if(pop_stack(&Stack, &returnVal))
    {
        printf("delete Node is %d\n", returnVal);
    }
    show_stack(&Stack);

    clear_stack(&Stack);
    show_stack(&Stack);

    return 0;
}

void init_stack(PSTACK pstackNode)
{
    pstackNode->pTop = (PNODE)malloc(sizeof(NODE));
    if(pstackNode->pTop == NULL)
    {
        printf("init_stack malloc is error!\n");
        exit(1);
    }
    else
    {
        pstackNode ->pTail = pstackNode->pTop;
        pstackNode ->pTail ->pNext = NULL; //pstackNode ->pTop ->pNext = NULL;
    }

    return;
}

bool empty_stack(PSTACK pstackNode)
{
    if(pstackNode->pTail == pstackNode ->pTop)
    {
        return true;
    }
    else
    {
        return false;
    }
}

bool push_stack(PSTACK pstackNode, int val)
{
    PNODE pNew = (PNODE)malloc(sizeof(NODE));
    if (pNew == NULL)
    {
        printf("push_stack malloc Node error!!\n");
        exit(1);
    }
    else
    {
        pNew->data = val;
        pNew->pNext = pstackNode->pTop;
        pstackNode ->pTop = pNew;
    }
    return true;
}

bool pop_stack(PSTACK pstackNode, int *returnVal)
{
    if(empty_stack(pstackNode) == true)
    {
        printf("stack is empty!\n");
        return false;
    }
    else
    {
        PNODE pdeleteNode= pstackNode->pTop;
        *returnVal = pdeleteNode ->data;
        pstackNode->pTop = pdeleteNode ->pNext;
        free(pdeleteNode);
        pdeleteNode =NULL;

        return true;
    }
}

void show_stack(PSTACK pstackNode)
{
    printf("Let's show stack!\n");
    PNODE pShow = pstackNode ->pTop;
    while(pShow != (pstackNode->pTail))
    {
        printf("%d  \n", pShow->data);
        pShow = pShow->pNext;
    }
    return;
}

void clear_stack(PSTACK pstackNode)
{
    if(empty_stack(pstackNode) == true)
    {
            printf("stack is empty!\n");
            return;
    }
    else
    {
            PNODE pShow = pstackNode ->pTop;
            PNODE qShow = NULL;
            /*qShow = pShow-> pNext不能写在循环外面，可能只有一个有效节点*/
            while(pShow != (pstackNode->pTail))
            {
                qShow = pShow ->pNext;
                free(pShow);
                pShow = NULL;
                pShow = qShow;
            }
            pstackNode ->pTop = pstackNode ->pTail;
            return;
    }
}