栈

基本定义

先进后出

==栈(Stack)==是只允许在一端进行插入和删除操作的线性表。

栈顶是允许进行插入、删除操作的那一端。

栈底是固定的，不允许进行插入、删除操作的那一端。

空栈是不含任何元素的栈。

n个不同元素进栈，出栈元素不同排列的个数为 1 n + 1 C n 2 n \frac{1}{n+1}C_{n}^{2n} n+11Cn2n。上述公式称为卡特兰(Catalan) 数，可采用数拿归纳法证明。

基本操作

InitStack(&S)：初始化栈。构造-一个空栈S，分配内存空间。

DestroyStack(&L)：销毁栈。销毁并释放栈S所占用的内存空间。

StackEmpty(S)：栈的判空

Push(&S,x)：进栈，若栈S未满，则将x加入使之成为新栈顶。

Pop(&S,&x)：出栈，若栈S非空，则弹出栈项元素，并用x返回。

GetTop(&S,&x)：读取栈顶元素。若栈非空，返回栈顶元素。

顺序栈

栈项指针: s.top, 初始时设置s.top=-1P;栈项元素: s.data[S. top].
进栈操作:栈不满时，栈顶指针先加1，再送值到栈项元素。
出栈操作:栈非空时，先取栈项元素值，再将栈顶指针减1。
栈空条件: s.top==-1;栈满条件: s. top==MaxSize-1;栈长: s. top+1。
由于顺序栈的入栈操作受数组上界的约束，当对栈的最大使用空间估计不足时，有可能发生
栈上溢，此时应及时向用户报告消息，以便及时处理，避免出错。
注意：栈和队列的判空、判满条件，会因实际给的条件不同而变化，上面提到的方法以及下面的代码实现只是在栈顶指针设定的条件下的相应方法，而其他情况则需具体问题具体分析。

#include<stdio.h>
#include<stdlib.h>
#define ElemType int//数据元素的类型
#define MaxSize 50
//定义顺序栈
typedef struct {
    ElemType data[MaxSize];//栈元素
    int top;//栈顶指针
}SequenceStack;
//初始化
int InitStack(SequenceStack& S) {
    S.top = -1;
    return 1;
}
//判空
bool StackEmpty(SequenceStack S) {
    if (S.top == -1)//栈空
        return true;
    else//非空
        return false;
}
//进栈，若栈S未满，则将x加入使之成为新栈顶。
int Push(SequenceStack& S, ElemType x) {
    if (S.top == MaxSize - 1)//栈满
        return 0;
    S.data[++S.top] = x;//指针加1并传入元素
    return 1;
}
//出栈，若栈S非空，则弹出栈项元素，并用x返回。
int Pop(SequenceStack& S, ElemType& x) {
    if (S.top == -1)//栈空
        return 0;
    x = S.data[S.top--];//传出元素并改变指针
    return 1;
}
//读取栈顶元素。若栈非空，返回栈顶元素。
int GetTop(SequenceStack& S) {
    ElemType x;
    if (S.top == -1)//栈空
        return 0;
    x = S.data[S.top];//传出元素
    return x;
}
int main() {
    SequenceStack S;
    ElemType x=0;
    int i;
    InitStack(S);
    printf_s("进栈：\n ");
    for (i = 0; i < 10; i+=2) {
        if (Push(S, i))
            printf_s(" %d进栈",i);
        else
            printf_s(" %d进栈失败", i);
    }
    printf_s("\n ");
    if(StackEmpty(S))
        printf_s("栈空\n ");
    else
        printf_s("非空\n ");
    printf_s("出栈：\n ");
    printf_s("栈顶元素为：%d\n ", GetTop(S));
    for (i = 0; i < 10; i += 2) {
        if (Pop(S, x))
            printf_s(" %d出栈", x);
        else
            printf_s(" 出栈失败",x);
    }
    printf_s("\n ");
    system("pause");
    return 0;
}

共享栈

两个栈共享同一片空间

#include<stdio.h>
#include<stdlib.h>
#define ElemType int//数据元素的类型
#define MaxSize 50
//定义共享栈
typedef struct {
    ElemType data[MaxSize];//栈元素
    int top0;//0号栈顶指针
    int top1;//1号栈顶指针
}ShowStack;
//初始化
int InitShowStack(ShowStack& S) {
    S.top0 = -1;
    S.top1 = MaxSize;
    return 1;
}
//判满 
bool ShowStackFull(ShowStack& S) {
    if (S.top0 + 1 == S.top1)//栈满
        return true;
    else
        return false;
}
//共享栈入栈
int ShowStackPush(ShowStack& S,int i, ElemType x) {
//i为栈号，取0或1；x为入栈元素
    if (i < 0 || i>1) {
        printf_s("栈号错误\n");
        return 0;
    }
    if (S.top0 + 1 == S.top1) {
        printf_s("栈满\n");
        return 0;
    }
    switch (i)
    {
    case 0:S.data[++S.top0] = x; return 1; break;
    case 1:S.data[--S.top1] = x; return 1; break;
    }
}
//共享栈出栈
int ShowStackPop(ShowStack& S, int i) {
    //i为栈号，取0或1
    if (i < 0 || i>1) {
        printf_s("栈号错误\n");
        return 0;
    }
    switch (i)
    {
    case 0:
        if (S.top0 == -1) {
            printf_s("栈空\n");
            return 0;
        }
        else {
            printf_s("%d出栈\n",S.data[S.top0]);
            S.top0--;
            return 0;
        }
    case 1:
        if (S.top1 == MaxSize) {
            printf_s("栈空\n");
            return 1;
        }
        else {
            printf_s("%d出栈\n",S.data[S.top1]);
            S.top1++;
            return 1;
        }
    }
}
int main(){
    ShowStack S;
    int i;
    InitShowStack(S);
    printf_s("进栈：\n ");
    for (i = 0; i < 10; i += 2) {
        if (ShowStackPush(S,0,i))
            printf_s(" 0号栈%d进栈", i);
        else
            printf_s(" 0号栈%d进栈失败", i);
        if (ShowStackPush(S, 1, i+1))
            printf_s(" 1号栈%d进栈", i+1);
        else
            printf_s(" 1号栈%d进栈失败", i+1);
    }
    printf_s("\n ");
    if (ShowStackFull(S))
        printf_s("栈满\n ");
    else
        printf_s("未满\n ");
    printf_s("0号栈出栈：\n ");
    for (i = 0; i < 10; i += 2) {
        ShowStackPop(S, 0);
    }
    printf_s("1号栈出栈：\n ");
    for (i = 0; i < 10; i += 2) {
        ShowStackPop(S, 1);
    }
    printf_s("\n ");
    system("pause");
    return 0;
}

链栈

相对于限制操作的链表

可以参考链表

栈的应用

栈的括号匹配

#include<stdio.h>
#include<stdlib.h>
#define MaxSize 10
typedef struct {
    char data[MaxSize];//栈元素
    int top;//栈顶指针
}SequenceStack;
//初始化
int InitStack(SequenceStack& S) {
    S.top = -1;
    return 1;
}
//判空
bool StackEmpty(SequenceStack S) {
    if (S.top == -1)//栈空
        return true;
    else//非空
        return false;
}
//进栈，若栈S未满，则将x加入使之成为新栈顶。
int Push(SequenceStack& S, char x) {
    if (S.top == MaxSize - 1)//栈满
        return 0;
    S.data[++S.top] = x;//指针加1并传入元素
    return 1;
}
//出栈，若栈S非空，则弹出栈项元素，并用x返回。
int Pop(SequenceStack& S, char& x) {
    if (S.top == -1)//栈空
        return 0;
    x = S.data[S.top--];//传出元素并改变指针
    return 1;
}
//括号匹配
bool braacketCheck(char str[], int length) {
    SequenceStack S;
    InitStack(S); //初始化一个栈
    for (int i = 0; i < length; i++) {
        if (str[i] == '(' || str[i] == '[' || str[i] == '{') {
            Push(S, str[i]); //扫描到左括号， 入栈
        }
        else {
            if (StackEmpty(S)) //扫描到右括号， 且当前栈空
                return false; //匹配失败
            char topElem;
            Pop(S, topElem);
            //栈顶元素出栈
            if (str[i] == ')' && topElem != '(')
                return false;
            if (str[i] == ']' && topElem != '[')
                return false;
            if (str[i] == '}' && topElem != '{')
                return false;
        }
    }
    return StackEmpty(S);//检索完所有括号后如果栈空说明匹配成功
}
int main() {
    char str[8] = {
    '{','[','[','(',')',']',']','}'};
    if (braacketCheck(str, 8)) {
        printf_s("匹配成功\n");
    }
    else {
        printf_s("匹配失败\n");
    }
    system("pause");
    return 0;
}