一.用棧來實現簡單的迷宮

1. 迷宮：

回溯法：對一個包括有很多個結點，每個結點有若干個搜尋分支的問 題，把原問題分解為若干個子問題求解的演算法；當搜尋到某個結點發 現無法再繼續搜尋下去時，就讓搜尋過程回溯(回退)到該節點的前一 個結點，繼續搜尋該節點外的其他尚未搜尋的分支；如果發現該結點 無法再搜尋下去，就讓搜尋過程回溯到這個結點的前一結點繼續這樣 的搜尋過程；這樣的搜尋過程一直進行到搜尋到問題的解或者搜尋完 了全部可搜尋分支沒有解存在為止。

2.迷宮實現的簡單步驟

(1.) 首先要初始化迷宮
(2.) 檢測合法的迷宮入口（要求入口必須在迷宮的邊界且為一 ）
（3.）走迷宮（步驟是上.左.右.下）把每步走的路程賦值為2如果走的路行不通則標記為3
（4.）檢測是否為迷宮出口（在邊界且不和入口相等）
在實現程式碼時一定要注意前置標頭檔案的宣告

3.實現迷宮的程式碼

stack.h

#pragma once
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


extern  struct Position;
typedef struct Position DataType;

typedef struct Stack
{
	DataType *arr;//指向動態空間的指標
	int capacity;//空間總容量
	int size;//有效元素個數
}Stack, *PStack;

// 棧的初始化 
void StackInit(PStack ps, int capacity);

// 入棧 
void StackPush(PStack ps, DataType data);

// 出棧 
void StackPop(PStack ps);

// 獲取棧頂元素 
DataType StackTop(PStack ps);

// 獲取棧中元素個數 
int StackSize(PStack ps);

// 檢測棧是否為空 
int StackEmpty(PStack ps);
 

Maze.h

#pragma once
#define MAX_ROW 6
#define MAX_COL 6

typedef struct Position
{
	int _x;
	int _y;
}Position;

typedef struct Maze
{
	int _map[MAX_ROW][MAX_COL];

}Maze, *PMaze;

//1. 用棧對簡單迷宮進行求解，迷宮只有一個出口
//採用迴圈方式實現
// 棧的初始化 


void InitMaze(PMaze pm, int map[][MAX_COL]);

// 檢測入口是否為有效入口 
int IsValidEntry(PMaze pm, Position entry);

// 檢測cur位置是否是通路 
int IsPass(PMaze pm, Position cur);

// 檢測Cur是否在出口 
int IsExit(PMaze pm, Position cur, Position entry);

// 走迷宮 
void PassMaze(PMaze pm, Position entry, PStack ps);

// 列印迷宮 
void PrintMaze(PMaze m, int map[][MAX_COL]);
 

stack.c

#include "stack.h"
#include "Maze.h"

//初始化棧，有效元素清空，分配起始空間
void StackInit(PStack ps, int capacity)
{
	if (NULL == ps)
		return;

	ps->arr = (DataType *)malloc(sizeof(DataType)*capacity);

	if (NULL == ps->arr)
	{
		printf("申請空間失敗!!!\n");
		return;
	}

	ps->capacity = capacity;//空間容量改變
	ps->size = 0;//有效元素清空

}

void AddCapacity(PStack ps)
{
	if (NULL == ps)
		return;

	ps->arr = (DataType *)realloc(ps->arr, sizeof(DataType)*(ps->capacity) * 2);//擴增位原空間大小二倍

	if (NULL == ps->arr)
	{
		printf("空間擴增失敗!!!\n");
		return;
	}

	ps->capacity = 2 * (ps->capacity);

}


//列印棧
void PrintStack(PStack ps)
{
	int i = 0;
	if (NULL == ps)
		return;

	for (; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}


//入棧，就是對錶進行尾插
void StackPush(PStack ps, DataType data)
{
	if (NULL == ps)
		return;

	if (ps->size == ps->capacity)//說明空間已滿，要申請空間
		AddCapacity(ps);

	ps->arr[ps->size] = data;
	ps->size++;

}


//出棧
void StackPop(PStack ps)
{
	if (NULL == ps)
		return;

	if (ps->size == 0)
	{
		printf("棧已空，操作失敗!!!\n");
		return;
	}

	ps->size--;
}

// 獲取棧頂元素,棧頂就是表的尾部
DataType StackTop(PStack ps)
{
	if (NULL == ps)
	{
	  printf("棧不存在!!!\n");
	  return;
	}

	if (ps->size == 0)
	{
	  printf("棧已空!!!\n");
	  return;
	}

	return ps->arr[ps->size - 1];
}

// 獲取棧中元素個數 
int StackSize(PStack ps)
{
	if (NULL == ps)
	{
		printf("棧不存在!!!\n");
		return 0;
	}

	return ps->size;
}

// 檢測棧是否為空 
int StackEmpty(PStack ps)
{
	if (NULL == ps)
	{
		printf("棧不存在!!!\n");
		return 0;
	}

	if (ps->size)
		return 0;
	return 1;

}

Maze.c

#include "stack.h"
#include "Maze.h"

//列印迷宮
void PrintMaze(PMaze pm)
{
	int i = 0;
	assert(pm);

	for (; i < MAX_ROW; ++i)
	{
		int j = 0;
		for (; j < MAX_COL; ++j)
		{
			printf("%d ", pm->_map[i][j]);
		}
		printf("\n");
	}

}


//迷宮初始化,就是將地圖中的值賦給迷宮
void InitMaze(PMaze pm, int map[][MAX_COL])
{
	int i = 0;
	assert(pm);

	for (; i < MAX_ROW; ++i)
	{
		int j = 0;
		for (; j < MAX_COL; ++j)
		{
			pm->_map[i][j] = map[i][j];
		}
	}
}

//檢測迷宮入口是否合法
int IsValidEntry(PMaze pm, Position entry)
{
	assert(pm);

	//必須位於迷宮邊界且值為1
	if ((entry._x == 0 || entry._y == 0 || entry._x == MAX_ROW - 1
		|| entry._y == MAX_COL - 1) && (pm->_map[entry._x][entry._y] == 1))
		return 1;
	return 0;
}


// 檢測cur位置是否是通路 
int IsPass(PMaze pm, Position cur)
{
	assert(pm);

	//值為1且不能越界
	if ((cur._x >= 0 && cur._x <= MAX_ROW - 1) &&
		(cur._y >= 0 && cur._y <= MAX_COL - 1) &&
		pm->_map[cur._x][cur._y] == 1)
		return 1;

	return 0;

}



// 檢測Cur是否在出口 
int IsExit(PMaze pm, Position cur, Position entry)
{
	assert(pm);

	//出口位置就是處於邊界值為1且不能是入口
	if ((cur._x == 0 || cur._y == 0 || cur._x == MAX_ROW - 1
		|| cur._y == MAX_COL - 1) && (pm->_map[cur._x][cur._y] == 1)
		&& ((cur._x != entry._x) || (cur._y != entry._y)))
		return 1;

	return 0;
}


//走迷宮
void PassMaze(PMaze pm, Position entry, PStack ps)
{
	Position cur;
	Position next;
	assert(pm);
	assert(ps);

	//檢測入口是否合法
	if (!IsValidEntry(pm, entry))
	{
		printf("迷宮入口不合法!!!\n");
		return;
	}

	//走進入口,入棧
	StackPush(ps, entry);

	while (!StackEmpty(ps))
	{
		cur = StackTop(ps);

		//在標記之前檢測要不然，cur位置值不為1
		if (IsExit(pm, cur, entry))
		{
			pm->_map[cur._x][cur._y] = 2;
			printf("已找到出口!!!\n");
			return;
		}
		pm->_map[cur._x][cur._y] = 2;

		//依次判斷上下左右是否可以走通
		//上
		next = cur;
		next._x -= 1;

		//判斷是否可以走通
		if (IsPass(pm, next))
		{
			StackPush(ps, next);
			continue;
		}

		//左
		next = cur;//如果走到這，next值已經變了，所以要重新賦值
		next._y -= 1;
		if (IsPass(pm, next))
		{
			StackPush(ps, next);
			continue;
		}

		//右
		next = cur;
		next._y += 1;
		if (IsPass(pm, next))
		{
			StackPush(ps, next);
			continue;
		}

		//下
		next = cur;
		next._x += 1;
		if (IsPass(pm, next))
		{
			StackPush(ps, next);
			continue;
		}

		//如果上下左右都不能走通，那麼說明cur走錯了，標記為3，出棧
		pm->_map[cur._x][cur._y] = 3;
		StackPop(ps);
	}

	//走到這，說明找不到迷宮出口
	printf("迷宮沒有出口!!!\n");
}

test.c

#include "stack.h"
#include "Maze.h"
#include <windows.h>

void TestMaze(PStack ps)
{
	int i = 0;
	Position entry;
	Maze m;
	PMaze pm = &m;
	StackInit(ps, 10);
	int map[6][6] = { { 0, 0, 0, 0, 0, 0 },
	{ 0, 0, 1, 0, 0, 0 },
	{ 0, 0, 1, 0, 0, 0 },
	{ 0, 0, 1, 1, 1, 0 },
	{ 0, 0, 1, 0, 1, 1 },
	{ 0, 0, 1, 0, 0, 0 } };
	InitMaze(pm, map);
	PrintMaze(pm, map);
	entry._x = 5;
	entry._y = 2;
	PassMaze(pm, entry, ps);
	printf("\n");
	PrintMaze(pm, map);


}
int main()
{
	Stack s;
	PStack ps = &s;

	TestMaze(ps);//測試迷宮
	system("pause");
	return 0;
}