迷宫问题 （下） 使用Quene 实现

Quene 的实现方法是 广度优先搜索方法。

使用队列一层一层的将路线记录到队列中， 然后新加入的元素指向之前的元素。

 

struct 
{
	int i,j;
	int pre;
}Qu[MAXSTACKSIZE];
int front = -1, rear = -1;

int findPathByQueue(int in_x, int in_y, int out_x, int out_y)
{
	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}
	};

	int i, j, find = 0, di;
	rear++;
	Qu[rear].i = in_x; Qu[rear].j = in_y;
	Qu[rear].pre = -1;
	A[in_x][in_y] = -1;
	
	while(front <= rear && !find)
	{
		front++;
		
		// current position
		i = Qu[front].i; j = Qu[front].j;
		
		// find the way
		if(i == out_x && j == out_y)
		{
			find = 1;
			print(front);
			return(1);
		}

		// search widely
		for(di = 0; di < 4; di++)
		{
			switch(di)
			{
			case 0: i = Qu[front].i - 1; j = Qu[front].j; break;
			case 1: i = Qu[front].i;     j = Qu[front].j + 1; break;
			case 2: i = Qu[front].i + 1; j = Qu[front].j; break;
			case 3: i = Qu[front].i;     j = Qu[front].j - 1; break;
			}

			if(A[i][j] == 0)
			{
				rear++;
				Qu[rear].i = i; Qu[rear].j = j;
				Qu[rear].pre = front;
				A[i][j] = -1;
			}
		} // end of search
		
	}

	return 0;
}

void print(int front)
{
	int k = front, j, ns = 0;
	printf("\n\n");

	do{
		j = k;
		k = Qu[k].pre;
		Qu[j].pre = -1;
	}while(k != 0);
	
	printf("\n the path is as follow: \n");
	k = 0;
	while(k < MAXSIZE)
	{
		if(Qu[k].pre == -1)
		{
			ns++;
			printf("\t[%d,%d]", Qu[k].i, Qu[k].j);
			if(ns % 5 == 0)
				printf("\n");
		}
		k++;
	}
	printf("\n");
}

该方法可以知道最短路径