算法导论9：栈的链表实现 2016.1.9

一直想做一个链表实现的栈，今天终于实现了。确实比数组要难多了，打了很久，很长时间花在了想象上（指针调试比较复杂。。）

但是链表实现有一个最大的好处，就是动态分配内存，所以一般不会出现栈顶溢出的问题。

值得一提的是代码中比昨天的多了一个build函数。建立一个新栈。那么init函数，还是初始化一个栈。昨天用数组写的时候这两个函数是一样的。但是用链表之后才发现两者还是有区别。一个是从无到有，一个是从有到无。只不过数组的时候本来都有，不涉及自己申请空间的问题，所以两个的操作可以相同，但是到了链表，内存要自己申请和释放，这两个函数也就不一样了。不过写完这个栈，我对c++里封装的集合对象有了一点想法，不知道和我想的是不是一样。等假期看c++primer的时候看一下。

下面是代码：

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

typedef struct _node{
    int num;
    struct _node *next;
}node;

struct stack {
    node * bottom;
    node * top;
}s;

void build(struct stack &S)
{
    S.bottom=(node *)malloc(sizeof(node));
    S.bottom->next=NULL;
    S.top=(node *)malloc(sizeof(node));
    S.top->next=S.bottom;
}

int sempty(struct stack &S)
{
    if ((S.top)->next==S.bottom) return 1;
    else return 0;
}

int pop(struct stack &S)
{
    if (sempty(S)) {
        printf("栈为空，弹出失败！\n");
    }
    else {
        node *p;
        p=S.top;
        S.top=(S.top)->next;
        int k=p->num;
        free(p);
        return k;
    }
}

void init(struct stack &S)
{

    while (!sempty(S)) {
        pop(S);
    }
}

void push(struct stack &S,int n)
{
    node *p;
    p=(node *)malloc(sizeof(node));
    p->num=n;
    p->next=S.top;
    S.top=p;
}

void showstack(struct stack S)
{
    while ((S.top)->next!=S.bottom){
        int k=(S.top)->num;
        S.top=(S.top)->next;
        printf("|%d|\n",k);
    }
    printf("| |\n");
    printf(" - \n");
}

int main()
{
    printf("1：初始化栈；2：入栈；3：出栈；4:退出。\n");
    build(s);
    int n;
    while (1) {
        int k;
        scanf("%d",&k);
        switch(k) {
            case 1:init(s); break;
            case 2:scanf("%d",&n); push(s,n); break;
            case 3:pop(s); break;
            case 4:return 0;
        }
        showstack(s);
    }
    return 0;
}