数据结构---堆栈的特点及C语言实践

堆栈

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

• 分类：

  静态栈（基于数组）

  动态栈（基于链表）

• 算法：压栈；出栈

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

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;


//初始化
void init_stack(PSTACK);
//入栈
void push_stack(PSTACK, int);
//出栈
int pop_stack(PSTACK);
//遍历栈
void traverse_stack(PSTACK);
//判断栈是否为空
bool is_empty(PSTACK);
//清空栈
void clear(PSTACK);

int main(void)
{
    int val;//出栈的值
    STACK s;
    init_stack(&s);//目的是造出一个空栈
    push_stack(&s, 1);//压栈
    push_stack(&s, 2);
    push_stack(&s, 3);
    push_stack(&s, 4);
    push_stack(&s, 5);
    traverse_stack(&s);
    val = pop_stack(&s);
    printf("出栈数：%d\n",val);
    traverse_stack(&s);

    return 0;
}

void init_stack(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;
    }
    return;
}

void push_stack(PSTACK pS, int val)
{
    PNODE pNew = (PNODE)malloc(sizeof(NODE));
    if (NULL == pNew)
    {
        printf("分配内存失败，程序终止！\n");
        exit(-1);
    }
    pNew->data = val;
    pNew->pNext = pS->pTop;//指向原来的top，即新建一个节点，就会指向上一个节点
    pS->pTop = pNew;
    return;
}

void traverse_stack(PSTACK pS)
{

    PNODE p = pS->pTop;
    printf("栈中的数据：");
    while (p != pS->pBottom)
    {
        printf("%d ", p->data);
        p = p->pNext;
    }
    printf("\n");
    return;
}

bool is_empty(PSTACK pS)
{
    if (pS->pTop == pS->pBottom)
        return true;
    else
        return false;
}

int pop_stack(PSTACK pS)
{
    int pVal;
    if (is_empty(pS)) {
        return false;
    }
    else
    {
        PNODE p = pS->pTop;
        pVal = p->data;
        pS->pTop = p->pNext;
        free(p);
        p = NULL;
        return pVal;
    }
}

void clear(PSTACK pS)
{
    if (is_empty(pS))
        return;
    else
    {
        PNODE p = pS->pTop;
        PNODE q = NULL;
        if (p != pS->pBottom)
        {
            q = p->pNext;
            free(p);
            p = q;
        }
        pS->pTop = pS->pBottom;
    }
    return;
}