栈

栈是限定仅在表尾进行插入和删除的线性表。

#ifndef FIXED_CAPACITY
#include <iostream>
#include <string>
#define STACK_INT_SIZE 100//存储空间初始分配量
#define  STACKINCREMENT 10//存储空间分配增量
#define TRUE 1;
#define FALSE 0;
typedef int SElemType;
typedef bool Status;
using namespace std;
typedef struct {
    SElemType *base;
    SElemType *top;
    int stacksize;
}SqStack;
Status InitStack(SqStack *s) {
    s->base = (SElemType*)malloc(STACK_INT_SIZE*sizeof(SElemType));
    if (s->base == NULL) exit(1);
    s->top = s->base;
    s->stacksize = STACK_INT_SIZE;
    return TRUE;
}//形参&s是c++中特有的形参引用

Status DestroyStack(SqStack *s) {
    free(s->base);
    s->base = s->top = NULL;
    s->stacksize = 0;
    return TRUE;
}

Status ClearStack(SqStack *s) {
    s->top = s->base;
    s->stacksize = 0;
    return TRUE;
}

Status StackEmpty(SqStack *s) {
    if (s->top-s->base == 0)
        return 1;
    else
        return 0;
}

int StackLength(SqStack s) {
    return s.top-s.base;
}

Status GetTop(SqStack s, SElemType &e) {
    e = *(s.top);
    return TRUE;
}

Status Push(SqStack *s, SElemType e) {
    if (s->top - s->base >= s->stacksize) {
        s->base = (SElemType*)realloc(s->base, (s->stacksize + STACKINCREMENT)*sizeof(SElemType));
        if (s->base == NULL) exit(1);
        s->top = s->base + s->stacksize;
        s->stacksize += STACKINCREMENT;
    }
    *s->top = e;
    s->top++;
    return TRUE;
}

Status  Pop(SqStack *s, SElemType &e) {
    if (s->top == s->base)
        return FALSE;
    (s->top)--;
    e = *(s->top);
    return TRUE;
}

Status StackTraverse(SqStack s) {
    SElemType *p = s.base;
    for (int i = 0; i < s.top - s.base; i++)
        cout << p[i] << " ";
    cout << " ";
    return TRUE;
}
#endif FIXED_CAPACITY

应用一：数制转换
公式：N=（N div d）*d+N mod d

void conversion(int N) {
    SqStack s;
    int e;
    InitStack(&s);
    while (N) {
        Push(&s, N % 8);
        N = N / 8;
    }
    while (!StackEmpty(&s))
    {
        Pop(&s, e);
        cout << e;
    }
    cout << endl;
}

应用二：迷宫求解

　计算机解迷宫，通常使用的是穷举求解，即从入口出发，顺某一方向向前前行，若能走通，则继续往前走，否则沿原路返回，换另一方向再继续探索，直到所有的通路都探索完为止。
　为了保证能够原路退回，需要一个后进先出的结构来保存从入口到当前位置的路径，因此考虑使用栈。

do{
    if(当前位置可通){
        将当前位置插入栈顶；
        if(当前位置在出口位置)
            结束；
        else
            将当前位置的东临方块作为新的位置；
    }
}

测试用例

#include <iostream>
#include "FixedCapacityStackOfStrings.h"
#include <string>
using namespace std;
int main() {
    int a[10][10] = { {1,1,1,1,1,1,1,1,1,1},{1,0,0,1,0,0,0,1,0,1},{1,0,0,1,0,0,0,1,0,1},{1,0,0,0,0,1,1,0,0,1},{1,0,1,1,1,0,0,0,0,1},{1,0,0,0,1,0,0,0,0,1},{1,0,1,0,0,0,1,0,0,1}, {1,0,1,1,1,0,1,1,0,1},{1,1,0,0,0,0,0,0,0,1},{1,1,1,1,1,1,1,1,1,1} };
    for (int i = 0; i < 10; i++) {
        for (int j = 0; j < 10; j++) {
            cout << a[i][j]<<" ";
        }
        cout << endl;
    }
    PosType start;
    start.x = 1;
    start.y = 1;
    PosType end;
    end.x = 8;
    end.y = 8;
    cout << MazePath(a, start, end) << endl;
    for (int i = 0; i < 10; i++) {
        for (int j = 0; j < 10; j++) {
            cout << a[i][j] << " ";
        }
        cout << endl;
    }
    system("pause");

}