栈的初始化、压栈，栈的遍历、出栈、清空栈

最新推荐文章于 2022-04-05 20:46:20 发布

fly_lhw

最新推荐文章于 2022-04-05 20:46:20 发布

阅读量1.8k

点赞数

分类专栏：数据结构文章标签：栈源代码链表

本文链接：https://blog.youkuaiyun.com/fly_lhw/article/details/21842581

版权

数据结构专栏收录该内容

4 篇文章

订阅专栏

单片机技术大全请点击：https://item.taobao.com/item.htm?spm=686.1000925.0.0.9TTLHO&id=535006878999

一、栈的初始化

1.创建首个元素

2.将bottom的指针指向top指针指向的元素

3.将首个元素的直针指向空节点

<span style="font-size:24px;">//
//
//
void init_stack(PSTACK pStack)
{
    pStack->pTop = (PNODE)malloc(sizeof(NODE));
    if (pStack->pTop == NULL)
    {
        printf("malloc failed!\n");
        exit(-1);
    }
    else
    {
        pStack->pBottom = pStack->pTop;
        pStack->pTop->pNext = NULL;
    }
}
//
//
//</span>

二、压栈

1.创建一个新节点

2.给新节点的数据区写值

3.将新节点的pNext指针指向原来的栈顶元素

4.将pTop指针指向新的栈顶元素

<span style="font-size:24px;">//
//
void push_stack(PSTACK pStack, int val)
{
    PNODE pNew = (PNODE)malloc(sizeof(NODE));
    pNew->data = val;
    pNew->pNext = pStack->pTop;
    pStack->pTop = pNew;
}
//
//</span>

三、栈的遍历

1.将栈顶元素下移，并打印当前栈顶元素的值。

<span style="font-size:24px;">//
//
void traverse_stack(PSTACK pStack)
{
    PNODE p = pStack->pTop;
    int val;
    while(p != pStack->pBottom)
    {
        printf("%d ", p->data);
        p = p->pNext;
    }
    printf("\n");

    return ;
}
//
//</span>

四、出栈

1.定义一个局部PNODE直针，记录当前栈顶元素的位置和数据，

2.将栈顶元素下移，并释放下移之前的栈顶元素

<span style="font-size:24px;">//
//
bool pop_stack(PSTACK pStack, int *pVal)
{
    PNODE p = NULL;
    if (isempty_stack(pStack))
    {
        return false;
    }
    else
    {
        p = pStack->pTop;
        *pVal = p->data;
        pStack->pTop = p->pNext;
        free(p);
        p = NULL;

        return true;
    }
}
//
//</span>

五、清空栈

<span style="font-size:24px;">//
//
void clear_stack(PSTACK pStack)
{
    PNODE p = NULL;
    PNODE q = NULL;

    if (isempty_stack(pStack))
    {
        return;
    }
    else
    {
        p = pStack->pTop;

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

        pStack->pTop = pStack->pBottom;
    }
}
//
//</span>

源代码：

<span style="font-size:24px;">//stack.c
//
#include <stdio.h>
#include <stdbool.h>
#include <string.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);
void traverse_stack(PSTACK);
bool pop_stack(PSTACK pStack, int *pVal);
void clear_stack(PSTACK pStack);


int main(void)
{
    STACK stStack;
    int val = 0;

    init_stack(&stStack);
    printf("Start push stack...\n");
    push_stack(&stStack, 1);
    push_stack(&stStack, 2);
    push_stack(&stStack, 3);
    push_stack(&stStack, 4);
    push_stack(&stStack, 5);
    push_stack(&stStack, 6);
    push_stack(&stStack, 7);
    traverse_stack(&stStack);

    printf("After clear stack...\n");
    clear_stack(&stStack);

    if (pop_stack(&stStack, &val))
    {
        printf("pop successful, pop stack element is: %d\n", val);
    }
    else
    {
        printf("pop failed!\n");
    }

}

void init_stack(PSTACK pStack)
{
    pStack->pTop = (PNODE)malloc(sizeof(NODE));
    if (pStack->pTop == NULL)
    {
        printf("malloc failed!\n");
        exit(-1);
    }
    else
    {
        pStack->pBottom = pStack->pTop;
        pStack->pTop->pNext = NULL;
    }
}

void push_stack(PSTACK pStack, int val)
{
    PNODE pNew = (PNODE)malloc(sizeof(NODE));
    pNew->data = val;
    pNew->pNext = pStack->pTop;
    pStack->pTop = pNew;
}


void traverse_stack(PSTACK pStack)
{
    PNODE p = pStack->pTop;
    int val;
    while(p != pStack->pBottom)
    {
        printf("%d ", p->data);
        p = p->pNext;
    }
    printf("\n");

    return ;
}

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

bool pop_stack(PSTACK pStack, int *pVal)
{
    PNODE p = NULL;
    if (isempty_stack(pStack))
    {
        return false;
    }
    else
    {
        p = pStack->pTop;
        *pVal = p->data;
        pStack->pTop = p->pNext;
        free(p);
        p = NULL;

        return true;
    }
}

void clear_stack(PSTACK pStack)
{
    PNODE p = NULL;
    PNODE q = NULL;

    if (isempty_stack(pStack))
    {
        return;
    }
    else
    {
        p = pStack->pTop;

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

        pStack->pTop = pStack->pBottom;
    }
}
//
//</span>

运行结果：

[root@localhost struct_list]# make stack
cc stack.c -o stack
[root@localhost struct_list]# ./stack
Start push stack...
7 6 5 4 3 2 1
After clear stack...
pop failed!