栈求解迷宫

//Stack.h
//栈
#pragma once
#include <Windows.h>
#include <assert.h>

template <class T>
class CStack
{
public:
	CStack(int nSize = 100);
	~CStack(void);

public:
	bool Push(T Item);
	T    Pop();
	T&   GetTop();

	bool IsEmpty();
	bool IsFull();

	int  Size();

private:
	T*  m_pData;
	T*  m_pBase;
	T*  m_pTop;

	int m_nStackSize;
	int m_nLength;
};

template <class T>
CStack<T>::CStack( int nSize /*= 100*/ )
{
	assert (nSize > 0);

	m_pData   = new T[nSize];
	m_pBase   = NULL;
	m_pTop    = NULL;

	m_nLength    = 0;
	m_nStackSize = nSize;
}

template <class T>
CStack<T>::~CStack( void )
{
	delete []m_pData;
}

template <class T>
bool CStack<T>::Push( T Item )
{
	if (IsFull())
		return false;

	if (IsEmpty())
	{
		m_pBase = &m_pData[0];
		m_pTop  = &m_pData[0];
		*m_pTop = Item;
	}
	else
	{
		m_pTop++;
		*m_pTop = Item;
	}

	m_nLength++;

	return true;
}

template <class T>
T CStack<T>::Pop()
{
	if (IsEmpty())
		assert(0);

	T Item = *m_pTop;
	
	if (m_pTop == m_pBase)
	{
		m_pTop  = NULL;
		m_pBase = NULL;
	}
	else
	{
		m_pTop--;
	}

	m_nLength--;

	return Item;
}

template <class T>
T& CStack<T>::GetTop()
{
	return *m_pTop;
}

template <class T>
bool CStack<T>::IsEmpty()
{
	return m_nLength == 0 ? true : false;
}

template <class T>
bool CStack<T>::IsFull()
{
	return m_nLength == m_nStackSize ? true : false;
}

template <class T>
int CStack<T>::Size()
{
	return m_nLength;
}

#include <iostream>
#include "Stack.h"
using namespace std;

//栈求解迷宫
//迷宫节点
typedef struct _MAZENODE
{
	bool m_bWall;
	bool m_bPass;

	int  m_nRow;
	int  m_nCol;
}MAZENODE;

//迷宫大小
const int nMazeRowSize = 5;
const int nMazeColSize = 5;

//迷宫数组
MAZENODE MazeArry[nMazeRowSize][nMazeColSize];

//迷宫起点和终点
int nMazeStartRow = 0, nMazeStartCol = 0;
int nMazeEndRow   = 4, nMazeEndCol   = 4;

//存储路径
CStack<MAZENODE> MazeStack(nMazeRowSize * nMazeColSize);

//初始迷宫
void InitMaze()
{
	for (int i = 0; i < nMazeRowSize; i++)
	{
		for (int j = 0; j < nMazeColSize; j++)
		{
			MazeArry[i][j].m_bWall = false;
			MazeArry[i][j].m_bPass = false;
			MazeArry[i][j].m_nRow  = i;
			MazeArry[i][j].m_nCol  = j;
		}
	}

	MazeArry[0][1].m_bWall = true;
	MazeArry[1][2].m_bWall = true;
	MazeArry[1][3].m_bWall = true;
	MazeArry[2][0].m_bWall = true;
	MazeArry[3][2].m_bWall = true;
	MazeArry[3][3].m_bWall = true;
	MazeArry[4][2].m_bWall = true;
}

//回溯遍历迷宫
void TraveMaze(MAZENODE &CurNode)
{
	//如果当前节点为终点则返回
	if (CurNode.m_nRow == nMazeEndRow && CurNode.m_nCol == nMazeEndCol)
	{
		//当前节点入栈
		CurNode.m_bPass = true;
		MazeStack.Push(CurNode);

		return;
	}	

	 //向右
	int nNextRow = CurNode.m_nRow;
	int nNextCol = CurNode.m_nCol + 1;

	if (nNextCol < nMazeColSize && !(MazeArry[nNextRow][nNextCol].m_bWall || MazeArry[nNextRow][nNextCol].m_bPass)) 
	{
		//当前节点入栈
		CurNode.m_bPass = true;
		MazeStack.Push(CurNode);

		TraveMaze(MazeArry[nNextRow][nNextCol]);
		return;
	}
	
	//向上
	nNextRow = CurNode.m_nRow - 1;
	nNextCol = CurNode.m_nCol;

	if (nNextRow >= 0 && !(MazeArry[nNextRow][nNextCol].m_bWall || MazeArry[nNextRow][nNextCol].m_bPass)) 
	{
		//当前节点入栈
		CurNode.m_bPass = true;
		MazeStack.Push(CurNode);

		TraveMaze(MazeArry[nNextRow][nNextCol]);
		return;
	}
	
	//向左
	nNextRow = CurNode.m_nRow;
	nNextCol = CurNode.m_nCol - 1;

	if (nNextCol >= 0 && !(MazeArry[nNextRow][nNextCol].m_bWall || MazeArry[nNextRow][nNextCol].m_bPass)) 
	{
		//当前节点入栈
		CurNode.m_bPass = true;
		MazeStack.Push(CurNode);

		TraveMaze(MazeArry[nNextRow][nNextCol]);
		return;
	}
	
	//向下
	nNextRow = CurNode.m_nRow + 1;
	nNextCol = CurNode.m_nCol;

	if (nNextRow < nMazeRowSize && !(MazeArry[nNextRow][nNextCol].m_bWall || MazeArry[nNextRow][nNextCol].m_bPass)) 
	{
		//当前节点入栈
		CurNode.m_bPass = true;
		MazeStack.Push(CurNode);

		TraveMaze(MazeArry[nNextRow][nNextCol]);
		return;
	}

	//当前节点没有通路
	CurNode.m_bPass = false;
	CurNode.m_bWall = true;

	//栈大小变为0时回到起始点
	if (MazeStack.Size() != 0)
	{
		//上一个节点位置
		int nPreRow = MazeStack.GetTop().m_nRow;
		int nPreCol = MazeStack.GetTop().m_nCol;

		//上一个节点出栈
		MazeStack.Pop();

		TraveMaze(MazeArry[nPreRow][nPreCol]);
	}
}

void CalcluateMaze()
{	
	InitMaze();

	//起始点或结束点为墙
	if (MazeArry[nMazeStartRow][nMazeStartCol].m_bWall || MazeArry[nMazeEndRow][nMazeEndCol].m_bWall)
		return;

	TraveMaze(MazeArry[nMazeStartRow][nMazeStartCol]);

	int nMazeStackSize = MazeStack.Size();
	for (int i = 0; i < nMazeStackSize; i++)
	{
		cout<<"Row:"<<MazeStack.GetTop().m_nRow<<"\t"<<"Col:"<<MazeStack.GetTop().m_nCol<<endl;
		MazeStack.Pop();
	}
}