栈的链式存储结构

4.2 栈的链式存储结构

4.2.1 栈的链式存储结构简介

我们上节学过，栈顺序结构的大小是固定的，一旦初始化后就无法动态调整大小，可能会浪费内存或导致栈溢出。由此出现了栈的链式存储结构，可以动态调整大小，其结构和单链表其实类似，下图是栈的链式存储结构示意图：

相比栈的顺序结构，除了都有栈顶指针top之外，栈的链式结构还多了一条指向下一结点的指针。

下面是会涉及到的操作函数的表：

4.2.2 栈的链式存储结构定义

链栈中一个结点包含存储的数据data，以及一个指向下个结点的next指针。而一整个栈链是由多个结点和一个栈顶指针top组成。

链栈类的代码如下：

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

typedef struct{
    LinkStackPtr top;
    int count;		//用于存储栈的长度
}LinkStack;

4.2.3 初始化栈和清空栈

1.初始化栈

链栈的初始状态，栈为空，栈顶指针指向NULL，代码如下：

/*初始化链栈*/
Status InitStack(LinkStack *S){
    S->top = (LinkStackPtr)malloc(sizeof(StackNode));
    if(!S->top){
        return ERROR;
    }
    S->top = NULL;       //链栈为空 top指向null
    S->count = 0;
    return OK;
}

2.清空栈

/*清空链栈*/
Status ClearStack(LinkStack *S){
    LinkStackPtr p,q;
    p = S->top;
    while(p){
        q = p;
        p = p->next;
        free(q);
    }
    S->count = 0;
    return OK;
}

首先定义两个栈链指针p,q，然后将栈顶元素赋值给p，当p不为空时，先让q=p，然后将p指针向后移动，在释放q，这就完成删除一个结点，随着while循环的进行，栈中每个结点都会被释放。

4.2.4 判断栈空和获取栈长度

1. 判断栈是否为空

因为我们在定义链栈的时候引入了成员变量count，用于记录栈长度，所以判断是否为空变得十分简单，只要判断count==0是否成立，代码如下：

/*判断链栈是否为空*/
Status StackEmpty(LinkStack S){
    if(S.count==0){
        return True;
    }else{
        return False;
    }
}

2. 获取栈长度

直接返回count的值即可，代码如下：

/*判断链栈是否为空*/
Status StackEmpty(LinkStack S){
    if(S.count==0){
        return True;
    }else{
        return False;
    }
}

4.2.5 获取栈顶元素

直接将top指针指向的元素存入指针e中即可，代码如下：

/*获取栈顶元素*/
Status GetTop(LinkStack S,SElemType *e){
    if(S.top==NULL){
        return ERROR;
    }else{
        *e = S.top->data;
    }
    return OK;
}

4.2.6 入栈和出栈

1. 入栈

创建一个新结点s并且将其加入到栈中，图解如下：

• 创建结点s，并将数据存入其中。
• 结点s插入到栈中，让s->next指向栈顶指针指向的位置。
• 然后将栈顶指针top移到新加入的结点s处。
• 最后将栈长度加1，即count+1。

2. 出栈

删除的操作不复杂，和单链表的删除类似，图解如下：

• 先判断栈是否为空。
• 定义一个结点指针p，将栈顶结点赋值给p，p=S->top
• 然后再将栈顶指针向下移动，S->top = S->top->next
• 释放p结点，最后再将栈长度减1，count--

4.2.7 遍历并打印栈

这个实现和上一节差不多，代码如下：

//遍历栈链
Status visit(SElemType c){
    printf("%d ",c);
    return OK;
}


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

4.2.8 测试

测试代码如下：

int main()
{
        int j;
        LinkStack s;
        int e;
        if(InitStack(&s)==OK)
                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));

        system("pause");
        return 0;
}

运行结果：

栈中元素依次为：10 9 8 7 6 5 4 3 2 1
弹出的栈顶元素 e=10
栈空否：0(1:空 0:否)
栈顶元素 e=9 栈的长度为9
清空栈后，栈空否：1(1:空 0:否)
请按任意键继续. . .

4.2.9 完整代码

最后附上完整代码：

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

#define OK 1
#define ERROR 0
#define True 1
#define False 0
#define MAXSIZE 20

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

typedef struct{
    LinkStackPtr top;
    int count;
}LinkStack;


/*初始化链栈*/
Status InitStack(LinkStack *S){
    S->top = (LinkStackPtr)malloc(sizeof(StackNode));
    if(!S->top){
        return ERROR;
    }
    S->top = NULL;       //链栈为空 top指向null
    S->count = 0;
    return OK;
}

/*清空链栈*/
Status ClearStack(LinkStack *S){
    LinkStackPtr p,q;
    p = S->top;
    while(p){
        q = p;
        p = p->next;
        free(q);
    }
    S->count = 0;
    return OK;
}

/*判断链栈是否为空*/
Status StackEmpty(LinkStack S){
    if(S.count==0){
        return True;
    }else{
        return False;
    }
}

/*获取栈链长度*/
int StackLength(LinkStack S){
    return S.count;
}

/*获取栈顶元素*/
Status GetTop(LinkStack S,SElemType *e){
    if(S.top==NULL){
        return ERROR;
    }else{
        *e = S.top->data;
    }
    return OK;
}


/*入栈*/
Status Push(LinkStack *S,SElemType e){
    LinkStackPtr s = (LinkStackPtr)malloc(sizeof(StackNode));
    s->data = e;
    s->next = S->top;     
    S->top = s;         //top指针移到s处
    
    S->count++;         //入栈后长度加1
    return OK;
}

/*出栈*/
Status Pop(LinkStack *S,SElemType *e){
    LinkStackPtr p;
    //判断栈是否为空
    if(StackEmpty(*S))
        return ERROR;
    *e = S->top->data;
    p = S->top;
    S->top = S->top->next;      //将栈顶后一元素赋值给栈顶
    free(p);
    S->count--;
    return OK;
}

//遍历栈链
Status visit(SElemType c){
    printf("%d ",c);
    return OK;
}


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

int main()
{
        int j;
        LinkStack s;
        int e;
        if(InitStack(&s)==OK)
                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));

        system("pause");
        return 0;
}