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

#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");

}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值