栈的应用——迷宫问题的求解

利用栈实现迷宫问题的求解（找到迷宫的通路，如下面给定的迷宫，0代表通路，1代表不通，利用栈的特点，求出他的通路）

给定的迷宫：

1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1
0 0 0 1 1 1 1 1 1 1
1 1 0 1 1 1 1 1 1 1
1 1 0 1 1 1 1 1 1 1
1 1 0 1 1 1 1 1 1 1
1 1 0 0 0 0 0 0 1 1
1 1 0 1 1 1 1 0 1 1
1 1 0 1 1 1 1 0 1 1
1 1 0 1 1 1 1 1 1 1

自己实现的栈

#include<iostream>
using namespace std;
#include<assert.h>

template<class T>
class Stack
{
public:
Stack()
:_capacity(0)
,_data(NULL)
, _top(0)

{}

~Stack()
{
delete[] _data;
_data = NULL;
_top= _capacity = 0;
}

void Push(const T&x)
{
_CheckCapacity();
_data[_top++] = x;
}
void Pop()
{
if (!IsEmpty())
--_top;
}
bool IsEmpty()
{
return _top == 0;
}
bool IsFull()
{
return _top == _capacity;
}

T& Top()
{
return _data[_top-1];
}

void Display()
{
for (int i = 0; i < _top; ++i)
{
cout << _data[i] << " ";
}
cout << endl;
}
public:
void _CheckCapacity()
{
if (_top >= _capacity)
{
size_t NewCapacity = 2 * _top + 3;
T* tmp = new T[NewCapacity];
// memcpy(tmp, _data, sizeof(T)*size); //内置类型
for (int i = 0; i <_top; ++i)
{
tmp[i] = _data[i];
}
delete[] _data;
_data = tmp;
_capacity = NewCapacity;
}
}
private:
T* _data;
size_t _top;
size_t _capacity;
}

///////////////////////////////////////////////////////////////////

迷宫的几种操作：

#include"Stack.h"
const int N = 10;

struct Pos
{
int _row;
int _col;

Pos(int row=0,int col=0)
:_row(row)
,_col(col)
{}
};
void InitMaze(int *Maze) //初始化迷宫
{
FILE* fp = fopen("Maze.txt", "r");
assert(fp);

for (int i = 0; i < N; ++i)
{
for (int j = 0; j < N; )
{
int value = fgetc(fp);
if (value ==32 || value == 10)
continue;
Maze[i*N + j] = value - '0';
++j;
}
}
}

bool CheckAccess(int *Maze,Pos p,int rows,int cols)
{
return (p._col >= 0 && p._col < cols&&p._row >= 0 && p._row < rows&&Maze[p._row*rows+ p._col] == 0)；
}

bool GetPath(int *Maze, int cols, int rows, Stack<Pos>&s, Pos entry)
{
Pos cur = entry;
s.Push(entry);
Maze[entry._row*rows+ entry._col] = 2; //走过的路径被设为2
while (!s.IsEmpty())
{
Pos next = s.Top();
cur = next;
Maze[cur._row*rows + cur._col] = 2;

if (next._row == rows-1 || next._col == cols-1) //3面可以出
return true;

//右
next._col = next._col + 1;
if (CheckAccess(Maze, next, N, N))
{
s.Push(next);
continue;
}
next._col = next._col - 1;

//下
next._row = next._row + 1;
if (CheckAccess(Maze,next,N,N))
{
s.Push(next);
continue;
}
next._row = next._row - 1;

//上
next._row = next._row - 1;
if (CheckAccess(Maze, next, N, N))
{
s.Push(next);
continue;
}
next._row = next._row + 1;

//左
next._col = next._col - 1;
if (CheckAccess(Maze, next, N, N))
{
s.Push(next);
continue;
}
next._col = next._col + 1;

//右
next._col = next._col + 1;
if (CheckAccess(Maze, next, N, N))
{
s.Push(next);
continue;
}
next._col = next._col - 1;

s.Pop();
Maze[next._row * rows+ next._col] = 3; //如果走过的路径不通，则标记为3
}
return false;
}

void PrintMaze(int *Maze)
{
for (int i = 0; i < N; ++i)
{
for (int j = 0; j < N; ++j)
{
cout << Maze[i*N + j] << " ";
}
cout << endl;
}
cout << endl;
}

///////////////////////////////////////////////////////

测试：

#include"Maze.h"
void main()
{
int maze

;
InitMaze((int *)maze);
PrintMaze((int *)maze);

Stack<Pos> paths;
cout << "是否有通路？" <<GetPath((int *)maze, N, N, paths, Pos(2, 0)) << endl;
//cout << "是否有通路？" << GetPath( N, N,(int *)maze, paths, Pos(2, 0)) << endl;
PrintMaze((int *)maze);
}

测试结果：