数据结构 - 链栈的实行（C语言）

数据结构-链栈的实现

1 链栈的定义

现在来看看栈的链式存储结构，简称为链栈。

想想看栈只是栈顶来做插入和删除操作，栈顶放在链表的头部还是尾部呢？由于单链表有头指针，而栈顶指针也是必须的，那干吗不让它俩合二为一呢，所以比较好的办法是把栈顶放在单链表的头部（如下图所示)。另外，都已经有了栈顶在头部了，单链表中比较常用的头结点也就失去了意义，通常对于链栈来说，是不需要头结点的。

对于空栈来说，链表原定义是头指针指向空，那么链栈的空其实就是 top=NULL 的时候。

链栈的结构代码如下:

/* 链栈结点结构 */
typedef struct StackNode
{
        SElemType data;
        struct StackNode *next;
}StackNode,*LinkStackPtr;

/* 链栈结构 */
typedef struct
{
        LinkStackPtr top;
        int count;
}LinkStack;

链栈的操作绝大部分都和单链表类似，只是在插入和删除上，特殊一些。

2 进栈操作

对于链栈的进栈push操作，假设元素值为e的新结点是s，top为栈顶指针，示意图如下图所示。

代码如下：

/* 插入元素e为新的栈顶元素 */
Status Push (LinkStack *S, SElemType e)
{
    LinkStackPtr s = (LinkStack *)malloc(sizeof(StackNode));
    s->data = e;

    s->next = S->top; /* 把当前的栈顶元素赋值给新结点的直接后继，见图中① */
    S->top = s; /* 将新的结点s赋值给栈顶指针，见图中② */
    S->count++;

    return TRUE;
}    

3 出栈操作

至于链栈的出栈pop操作，也是很简单的三句操作。假设变量P用来存储要删除的栈顶结点，将栈顶指针下移一位，最后释放p即可，如下图所示。

/* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
Status Pop(LinkStack *S,SElemType *e)
{
        LinkStackPtr p;
        if(StackEmpty(*S))
                return ERROR;
        *e=S->top->data;
        p=S->top; /* p用来存储要删除的栈顶结点，见图中③ */
        S->top=S->top->next; /* 使得栈顶指针下移一位，指向后一结点，见图中④ */
        free(p); /* 释放结点p */
        S->count--;
        return OK;
}

链栈的进栈push 和出栈pop 操作都很简单，没有任何循环操作，时间复杂度均为O(1)。

4 完整实现

#include "stdafx.h"
#include "stdlib.h"   

#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status;
typedef int SElemType; /* SElemType类型根据实际情况而定，这里假设为int */

/* 链栈结点结构 */
typedef struct StackNode
{
    SElemType data;
    struct StackNode *next;
}StackNode, *LinkStackPtr;

/* 链栈结构 */
typedef struct
{
    LinkStackPtr top;
    int count;
}LinkStack;

Status visit(SElemType c)
{
    printf("%d ", c);
    return TRUE;
}

/*  构造一个空栈S */
Status InitStack(LinkStack *S)
{
    S->top = (LinkStackPtr)malloc(sizeof(StackNode));
    if (!S->top)
        return FALSE;
    S->top = NULL;
    S->count = 0;
    return TRUE;
}

/* 把S置为空栈 */
Status ClearStack(LinkStack *S)
{
    LinkStackPtr p, q;
    p = S->top;
    while (p)
    {
        q = p;
        p = p->next;
        free(q);
    }
    S->count = 0;
    return TRUE;
}

/* 若栈S为空栈，则返回TRUE，否则返回FALSE */
Status StackEmpty(LinkStack S)
{
    if (S.count == 0)
        return TRUE;
    else
        return FALSE;
}

/* 返回S的元素个数，即栈的长度 */
int StackLength(LinkStack S)
{
    return S.count;
}

/* 若栈不空，则用e返回S的栈顶元素，并返回TRUE；否则返回FALSE */
Status GetTop(LinkStack S, SElemType *e)
{
    if (S.top == NULL)
        return FALSE;
    else
        *e = S.top->data;
    return TRUE;
}

/* 插入元素e为新的栈顶元素 */
Status Push(LinkStack *S, SElemType e)
{
    LinkStackPtr s = (LinkStackPtr)malloc(sizeof(StackNode));
    s->data = e;
    s->next = S->top;   /* 把当前的栈顶元素赋值给新结点的直接后继，见图中① */
    S->top = s;         /* 将新的结点s赋值给栈顶指针，见图中② */
    S->count++;
    return TRUE;
}

/* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回TRUE；否则返回FALSE */
Status Pop(LinkStack *S, SElemType *e)
{
    LinkStackPtr p;
    if (StackEmpty(*S))
        return FALSE;
    *e = S->top->data;
    p = S->top;                 /* p用来存储要删除的栈顶结点，见图中③ */
    S->top = S->top->next;    /* 使得栈顶指针下移一位，指向后一结点，见图中④ */
    free(p);                    /* 释放结点p */
    S->count--;
    return TRUE;
}

Status StackTraverse(LinkStack S)
{
    LinkStackPtr p;
    p = S.top;
    while (p)
    {
        visit(p->data);
        p = p->next;
    }
    printf("\n");
    return TRUE;
}

int main()
{
    int j;
    LinkStack s;
    int e;
    if (InitStack(&s) == TRUE)
        for (j = 1; j <= 10; j++)
            Push(&s, j);
    printf("栈中元素依次为：");
    StackTraverse(s);
    Pop(&s, &e);
    printf("弹出的栈顶元素 e=%d\n", e);
    printf("栈空否：%d(1:空 0:否)\n", StackEmpty(s));
    GetTop(s, &e);
    printf("栈顶元素 e=%d 栈的长度为%d\n", e, StackLength(s));
    ClearStack(&s);
    printf("清空栈后，栈空否：%d(1:空 0:否)\n", StackEmpty(s));
    return 0;
}

/*
输出结果：

栈中元素依次为：10 9 8 7 6 5 4 3 2 1
弹出的栈顶元素 e=10
栈空否：0(1:空 0:否)
栈顶元素 e=9 栈的长度为9
清空栈后，栈空否：1(1:空 0:否)
*/

原文地址：https://www.cnblogs.com/linuxAndMcu/p/10327790.html