栈的链式存储结构及C实现

栈的链式存储结构，简称链栈。

考虑链表都有一个头指针，而栈都有一个栈顶；不妨把栈的栈顶就看成链表的头指针。

单链表的基本数据结构是结点，每个结点有数据域和指针域两个属性；

栈的数据结构要考虑栈顶指向哪，栈的长度是多少；而栈顶应该指向一个结点，结点又有数据域和指针域；

#include <stdio.h>
#include <stdlib.h>
//栈的链式存储
#define OK 1
#define ERROR -1
typedef int ElemType;
typedef int Status;

与单链表一样，先声明每个结点的数据结构；声明一个指向结点类型的指针（作为栈顶）；

typedef struct Node{
    ElemType data;
    struct Node *next;
}Node,*LinkStackPtr;

接下来，根据LinkStackPtr来定义栈的数据结构（栈顶，栈长）

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

然后就是一系列的操作实现

/*初始化*/
Status InitStack(LinkStack *S){
    //新建一个空的结点
    LinkStackPtr s=(LinkStackPtr)malloc(sizeof(Node));
    s->data=NULL;
    s->next=NULL;
    S->top=s;
    S->count=0;
    return OK;
}
/*创建一个长度为n的链栈*/
Status CreateStack(LinkStack *S,int n){
    LinkStackPtr T;//临时结点
    int i;
    srand(time(0));
    for(i=0;i<n;i++){
        T=(LinkStackPtr)malloc(sizeof(Node));
        T->data=rand()%100+1;
        T->next=S->top;
        S->top=T;
        S->count++;
    }
    return OK;

}
/*判断链栈是否为空*/
Status StackEmpty(LinkStack S){
    if(S.count==0 && S.top==NULL){
        return OK;
    }else{
        return ERROR;
    }
}
/*插入元素e为新的栈顶元素*/
Status Push(LinkStack *S,ElemType e){
    LinkStackPtr s=(LinkStackPtr)malloc(sizeof(Node));
    s->data=e;
    s->next=S->top;//指向原来的栈顶
    S->top=s;//更新栈顶
    S->count++;//栈长增加
    return OK;
}
/*若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR*/
Status Pop(LinkStack *S,ElemType *e){
    LinkStackPtr p;
    if(OK==StackEmpty(*S))
        return ERROR;
    *e=S->top->data;
    p=S->top;
    S->top=S->top->next;
    free(p);
    S->count--;
    return OK;
}

在main中测试

int main()
{
   LinkStack S,T;
   if(OK!=InitStack(&S)){
        printf("初始化失败！");
        return ERROR;
   }
   int n;
   printf("输入要创建的链栈长度:\n");
   scanf("%d",&n);
   if(OK==CreateStack(&S,n)){
        T=S;//更新链栈
        printf("栈的长度为%d\n",S.count);
        while(T.count){
            printf("%d\t",(T.top)->data);
            T.top=(T.top)->next;
            T.count--;
        }
   }
   printf("测试入栈！\n");
   printf("输入想要入栈的元素\n");


   int e;
   while(1==scanf("%d",&e)){
        if(OK==Push(&S,e)){
            T=S;
        printf("\n栈的长度为%d\n",T.count);
        while(T.count){
            printf("%d\t",(T.top)->data);
            T.top=(T.top)->next;
            T.count--;
        }


        }
   }


    printf("测试出栈！\n");
    T=S;//更新链栈
    while(T.count){
            if(OK==Pop(&T,&e)){
                printf("%d\t",e);
            }
    }
    printf("全部出栈成功");


    return 0;
}

运行结果：

对比一下栈的是顺序存储结构和链式存储结构，它们在时间复杂度上都是一样的，均为O（1）。但是顺序存储结构必须事先声明一段连续的内存空间，可能会造成空间的浪费，它的优势是存取定位很方便；而链栈要求每个元素都有指针域，增加了一些内存开销，但对于栈的长度无限制。

因此，如果栈的长度变化不大或者在可控范围内，用顺序存储结构较好；如果栈的长度波动大或者不想事先分配内存空间，则用链式存储结构较好。