栈：：迷宫问题

最新推荐文章于 2021-11-13 10:46:02 发布

beimuaihui

最新推荐文章于 2021-11-13 10:46:02 发布

阅读量509

点赞数

分类专栏：数据结构(Javascript) 文章标签： object function html 算法 button null

本文链接：https://blog.csdn.net/beimuaihui/article/details/2111944

版权

数据结构(Javascript) 专栏收录该内容

59 篇文章 0 订阅

订阅专栏

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=gbk" />
  <title>Untitled Document</title>
</head>
<body>
  <p>迷宫问题（栈实现）</p>
  <p>以试错及栈的特性，将当前走过的位置存入栈中，得出当前的四个方向是否有可行时，
  存入位置及方向(避免重复走相同的路径)。如此循环。其它部可参考递归中的迷宫算法</p>
   <p>
            <input type="button" id="btnFind" name="btnFind" value="显示路径"/>
        </p>
  <script type="text/javascript">
            /**
             * 栈结构
             */
            function stack(){
                this.item = [];
            }

            function push(stack, str){
                var arr = stack.item;
                arr[arr.length] = str;
            }

            function pop(stack){
                var arr = stack.item;
                if (arr.length == 0) {
                    return null;
                    // document.writeln("错误，没有数据可以弹出");
                }
                else {
                    var value = arr[arr.length - 1];
                    arr.length = arr.length - 1;
                    return value;
                }
            }

            /**
             * 每一步走过的位置
             * @param {Object} _row
             * @param {Object} _column
             * @param {Object} _dir 这上步的下一部在哪个方向(0,1,2,3)，会加1以防止重复查找相同的下一步，
             */
            function step(_row, _column, _dir){
                this.row = _row;
                this.column = _column;
                this.dir = _dir;
            }
   /**
    * 创建显示的表格
    * @param {Object} tblId
    */
             function createTable(tblId){
                var html = "<table id='" + tblId + "' border='1'>";
                for (var i = 0; i < 5; i++) {
                    html += "<tr>";
                    for (var j = 0; j < 5; j++) {
                        if (i == 0 && j == 0) {
                            html += "<td>^0^</td>";
                        }
                        else {
                            html += "<td> </td>";
                        }
                    }
                    html += "</tr>";
                }
                html += "</table>";
                document.writeln(html);
            }
   /**
    * 迷宫算法
    * @param {Object} mazing
    * @param {Object} direct
    * @param {Object} row
    * @param {Object} column
    */
    function findpath(mazing, direct,row,column){
    var MaxRow = mazing.length - 2;
                var MaxColumn = mazing[0].length - 2;
    var stp=new step(row,column,0);
    var stk=new stack();
    mazing[row][column]=2;
    push(stk,stp);
    while(stk!=null){
     var stp_pre=pop(stk);
     if (!stp_pre) {
      break
     }
     //alert(stp_pre.row+","+stp_pre.column+","+stp_pre.dir+","+direct.length);
     var found_dir=-1; //是否在哪个方向找到下一个位置
     for(var i=stp_pre.dir,cnt=direct.length;i<cnt ;i++){
      var stp_next=new step(stp_pre.row+direct[i][0],stp_pre.column+direct[i][1],0);
     // alert(stp_next.row+","+stp_next.column+","+mazing[stp_next.row][stp_next.column]);
      if(mazing[stp_next.row][stp_next.column]==0){
       mazing[stp_next.row][stp_next.column]=2;
       if(stp_next.row==MaxRow && stp_next.column==MaxColumn){
        showpath(mazing,"tbl");
       }else{
        found_dir=i+1;
        var stp=new step(stp_pre.row,stp_pre.column,found_dir);
        push(stk,stp);
        //alert(stp_pre.row+","+stp_pre.column+","+stp_pre.dir);
        push(stk,stp_next);
        break;
       }
      }
     }
     if (found_dir == -1) {
      mazing[stp_pre.row][stp_pre.column] = 0;
     }
    }
            }
            /**
             * 显示迷宫算法的结果
             * @param {Object} mazing
             * @param {Object} tblId
             */
            function showpath(mazing, tblId){
                var objTable = document.getElementById(tblId)
                var tbody = objTable.tBodies[0];
                var MaxRow = mazing.length - 1;
                var MaxColumn = mazing[0].length - 1;
                for (var i = 1; i < MaxRow; i++) {
                    var row = tbody.rows[i - 1];
                    for (var j = 1; j < MaxColumn; j++) {
                        var column = row.cells[j - 1];
                        var state = mazing[i][j];
                        column.style.backgroundColor = (state == 2 ? "#00ff00" : (state == 1 ? "#ff0000" : "#ffffff"));
                    }
                }
            }

            //分别是迷宫的数据（包括墙壁），及四个方向的（X,Y)值
            var mazing = [], direct = [], i = 0, j = 0;
            mazing[i++] = [1, 1, 1, 1, 1, 1, 1];
            mazing[i++] = [1, 0, 1, 0, 0, 0, 1];
            mazing[i++] = [1, 0, 1, 0, 1, 0, 1];
            mazing[i++] = [1, 0, 0, 0, 1, 0, 1];
            mazing[i++] = [1, 0, 1, 0, 1, 0, 1];
            mazing[i++] = [1, 0, 1, 0, 1, 0, 1];
            mazing[i++] = [1, 1, 1, 1, 1, 1, 1];
            direct[j++] = [1, 0];
            direct[j++] = [0, 1];
            direct[j++] = [-1, 0];
            direct[j++] = [0, -1];


            createTable("tbl");
            showpath(mazing, "tbl");
            var btnFind = document.getElementById("btnFind");
            btnFind.onclick = function(){
                findpath(mazing, direct, 1, 1)
            };
  </script>
</body>
</html>

beimuaihui

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
栈：：迷宫问题

http://www.w3.org/TR/html4/strict.dtd"> Untitled Document 迷宫问题（栈实现）以试错及栈的特性，将当前走过的位置存入栈中，得出当前的四个方向是否有可行时，存入位置及方向(避免重复走相同的路径)。如此循环。其它部可参考递归中的迷宫算法 /**
复制链接

扫一扫