栈（顺序栈，多栈共享技术，动态顺序栈，链栈）

1.顺序栈

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

#define StackSize 10

//创建
typedef struct SeqStack
{
    int elem[StackSize];
    int top;//存放栈顶元素的下标 -1表示空栈
}SeqStack;

//初始化
void InitStack(SeqStack *S)
{
    S->top = -1;
}

//入栈
int Push(SeqStack *S, int elem)
{
    if (S->top == StackSize - 1)
    {
        return 0;
    }

    S->top++;
    S->elem[S->top] = elem;
    return 1;
}

//出栈
int Pop(SeqStack *S, int *elem)
{
    if (S->top == -1)
    {
        return 0;
    }

    *elem = S->elem[S->top];
    S->top--;
    return 1;
}

int main()
{
    SeqStack S;
    InitStack(&S);
    int i = 0;
    int ret = 0;
    int PopElem = 0;

    printf("入栈<:");
    for (i = 0; i < 10; i++)
    {
        ret = Push(&S, i + 1);

        if (ret == 0)
        {
            printf("\n栈满！");
            break;
        }

        printf("%d ", S.elem[i]);
    }

    printf("\n前4个元素出栈<:");
    for (i = 0; i < 4; i++)
    {
        ret=Pop(&S, &PopElem);

        if (ret == 0)
        {
            printf("\n栈空！");
            break;
        }

        printf("%d ", PopElem);
    }

    printf("\n");
    system("pause");
    return 0;
}

2. 双端顺序栈

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

#define M 20

//创建
typedef struct DqStack
{
    int elem[M];
    int top[2];//栈顶指示器，分别存放两个栈顶的下标
}DqStack;

//初始化
void InitStack(DqStack *D)
{
    D->top[0] = -1;
    D->top[1] = M;

}

//第i号栈入栈
int Push(DqStack *D, int elem, int i)
{
    if (D->top[0] + 1 == D->top[1])//栈满
        return 0;

    switch (i)
    {
    case 0:{
               D->top[0]++;
               D->elem[D->top[0]] = elem;
               break;
    }

    case 1:{
               D->top[1]--;
               D->elem[D->top[1]] = elem;
               break;
    }
    default:
        break;
    }

    return 1;
}

//第i号栈出栈
int Pop(DqStack *D, int *elem, int i)
{
    switch (i)
    {
    case 0:{
               if (D->top[0] == -1)
                   return 0;
               *elem = D->elem[D->top[0]];
               D->top[0]--;
               break;
    }

    case 1:{
               if (D->top[1] == M)
                   return 0;
               *elem = D->elem[D->top[1]];
               D->top[1]++;
               break;
    }
    default:
        break;
    }

    return 1;
}

int main()
{
    DqStack D;
    InitStack(&D);
    int i = 0;
    int ret = 0;
    int n = M;
    int elem = 0;

    printf("第0号栈入栈<:");
    for (i = 0; i < 10; i++)
    {
        ret = Push(&D, i + 1,0);//0号栈入栈
        if (ret == 0)
        {
            printf("\n栈满！");
            break;
        }
        printf("%d ", D.elem[i]);
    }

    printf("\n第1号栈入栈<:");
    for (i = 0; i < 5; i++)
    {
        ret = Push(&D,i+2,1);
        if (ret == 0)
        {
            printf("\n栈满！");
            break;
        }
        printf("%d ", D.elem[--n]);
    }

    printf("\n第0号栈前五个元素出栈<:");
    for (i = 0; i < 5; i++)
    {
        ret = Pop(&D, &elem,0);
        if (ret == 0)
        {
            printf("\n栈空！");
            break;
        }
        printf("%d ", elem);
    }

    printf("\n第1号前三个元素栈出栈<:");
    for (i = 0; i < 3; i++)
    {
        ret = Pop(&D, &elem, 1);
        if (ret == 0)
        {
            printf("\n栈空！");
            break;
        }
        printf("%d ", elem);
    }

    printf("\n");
    system("pause");
    return 0;
}

3.动态顺序栈(将二进制数转换为十进制数)

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

#define StackSize 20
typedef char ElemType;


//创建
typedef struct Stack
{
    ElemType *base;//指向栈底
    ElemType *top;//指向栈顶
    int stacksize;
}SqStack;

//检查指针
void CheckPtr(void *ptr)
{
    if (ptr == NULL)
        exit(EXIT_FAILURE);
}
//初始化
void InitStack(SqStack *S)
{
    S->base = (ElemType *)malloc(StackSize*sizeof(ElemType));
    CheckPtr(S->base);
    S->top = S->base;
    S->stacksize = StackSize;
}

//入栈
void Push(SqStack *S, int elem)
{
    ElemType *tmp;

    if (S->top - S->base == S->stacksize) //栈满，追加
    {
        tmp = (ElemType *)realloc(S->base, (S->stacksize + StackSize)*sizeof(ElemType));
        CheckPtr(tmp);
        S->base = tmp;
        S->top = S->base + S->stacksize;
        S->stacksize += StackSize;
    }
    *(S->top) = elem;
    S->top++;
}

//出栈
void Pop(SqStack *S,ElemType *elem)
{
    --S->top;
    *elem = *(S->top);
}

//销毁栈
void DesStack(SqStack *S)
{
    free(S->base);
    S->base = S->top = NULL;
    S->stacksize = 0;
}

int main()
{
    ElemType c;
    ElemType elem;
    SqStack S;
    InitStack(&S);
    int len = 0;
    int i = 0;
    int d = 0;

    printf("请输入二进制数<:");
    scanf("%c", &c);
    while (c!='#')
    {
        Push(&S,c);  //二进制数入栈
        scanf("%c", &c);
    }

    len = S.top-S.base;//栈当前的长度

    for (i = 0; i < len; i++)
    {
        Pop(&S, &elem);
        d += (elem-48)*pow(2, i);
    }

    printf("d=%d", d);

    DesStack(&S);//销毁栈

    printf("\n");
    system("pause");
    return 0;
}

4.链栈

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

typedef int StackElem;

//定义
typedef struct node
{
    StackElem data;
    struct node *next;
}LinkStackNode,*LinkStack;

//初始化
void InitStack(LinkStack *S)
{
    *S = (LinkStack)malloc(sizeof(LinkStackNode));
    if (*S == NULL)
    {
        exit(EXIT_FAILURE);
    }
    (*S)->next = NULL;
}

//入栈
void Push(LinkStack *S, StackElem elem)
{
    LinkStack new;
    LinkStack t = *S;//t指向头结点，即栈顶
    new = (LinkStack)malloc(sizeof(LinkStackNode));
    if (new == NULL)
    {
        exit(EXIT_FAILURE);
    }

    new->data = elem;
    new->next = t->next;
    t->next = new;
}

//出栈
int Pop(LinkStack *S, StackElem *elem)
{
    LinkStack tmp;
    tmp = (*S)->next;

    if (tmp == NULL)
        return 0;

    (*S)->next = tmp->next;
    *elem = tmp->data;
    free(tmp);
    return 1;
}

int main()
{
    LinkStack S;
    LinkStack tmp;
    int i = 0;
    StackElem elem;

    InitStack(&S);//初始化，建立带头结点的空链栈，并且该头结点作为栈顶指针

    printf("入栈<:");
    for (i = 0; i < 10; i++)
    {
        Push(&S, i+1);//入栈
        printf("%d ", i + 1);
    }

    printf("\n出栈<:");
    while (1)
    {
        if (Pop(&S, &elem) != 0)
        {
            printf("%d ", elem);
        }
        else
            break;
    }

    printf("\n");
    system("pause");
    return 0;
}