数据结构笔记#栈

可以说线性表的一个具体应用就是栈，可能看完以下代码你觉得这是什么嘛有什么卵用啊，但是栈在现实生活的中的应用，或者说这种概念的应用是非常广泛的。

比如说各种浏览器的返回上一级功能。

栈与线性表最大的差别就是它对数据的操控是受限的，遵守Last in First out(LIFO)“后进先出原则”的数据结构都可以叫栈。

栈一般长这个样子(美工欠下了3.5个亿带着他的小姨子跑了！)

右边是我们对线性表之单链表的正常理解，数据从表头到表尾依次排放。

左边是栈的特性，处于上层的元素（较新）叫top，处于底部的元素（最先放进去的那个）叫bottom。

这里注意一下top指针指向的位置，是一个空白的位置，而不是最顶层的那个数据。

而bottom指针则一直指向最底层的那个数据。

对栈的常见操作有push（入栈，将数据放入栈）和pop（出栈，将数据提取出来）。

这两个操作只能影响最顶层的元素。

以下是我的具体的代码实现，实现的方式有很多种，以下仅供参考。

 Github

首先是栈的头文件.h

Stack.h

声明一下结构体及函数。

链表一样，栈你可以搞成链式也可以搞成顺序的，这里我用了顺序存储结构，方便操作。

#ifndef _STACK_H_
#define _STACK_H_

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

//以下两个数据大小视实际情况而定
//初始栈容量
#define STACK_INIT_SIZE 10
//每次扩容的增量
#define STACKINCREMENT 10

typedef int DataType;

struct stack
{
    //指向栈最顶上的元素的接下来一个位置
    //表示新入栈的值可以放在指向的地方
    DataType *Top;
    //指向栈底部，最里面的元素
    DataType *Bottom;
    //表示了当前栈的容量
    int stacksize;
};
typedef struct stack STACK;

//新建栈
int InitStack(STACK *S);

//销毁栈
int DestroyStack(STACK *S);

//获取栈长度
int StackLength(STACK S);

//获取栈顶部元素
int GetTop(STACK S, DataType *e);

//Push操作，入栈，压栈
int Push(STACK *S, DataType e);

//Pop操作，出栈
int Pop(STACK *S, DataType *e);

//打印整表
int StackTraverse(STACK S);

#endif

Stack.c

不知道为什么感觉栈的代码比链表的简单。。。直接都贴上来吧。

首先是初始化链表和销毁链表。

int InitStack(STACK *S)
{
    //创建出设定长度的顺序表，地址赋给bottom指针
    S->Bottom = (DataType*)malloc(STACK_INIT_SIZE*sizeof(DataType));
    if (!S->Bottom)
    {
        return 0;
    }
    S->stacksize = STACK_INIT_SIZE;
    S->Top = S->Bottom;
    return 1;
}

int DestroyStack(STACK *S)
{
    S->Top = NULL;
    free(S->Bottom);
    S->Bottom = NULL;
    return 1;
}

然后是Push和Pop的函数，注释应该把代码解释的比较清楚了

int Push(STACK *S, DataType e)
{
    //当超出当前栈的容量时进行扩容
    //这里应该只有等于的情况
    //而不会大于
    if ((S->Top - S->Bottom) >= S->stacksize)
    {
        //realloc函数将开辟指定大小的储存空间
        //并将原来的数据全部移到这个新的储存空间
        S->Bottom = (DataType*)realloc(S->Bottom, (S->stacksize + STACKINCREMENT)*sizeof(DataType));
        if (!S->Bottom)
        {
            return 0;
        }
        //由于重新开辟了空间
        //需要重新根据bottom指针的位置指定top
        S->Top = S->Bottom + S->stacksize;
        //最后增加当前栈容量
        S->stacksize += STACKINCREMENT;
    }
    //再把入栈的数据存放好
    *(S->Top++) = e;
    return 1;
}

int Pop(STACK *S, DataType *e)
{
    if (S->Bottom == S->Top)
    {
        printf("Empty Stack!Can not pop!
");
        return 0;
    }
    //top指针先减1再取值
    *e = *(--S->Top);
    return 1;
}

然后是其他一些奇奇怪怪的“辅助”函数

int StackLength(STACK S)
{
    return  S.Top - S.Bottom;
}

int GetTop(STACK S, DataType *e)
{
    if (S.Bottom != S.Top)
    {
        //由于top指向的是最顶上元素的下一个位置
        //所以取出最顶上元素的时候
        //要把top减去1
        *e = *(S.Top - 1);
        return 1;
    }
    return 0;
}

最后是打印整个栈的数据的函数

int StackTraverse(STACK S)
{
    int timer = 0;
    int *cur=S.Bottom;
    if (S.Bottom ==S.Top)
    {
        printf("Empty!
");
        return 1;
    }
    while (cur < S.Top)
    {
        printf("%d) ", timer++);
        printf("%d
", *(cur++));
    }
    return 1;
}

最后随便写个main函数测试一下

Stacktest.c

#include"Stack.h"

int main()
{
    STACK s;
    int input=0;
    int output = 0;
    
    InitStack(&s);
    StackTraverse(s);

    while(scanf("%d",&input) && input!=999)
    {
        Push(&s, input);
    }
    StackTraverse(s);
    printf("Length: %d
", StackLength(s));;

    if (Pop(&s, &output))
    {
        printf("Poped : %d
", output);
    }

    DestroyStack(&s);
    return 0;
}

不同人的代码差别是很大的。。。但数据结构代码又没有一个标准，适和自己的需求就好，我也不敢确定我这么写最好。

如果感兴趣的话可以用栈做一个简单的计算器程序，用于计算比如

(3+(3-2))*10 = ？

这种的复合计算。

具体实现方法，我还在摸索。。