2-2 栈——链栈（C/C++语言）

实现的功能

bool InitStack(LinkStack& S);    //初始化一个栈
bool StackEmpty(LinkStack S);   //判断栈是否为空
bool Push(LinkStack& S, int x);  //进栈
bool Pop(LinkStack& S, int& x);  //出栈
bool GetTop(LinkStack S, int& x);    //读栈顶元素
void ClearStack(LinkStack& S);   //清空栈

无头结点（对应于受限的无头单链表，仅在表尾插入和表尾删除）

完整代码：

/*
    Name:LinkStackNotHead(不带头链栈)
    Copyright:
    Author: Sdjzu_Nxy
    Date: 2023 年 2 月 27 日
    Description:
*/
#include<stdio.h>
#include<stdbool.h>
#include <malloc.h>

#define MaxSize 10      //定义最大长度

typedef struct LinkNode{
    int data;		//用静态的“数组”存放数据元素
    struct LinkNode* next;
} *LinkStackNotHead;					//类型定义

bool InitStack(LinkStackNotHead& S);    //初始化一个栈
bool StackEmpty(LinkStackNotHead S);   //判断栈是否为空
bool Push(LinkStackNotHead& S, int x);  //进栈
bool Pop(LinkStackNotHead& S, int& x);  //出栈
bool GetTop(LinkStackNotHead S, int& x);    //读栈顶元素
void ClearStack(LinkStackNotHead& S);   //清空栈

bool InitStack(LinkStackNotHead& S)
{
    S = NULL;
    return true;
}

bool StackEmpty(LinkStackNotHead S)
{
    return S == NULL ? true : false;
}

bool Push(LinkStackNotHead& S, int x)
{
    if (S == NULL) {
        LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
        s->data = x;
        s->next = NULL;
        S = s;
        return true;
    }

    LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));

    s->data = S->data;
    S->data = x;
    s->next = S->next;
    S->next = s;
    return true;
}

bool Pop(LinkStackNotHead& S, int& x)
{
    if (S == NULL) {
        return false;
    }

    LinkNode* p = S;
    x = S->data;
    S = p->next;
    free(p);
    return true;
}

bool GetTop(LinkStackNotHead S, int& x)
{
    if (S == NULL)
    {
        return false;
    }
    x = S->data;
    return true;
}

void ClearStack(LinkStackNotHead& S)
{
    if (S == NULL) {
        return;
    }
    LinkNode* p = S;
    while (p->next != NULL) {
        LinkNode* q = p;
        p = p->next;
        free(q);
    }
    S = NULL;
}

int main() {
    LinkStackNotHead S;

    InitStack(S);

    printf("The LinkStackNotHead is Empty? %d\n", StackEmpty(S));

    Push(S, 1);
    Push(S, 2);
    Push(S, 3);

    int x;
    if (GetTop(S, x)) {
        printf("The LinkStackNotHead Top data is %d.\n", x);
    }

    if (Pop(S, x))
    {
        printf("Pop LinkStackNotHead data is %d.\n", x);
    }

    if (Pop(S, x))
    {
        printf("Pop LinkStackNotHead data is %d.\n", x);
    }

    if (Pop(S, x))
    {
        printf("Pop LinkStackNotHead data is %d.\n", x);
    }

    if (Pop(S, x))
    {
        printf("Pop LinkStackNotHead data is %d.\n", x);
    }
    else
    {
        printf("The LinkStackNotHead is NULL!\n");
    }

    ClearStack(S);
    printf("The LinkStackNotHead is Empty? %d\n", StackEmpty(S));
}

运行结果：

带头结点（对应于受限的带头单链表，仅在标为插入，表尾删除）

完整代码：

/*
    Name:LinkStackWithHead(带头结点的链栈)
    Copyright:
    Author: Sdjzu_Nxy
    Date: 2023 年 2 月 28 日
    Description:
*/
#include<stdio.h>
#include<stdbool.h>
#include <malloc.h>

#define MaxSize 10      //定义最大长度

typedef struct LinkNode {
    int data;		//用静态的“数组”存放数据元素
    struct LinkNode* next;
} *LinkStackWithHead;					//类型定义

bool InitStack(LinkStackWithHead& S);    //初始化一个栈
bool StackEmpty(LinkStackWithHead S);   //判断栈是否为空
bool Push(LinkStackWithHead& S, int x);  //进栈
bool Pop(LinkStackWithHead& S, int& x);  //出栈
bool GetTop(LinkStackWithHead S, int& x);    //读栈顶元素
void ClearStack(LinkStackWithHead& S);   //清空栈

bool InitStack(LinkStackWithHead& S)
{
    S = (LinkNode*)malloc(sizeof(LinkNode));
    if (S == NULL) {
        return false;
    }
    S->next = NULL;
    return true;
}

bool StackEmpty(LinkStackWithHead S)
{
    return S->next == NULL ? true : false;
}

bool Push(LinkStackWithHead& S, int x)
{
    LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
    if (s == NULL) {
        return false;
    }
    s->data = x;
    s->next = S->next;
    S->next = s;
    return true;
}

bool Pop(LinkStackWithHead& S, int& x)
{
    if (S->next == NULL) {
        return false;
    }

    LinkNode* p = S->next;
    x = p->data;
    S->next = p->next;
    free(p);
    return true;
}

bool GetTop(LinkStackWithHead S, int& x)
{
    if (S->next == NULL)
    {
        return false;
    }
    x = S->next->data;
    return true;
}

void ClearStack(LinkStackWithHead& S)
{
    if (S->next == NULL) {
        return;
    }
    LinkNode* p = S->next;
    while (p != NULL) {
        LinkNode* q = p;
        p = p->next;
        free(q);
    }
    S->next = NULL;
}

int main() {
    LinkStackWithHead S;

    InitStack(S);

    printf("The LinkStackNotHead is Empty? %d\n", StackEmpty(S));

    Push(S, 1);
    Push(S, 2);
    Push(S, 3);

    int x;
    if (GetTop(S, x)) {
        printf("The LinkStackNotHead Top data is %d.\n", x);
    }

    if (Pop(S, x))
    {
        printf("Pop LinkStackNotHead data is %d.\n", x);
    }

    if (Pop(S, x))
    {
        printf("Pop LinkStackNotHead data is %d.\n", x);
    }

    if (Pop(S, x))
    {
        printf("Pop LinkStackNotHead data is %d.\n", x);
    }

    if (Pop(S, x))
    {
        printf("Pop LinkStackNotHead data is %d.\n", x);
    }
    else
    {
        printf("The LinkStackNotHead is NULL!\n");
    }

    ClearStack(S);
    printf("The LinkStackNotHead is Empty? %d\n", StackEmpty(S));
}

运行结果：