2. 程式人生 > >遞迴與非遞迴實現走迷宮演算法

遞迴與非遞迴實現走迷宮演算法

阿新 • • 發佈：2019-02-03

●問題描述：

　　給出一個矩陣，其中0表示通路，1表示牆壁，這樣就形成了一個迷宮，要求編寫演算法求出其中一條路徑。

●遞迴思路：

　　編寫一個走迷宮函式，傳入二位陣列的下標，先假設該點位於最終路徑上（將0置為2）再探測周圍四個點是否可以走通（是否為０），如果可以走通則將該點四周能走通的點作為函式引數傳入函式進入遞迴。若四周均不能走通（都不為０時）則將該點置回０表示該點不是最終路徑上的點。

　　在此思路中遞迴進入時表示了列舉路徑，當發現此條路徑走到某處再不能走通時就將路徑該點置回０並且遞迴退出（回溯）尋找下一條可走通路徑。

●程式碼：

#include <stdio.h>
#include <stdlib.h>

#define END_I 8
#define END_J 7
#define START_I 0
#define START_J 0

//走迷宮
int VistMaze(int maze[][8], int i, int j)
{
	int end = 0;

	//假設能夠走通
	maze[i][j] = 2;
	
	//如果到達重點則將end置為0表示迷宮已經走結束
	if (i == END_I && j == END_J){
		end = 1;
	}
	//如果迷宮沒有走結束則將搜尋所在位置的右、下、左、上四個方向是否能夠走通
	if (end != 1 && j + 1 <= END_J && maze[i][j + 1] == 0){		//右
		if (VistMaze(maze, i, j + 1) == 1)
			return 1;
	}
	if (end != 1 && i + 1 <= END_I && maze[i + 1][j] == 0){		//下
		if (VistMaze(maze, i + 1, j) == 1)
			return 1;
	}
	if (end != 1 && j - 1 >= START_J && maze[i][j - 1] == 0){	//左
		if (VistMaze(maze, i, j - 1) == 1)
			return 1;
	}
	if (end != 1 && i - 1 >= START_I && maze[i - 1][j] == 0){	//上
		if (VistMaze(maze, i - 1, j) == 1)
			return 1;
	}	//當四周都不通的時候將其置回0
	if (end != 1){
		maze[i][j] = 0;
	}

	return end;
}

int main(void)
{
	    //迷宮
    int i, j;
    int maze[9][8] = {
        {0,0,1,0,0,0,1,0},
        {0,0,1,0,0,0,1,0},
        {0,0,0,0,1,1,0,1},
        {0,1,1,1,0,0,1,0},
        {0,0,0,1,0,0,0,0},
        {0,1,0,0,0,1,0,1},
        {0,1,1,1,1,0,0,1},
        {1,1,0,0,1,1,0,1},
        {1,1,0,0,0,0,0,0}
        };
	//打印出迷宮
	printf("原迷宮：\n");
	for(i = 0; i <= 9; i++)
		printf("-");
	printf("\n");
	for (i = 0; i < 9; i++){
		printf("|");
		for (j = 0; j < 8; j++){
			if (maze[i][j] == 1)
				printf("@");
			else
				printf(" ");
		}
		printf("|\n");
	}
	for(i = 0; i <= 9; i++)
		printf("-");
	printf("\n");

	if (VistMaze(maze, 0, 0) == 0){
		printf("沒有路徑可走\n");
		exit(0);
	}

	//打印出迷宮和路徑
	printf("迷宮和路徑：\n");
	for(i = 0; i <= 9; i++)
		printf("-");
	printf("\n");
	for (i = 0; i < 9; i++){
		printf("|");
		for (j = 0; j < 8; j++){
			if (maze[i][j] == 1)
				printf("@");
			else if (maze[i][j] == 2)
				printf("%%");
			else
				printf(" ");
		}
		printf("|\n");
	}
	for(i = 0; i <= 9; i++)
		printf("-");
	printf("\n");

	return 0;
}

●非遞迴思路：

　　此題也可以使用棧來避開遞迴，首先需要開闢一個和迷宮具有同樣幾何形狀的結構體二維陣列來儲存是從哪一個點（座標）到達該點的（該初始化時將所有的座標都置為-1），還需要一個可以儲存座標的棧。每次將能夠走通的點（值為０）都入棧然後在迴圈的開始處將棧頂元素彈出儲存進temp變數（儲存座標的變數）中，訪問temp變數四周的元素是否可以被訪問，如果可以被訪問（值為０）則將對應路徑陣列中的元素（即對應座標）值改為temp變數的值並將該能被訪問的變數入棧，再將迷宮中的0（能訪問）更改為2（已被訪問過）防止重複訪問。最後從路徑陣列中的出口處開始倒序輸出所走路徑即可。

　　在此種思想中棧儲存了所有可以走通的點，當一個點的四周都不能夠走通時彈出的該點座標程式並沒有進行任何實質性的處理，所以這就相當於一個“回溯”的過程。而訪問四周的點的過程就是一個列舉的過程。

●程式碼：

#include <stdio.h>
#include <stdlib.h>

#define COUNT_I 9
#define COUNT_J 8
#define START_I 0
#define START_J 0
#define END_I 8
#define END_J 7
#define MAXSIZE 1000

//座標位置結構體
typedef struct local{
	
	int x;
	int y;

}LOCAL;

//棧結構
typedef struct stack{
	
	LOCAL data[MAXSIZE];
	int top;

}STACK;

//初始化棧
STACK *InitStack(void)
{
	STACK *maze;
	maze = (STACK *)malloc(sizeof(STACK));
	maze->top = -1;
	
	return maze;
}

//判棧空
int EmptyStack(STACK *maze)
{
	if (maze->top == -1)
		return 1;
	else
		return 0;
}

//判棧滿
int IsFull(STACK *maze)
{
	if (maze->top == MAXSIZE - 1)
		return 1;
	else
		return 0;

}

//入棧
int PushStack(STACK *maze, LOCAL *x)
{
	if (maze->top <= MAXSIZE - 1){
		maze->data[++maze->top] = *x;
		return 1;
	}
	else{
		printf("棧已滿\n");
		return 0;
	}
}

//出棧
int PopStack(STACK *maze, LOCAL *x)
{
	if (maze->top > -1){
		*x = maze->data[maze->top];
		maze->top--;
		return 1;
	}
	else{
		printf("棧已空\n");
		return 0;
	}
}

//走迷宮函式
int VistMaze(int maze[][COUNT_J], LOCAL path[][COUNT_J])
{
	int i, j;

	//初始化棧
	STACK *stack;
	LOCAL temp;
	stack = InitStack();
	temp.x = 0; temp.y = 0;
	if (maze[START_I][START_J] == 0)
		PushStack(stack, &temp);
	else
		return 0;
	while(!EmptyStack(stack)){
		PopStack(stack, &temp);
		i = temp.x;	j = temp.y;
		maze[i][j] = 2;

		if (i == END_I && j == END_J)
			break;

		//下
		if (i + 1 <= END_I && maze[i + 1][j] == 0){
			maze[i + 1][j] = 2;
			path[i + 1][j].x = i;	path[i + 1][j].y = j;
			temp.x = i + 1;
			temp.y = j;
			PushStack(stack, &temp);
		}
		//右
		if (j + 1 <= END_J && maze[i][j + 1] == 0){
			maze[i][j + 1] = 2;
			path[i][j + 1].x = i;	path[i][j + 1].y = j;
			temp.x = i;
			temp.y = j + 1;
			PushStack(stack, &temp);
		}
		//左
		if (j - 1 >= 0 && maze[i][j - 1] == 0){
			maze[i][j - 1] = 2;
			path[i][j - 1].x = i;	path[i][j - 1].y = j;
			temp.x = i;
			temp.y = j - 1;
			PushStack(stack, &temp);
		}
		//上
		if (i - 1 >= 0 && maze[i - 1][j] == 0){
			maze[i - 1][j] = 2;
			path[i - 1][j].x = i;	path[i - 1][j].y = j;
			temp.x = i - 1;
			temp.y = j;
			PushStack(stack, &temp);
		}
	}
	//如果到達終點而退出的迴圈則將路徑標識出來
	if (i == END_I && j == END_J){
		maze[i][j] = 3;
		while(path[temp.x][temp.y].x != -1){
			temp = path[temp.x][temp.y];
			maze[temp.x][temp.y] = 3;
		}
		
		return 1;
	}
	else{
		return 0;
	}
}



int main(void)
{
	//迷宮
	int i, j;
	int maze[COUNT_I][COUNT_J] = {
			{0,0,1,0,0,0,1,0},
			{0,0,1,0,0,0,1,0},
			{0,0,0,0,1,1,0,1},
			{0,1,1,1,0,0,1,0},
			{0,0,0,1,0,0,0,0},
			{0,1,0,0,0,1,0,1},
			{0,1,1,1,1,0,0,1},
			{1,1,0,0,1,1,0,1},
			{1,1,0,0,0,0,0,0}
		};
	
	//定義路徑陣列,將到(x,y)點的路徑儲存進陣列
	LOCAL path[COUNT_I][COUNT_J];
	for(i = 0; i < COUNT_I; i++){
		for(j = 0; j < COUNT_J; j++){
			path[i][j].x = -1;
			path[i][j].y = -1;
		}
	}

	//打印出迷宮
	printf("原迷宮：\n");
	for(i = 0; i <= COUNT_I; i++)
		printf("-");
	printf("\n");
	for (i = 0; i < COUNT_I; i++){
		printf("|");
		for (j = 0; j < COUNT_J; j++){
			if (maze[i][j] == 1)
				printf("@");
			else
				printf(" ");
		}
		printf("|\n");
	}
	for(i = 0; i <= COUNT_I; i++)
		printf("-");
	printf("\n");

	if (VistMaze(maze, path) == 0){
		printf("沒有路徑可走\n");
		exit(0);
	}

	//打印出迷宮和路徑
	printf("迷宮和路徑：\n");
	for(i = 0; i <= COUNT_I; i++)
		printf("-");
	printf("\n");
	for (i = 0; i < COUNT_I; i++){
		printf("|");
		for (j = 0; j < COUNT_J; j++){
			if (maze[i][j] == 1)
				printf("@");
			else if (maze[i][j] == 3)
				printf("%%");
			else
				printf(" ");
		}
		printf("|\n");
	}
	for(i = 0; i <= COUNT_I; i++)
		printf("-");
	printf("\n");

	return 0;
}

●心得：

　　這兩種演算法都離不開列舉與回溯這兩大思想，在以後的學習中要多加理解這兩種思想。在初次接觸時理解不了遞迴的過程，後來在之上慢慢畫模擬計算機的執行過程終於讓遞迴這個過程瞭然於胸。可見在程式設計中驗算是多麼的重要。

相關推薦

遞迴與非遞迴實現走迷宮演算法

●問題描述： 　　給出一個矩陣，其中0表示通路，1表示牆壁，這樣就形成了一個迷宮，要求編寫演算法求出其中一條路徑。 ●遞迴思路： 　　編寫一個走迷宮函式，傳入二位陣列的下標，先假設該點位於最終路徑上（將0置為2）再探測周圍四個點是否可以走通（是否為０），如果可以走通則將該點

[計算機程式設計C++] Fibonaci數列的遞迴與非遞迴演算法實現

本文是對西安交通大學C++慕課第三章程式設計練習的16題的講解。 參考部落格：https://blog.csdn.net/zombie_slicer/article/details/38871799 題目內容： 編寫程式，顯示Fibonaci序列的前n項（從

斐波那契數列的遞迴與非遞迴的實現

0，1，1，2，3，5，8…這樣的數列稱作斐波那契數列 1、遞迴實現方式 //斐波那契數列遞迴實現 long long Fib1(long long n) { if (n<=1) retur

楊輝三角的C語言實現（遞迴與非遞迴）

本文用C語言程式碼實現楊輝三角 遞迴演算法依據於f(m,n)=f(m-1,n)+f(m-1,n-1) 其中（m,n）為楊輝三角第m行第n個元素 演算法程式碼如下：   #include <stdio.h> //遞迴函式 int func(int m,in

[二叉樹] 遍歷方法總結--遞迴與非遞迴--純C實現

非遞迴方法： 思路一：根據訪問次序來入棧並輸出 思路二：模擬訪問過程 思路三：使用識別符號mark來記錄已經第幾次訪問該結點 /* @Desc:二叉連結串列 無頭結點 @Vesrion:0.0.1 @Time:20180922建立 */ #include

# 二分查詢的遞迴與非遞迴實現

二分查詢的遞迴與非遞迴實現 二分查詢也稱為折半查詢，首先，假設表中元素是按升序排列，將表中間位置記錄的關鍵字與查詢關鍵字比較，如果兩者相等，則查詢成功；否則利用中間位置記錄將表分成前、後兩個子表，如果

排序演算法6——圖解歸併排序及其遞迴與非遞迴實現

排序演算法1——圖解氣泡排序及其實現（三種方法，基於模板及函式指標） 排序演算法2——圖解簡單選擇排序及其實現 排序演算法3——圖解直接插入排序以及折半（二分）插入排序及其實現 排序演算法4——圖解希爾排序及其實現 排序演算法5——圖解堆排序及其實現 排序演算法6——圖解歸併排序及其遞迴與非

1.遞迴和非遞迴分別實現求第n個斐波那契數。 遞迴與非遞迴的典型題型

1.遞迴和非遞迴分別實現求第n個斐波那契數。 2.編寫一個函式實現n^k，使用遞迴實現 寫一個遞迴函式DigitSum(n)，輸入一個非負整數，返回組成它的數字之和，例如，呼叫DigitSum(1729)，則應該返回1+7+2+9，它的和是19 編寫一個

二叉樹後序遍歷（遞迴與非遞迴）演算法及C語言實現

二叉樹後序遍歷的實現思想是：從根節點出發，依次遍歷各節點的左右子樹，直到當前節點左右子樹遍歷完成後，才訪問該節點元素。 圖 1 二叉樹   如圖 1 中，對此二叉樹進行後序遍歷的操作過程為： 從根節點 1 開始，遍歷該節點的左子樹（以節點 2 為根節點）； 遍歷節點 2 的左子樹（以節點 4 為根

二叉樹先序遍歷（遞迴與非遞迴）及C語言實現

二叉樹先序遍歷的實現思想是： 訪問根節點； 訪問當前節點的左子樹； 若當前節點無左子樹，則訪問當前節點的右子樹； 圖 1 二叉樹   以圖  1 為例，採用先序遍歷的思想遍歷該二叉樹的過程為： 訪問該二叉樹的根節點，找到 1； 訪問節點 1 的左子樹，找到節點 2； 訪問節點 2 的左子

Java排序演算法(三)--歸併排序（MergeSort）遞迴與非遞迴的實現

歸併有遞迴和非遞迴兩種。 歸併的思想是： 1.將原陣列首先進行兩個元素為一組的排序，然後合併為四個一組，八個一組，直至合併整個陣列； 2.合併兩個子陣列的時候，需要藉助一個臨時陣列，用來存放當前的

【資料結構】二叉搜尋樹(增、刪、查)的遞迴與非遞迴實現

前言：     二叉搜尋樹是二叉樹中的一種特殊結構，具有如下的性質： ➢每個節點都有一個作為搜尋依據的關鍵碼（key），所有節點的關鍵碼互不相同。 ➢左子樹上所有節點的關鍵碼（key）都小於根節點的關鍵碼（key）。 ➢右子樹上所有節點的關鍵碼（key）都大於根節點的關鍵碼

fibonacci數列的遞迴與非遞迴實現

fibonacci數列的遞迴與非遞迴實現 public class fibonacci { public static void main(String arg[]){ // fib1(); System.out.println(fib2(4));

深度優先搜尋（DFS）遞迴與非遞迴實現邏輯詳解

 遞迴與非遞迴：        資料結構對於學習程式設計的人來說是非常重要的，我們在現實生活碰到的各種煩難問題可以用遞迴來實現，一個遞迴思想就把問題給簡單化了，但是我們都知道遞迴是非常耗時的，一旦資料量龐大起來，遞迴

斐波那契數列--遞迴與非遞迴實現

初識斐波那契數列： 斐波那契數列（Fibonacci sequence），又稱黃金分割數列、因數學家列昂納多·斐波那契（Leonardoda Fibonacci）以兔子繁殖為例子而引入，故又稱為“兔子

python實現 二叉樹的前序中序後序遍歷層次遍歷——遞迴與非遞迴

前序遍歷 # ------ coding:utf-8 ------- class TreeNode: def __init__(self, x): self.val = x

斐波那契數列遞迴與非遞迴實現（JAVA語言描述）

斐波那契數列（Fibonacci sequence），又稱黃金分割數列、因數學家列昂納多·斐波那契（Leonardoda Fibonacci[1] ）以兔子繁殖為例子而引入，故又稱為“兔子數列”，指的是這樣一個數列：0、1、1、2、3、5、8、13、21、34

歸併排序（遞迴與非遞迴）的實現

摘要： (1)歸併排序幾乎以O（NlogN）的時間界實現，是典型的分治演算法; (2)歸併排序的基本思路很簡單：就是將目標序列分為兩個部分，將兩個子序列排序好之後，再將它們合併。注意到合併兩個已排序

Gray碼的遞迴與非遞迴C++實現

Gray碼又稱二進位制迴圈碼，簡單說就是任意兩個相鄰的程式碼只有一位不同。 一個n位的二進位制碼是由 2^n個Gray碼構成的一個集合。 格雷碼的編碼規律是： 第一步，改變最右邊的位元值； 第二步，改變右起第一個為1的位元的左邊位元； 第三步，重複第一步和第二步，直

JAVA實現二叉樹的前、中、後序遍歷（遞迴與非遞迴）

最近在面試中遇到過問到二叉樹後序遍歷非遞迴實現的方法，之前以為會遞迴的解決就OK，看來還是太心存僥倖，在下一次面試之前，特地整理一下這個問題。 首先二叉樹的結構定義，java程式碼如下： public class Node { private