Chinaunix首页 | 论坛 | 博客

GP-Kinggpking.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

gongping11

  • 博客访问： 1891739
  • 博文数量： 152
  • 博客积分： 3730
  • 博客等级： 上尉
  • 技术积分： 3710
  • 用 户 组： 普通用户
  • 注册时间： 2011-06-02 14:36
个人简介

减肥，运动，学习，进步...

文章分类

全部博文（152）

文章存档

2016年（14）

2015年（17）

2014年（16）

2013年（4）

2012年（66）

2011年（35）

我的朋友
最近访客
推荐博文
相关博文
栈的妙用-实现迷宫问题

分类： LINUX

2012-04-06 10:33:47

堆栈是计算机程序中非常重要的一部分，主要用来参数的调用，局部变量的存储等，在C语言中的函数调用过程中通过不同函数的堆栈空间可以非常方便的找到传递进来的参数以及退出时应该返回的地址。具体的参看“ ”，这篇文章中通过实例分析讨论了函数调用过程中堆栈的变化过程。
 
实质上栈的运用并不是只能在函数调用中，栈作为一种数据结构，自然有其特殊的意义，栈的最大特点是"先入后出，后入先出"，这个特点可以用来结局很多的问题。C语言中的函数调用算是其中的最主要的用法之一，也就不再分析和讨论。同样递归，嵌套调用等都属于函数调用的子类也不再描述。在其他方面经典的运用是解决迷宫问题，不同进制数值之间的转换，长字符串的分解以及算术表达式的求值等。下面我主要采用栈实现经典的迷宫问题。
迷宫问题
迷宫问题是经典的一类问题，如何从给出的入口找到对应的出口，实现的方法和马踏棋盘问题相似也是通过找到周围8个方向坐标的关系，然后依据深度优先搜索方法和一定的条件找到下一步对应的出路。由于迷宫问题需要存储具体的完成路劲，这与前面的问题存在一定的差别。采用栈能够很好的解决这个问题，其中栈结构用来存储具体的坐标和方向。这样根据栈就能保证以后每一次都能快速的找到出路。
实现的基本步骤如下：
1、为了避免边界检测问题，在迷宫的外围添加一层围墙，比如原来的迷宫为m*n,则添加围墙以后的矩阵为(m+2)*(n+2)。其中为1表示不能走通，0时表示可以走通。这样maze[1][1]表示迷宫的入口，而maze[m][n]表示迷宫的出口。
2、创建一个堆栈空间，可以采用静态数组的方式，但由于不能准确的估计数组空间大小，可以采用动态创建的方式。并将入口坐标值压入到栈中。定义一个与迷宫大小相同的矩阵mark，用来统计当前坐标是否已经到达过，当没有到达坐标（i,j）时，则有mark[i][j] = 0,如果之前到达过，则有mark[i][j] = 1.这样主要是为了避免形成内部死循环，同时说明此路不能走通。
3、检测栈空间是否为空，如果为空则停止，如果不为空，则弹出栈顶的元素.
4、采用循环的方式，依据元素的方向确定下一个坐标，具体的确定方法依据之前的移动关系找到，判断该位置是否为0（maze[nextrow][nextcol] == 0）以及之前是否到达该位置(mark[nextrow][nextcol] == 1)。如果满足条件，则将mark[nextrow][newcol]设置为1，并将当前位置以及具体的方向值压入栈中，将当前坐标设置为之前确定的下一个坐标，设置方向为0。然后重新进行步骤4。如果8个方向全部不能找到合适的下一个坐标，说明此路走不通。重新进行步骤3，探索新的路劲。探索成功的条件是(nextrow == EXIT_ROW&&nextcol == EXIT_COL)。
基本的实现流程图如下所示：

代码实现如下：

点击(此处)折叠或打开

  1. /*maze_problem.h*/
  2. #ifndef MAZE_PROBLEM_H_H_
  3. #define MAZE_PROBLEM_H_H_

  5. typedef struct
  6. {
  7.     int vert;
  8.     int horiz;
  9. }offsets;

  11. typedef struct {
  12.     int row;
  13.     int col;
  14.     int dir;
  15. }element;

  17. typedef struct {
  18.     int row;
  19.     int col;
  20. }coordinate;
  21. #endif

点击(此处)折叠或打开

  1. /*maze_problem.c*/
  2. #include "maze_problem.h"

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

  7. offsets move[8];

  9. /*the stack save the path, and used */
  10. element * stack;
  11. int top = -1;

  13. void initial_move(void)
  14. {
  15.     /*horiz means cols*/
  16.     move[0].horiz = 0;
  17.     /*vert means rows*/
  18.     move[0].vert = -1;
  19.     
  20.     move[1].horiz = 1;
  21.     move[1].vert = -1;
  22.     
  23.     move[2].horiz = 1;
  24.     move[2].vert = 0;
  25.     
  26.     move[3].horiz = 1;
  27.     move[3].vert = 1;

  29.     move[4].horiz = 0;
  30.     move[4].vert = 1;
  31.     
  32.     move[5].horiz = -1;
  33.     move[5].vert = 1;
  34.     
  35.     move[6].horiz = -1;
  36.     move[6].vert = 0;
  37.     
  38.     move[7].horiz = -1;
  39.     move[7].vert = -1;
  40. }
  41. #define MAZE_ROWS    12
  42. #define MAZE_COLS    15

  44. #define NEW_MAZE_ROWS (MAZE_ROWS + 2)
  45. #define NEW_MAZE_COLS (MAZE_COLS + 2)
  46. #define EXIT_COL    15
  47. #define EXIT_ROW    12

  49. int maze[NEW_MAZE_ROWS][NEW_MAZE_COLS]
  50. = {
  51.  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  52.  1,0,1,0,0,0,1,1,0,0,0,1,1,1,1,1,1,
  53.  1,1,0,0,0,1,1,0,1,1,1,0,0,1,1,1,1,
  54.  1,0,1,1,0,0,0,0,1,1,1,1,0,0,1,1,1,
  55.  1,1,1,0,1,1,1,1,1,1,1,0,1,1,0,0,1,
  56.  1,1,1,0,1,0,0,1,0,1,1,1,1,1,1,1,1,
  57.  1,0,0,1,1,0,1,1,1,0,1,0,0,1,0,1,1,
  58.  1,0,0,1,1,0,1,1,1,0,1,0,0,1,0,1,1,
  59.  1,0,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,
  60.  1,0,0,1,1,0,1,1,0,1,1,1,1,1,0,1,1,
  61.  1,1,1,0,0,0,1,1,0,1,1,0,0,0,0,0,1,
  62.  1,0,0,1,1,1,1,1,0,0,0,1,1,1,1,0,1,
  63.  1,0,1,0,0,1,1,1,1,1,0,1,1,1,1,0,1,
  64.  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  65. };

  67. /*used to store the used place*/
  68. int mark[NEW_MAZE_ROWS][NEW_MAZE_COLS];

  70. void mark_init()
  71. {
  72.     int i = 0,j = 0;
  73.     for(i = 0; i < NEW_MAZE_ROWS ; ++ i)
  74.         for(j = 0; j < NEW_MAZE_COLS ; ++ j)
  75.             mark[i][j] = 0;
  76. }
  77. int mark_stack_size(int maze[NEW_MAZE_ROWS][NEW_MAZE_COLS])
  78. {
  79.     int i = 0,j = 0;

  81.     int size = 0;
  82.     for(i = 0; i < NEW_MAZE_ROWS; ++ i)
  83.         for (j = 0; j < NEW_MAZE_COLS ; ++ j)
  84.         {
  85.             if(!maze[i][j])
  86.             size ++;
  87.         }    
  88.     return size;
  89. }

  91. coordinate nextposition(element a,int dir)
  92. {
  93.     coordinate b;
  94.     b.col = a.col + move[dir].horiz;
  95.     b.row = a.row + move[dir].vert;
  96.     
  97.     return b;
  98. }

  100. int maze_out()
  101. {
  102.     element temp;
  103.     coordinate nextp;
  104.     
  105.     /*Test the stack is not empty*/
  106.     while(top >= 0)
  107.     {
  108.         /*pop a element*/
  109.         temp = *(stack+top);
  110.         top --;

  112.         /*find on eight directions*/
  113.         while(temp.dir < 8)
  114.         {
  115.             /*get the possible next positions*/
  116.             nextp = nextposition(temp,temp.dir);
  117.             /*next direction*/
  118.             temp.dir ++;

  120.             /*success conditions*/
  121.             if(nextp.row == EXIT_ROW &&
  122.              nextp.col == EXIT_COL)
  123.             {
  124.                 /*save current position*/
  125.                 stack[++top] = temp;

  127.                 /*save the exit pointion*/
  128.                 stack[++top].row = EXIT_ROW;
  129.                 stack[top].col = EXIT_COL;
  130.                 stack[top].dir = 0;

  132.                 /*exit*/
  133.                 return 1;
  134.             }

  136.             /*the new position is ok and does not wake*/
  137.             if(maze[nextp.row][nextp.col] ==0 &&
  138.              mark[nextp.row][nextp.col] == 0)
  139.             {
  140.                 /*mark means that this way has been waked*/
  141.                 mark[nextp.row][nextp.col] = 1;

  143.                 /*
  144.                  *push a element in stack
  145.                  *save current position and direction
  146.                  *if this way is failed, used to this position to start new way.
  147.                 */
  148.                 stack[++top] = temp;
  149.                 
  150.                 /*go to the new position as current position*/
  151.                 temp.row = nextp.row;
  152.                 temp.col = nextp.col;
  153.                 temp.dir = 0;
  154.             }
  155.         }
  156.     }    
  157.     /*failed*/
  158.     return 0;
  159. }

  161. int main()
  162. {
  163.     int i = 0;
  164.     /*inital the mark array*/
  165.     mark_init();
  166.     initial_move();

  168.     /*create stack*/
  169.     stack = (element*)malloc(mark_stack_size(maze)*sizeof(element));
  170.     /*if failed*/
  171.     if(stack == NULL)
  172.         return 0;
  173.     /*push a element in stack*/
  174.     top ++;
  175.     (stack+top)->col = 1;
  176.     (stack+top)->row = 1;
  177.     (stack+top)->dir = 0;

  179.     if(maze_out())
  180.     {
  181.         while(i <= top)
  182.         {
  183.             printf("(%d,%d,%d)\n",stack[i].row,stack[i].col,stack[i].dir);
  184.             i ++;
  185.         }
  186.     //    printf("(%d,%d)\n",EXIT_ROW,EXIT_COL);

  188.     }
  189.     /*free the memory*/
  190.     free(stack);
  191.     /*point to the NULL*/
  192.     stack = NULL;
  193.     return 1;
  194. }
测试结果：

在迷宫问题中，栈主要实现了对满足条件坐标以及方向值(0-7,分别表示一个具体的方向)的动态保存能够保证路劲的一致性，也就是先入后出的特性。

 
阅读(9057) | 评论(0) | 转发(3) |
0

上一篇：马踏棋盘的实现

下一篇：关于uC/OS-II中的任务挂起讨论

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6