严蔚敏《数据结构》中迷宫算法java实现

最新推荐文章于 2023-10-07 22:06:31 发布
最新推荐文章于 2023-10-07 22:06:31 发布
阅读量1.5k 收藏 3
点赞数
文章标签： 数据结构 算法 java null equals
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hhsh123hhsh/article/details/6607249
版权

总的来说，这个程序运行得不错，可以任意修改迷宫图，但是有一点儿毛病:第一，如果终点不可达，程序陷入循环状态。改良思想，可以写个判断终点或起点是否合法的方法。也可以给所经过的路径标记，如果所以的点都经过了，则退出程序。其次，在switch分支中，以这样的顺序：下、右、上、左 探索的话，则有些点是无法到达的，如点（18，1），这些点称为盲点，只向一个方向绕过去是永远达到 的。解决思路：让探索既向逆时针探索，又向顺时针探索。以下是代码：（已经测试过，保证正确运行）

package test1;

import java.util.Random;

public class Migong
{
 static int maze[][];
 Stack <Node> stack =new Stack<Node>();
 Random r=new Random();
 int count=0+r.nextInt(20);
 //long count=100;   //在nextPos方法中，用来来回实行case；
 int i=1;    //在nextPos方法中，用来来回实行case；
 String flag="ni";  //在nextPos方法中，用来来回实行case；
 //String flag="ni";
 public static void main(String []args)
 {
  Migong mg=new Migong();
  maze=mg.initMaze(); 
  //Stack<Node> stackWithPath=mg.findPath( mg.stack,new Position(1,0),new Position(18,19));
  //Stack<Node> stackWithPath=mg.findPath( mg.stack,new Position(1,0),new Position(15,18));
  //Stack<Node> stackWithPath=mg.findPath( mg.stack,new Position(1,0),new Position(18,1));
  //Stack<Node> stackWithPath=mg.findPath( mg.stack,new Position(1,0),new Position(9,9));
  //Stack<Node> stackWithPath=mg.findPath( mg.stack,new Position(1,0),new Position(3,1));
  Stack<Node> stackWithPath=mg.findPath( mg.stack,new Position(1,0),new Position(18,39));
  mg.printFindPath(stackWithPath, maze);
 
 }
 
 public boolean jugePos(Position p)
 {
  if( maze[p.x][p.y]==1)
  {
   System.out.println("对不起，请输入合法的起点和终点！");
   return false;
  }
  else
   return true;
 
 }

 public void printFindPath(Stack<Node> st,int maze[][])
 {
 
  if(st==null)
  {
   System.out.println("对不起，栈为null！");
  }
  else
  {
   if(!st.isEmpty())
   {
    while(!st.isEmpty())
    {
     Node node=st.pop();
     maze[node.position.x][node.position.y]=-1;
    }
    printMaze(maze);
   }
   else
   {
    System.out.println("对不起，栈为空值！");
   }
  
  }
 
 
 }
 
 
 public Stack<Node> findPath(Stack<Node> stack,Position start,Position end)
 {
  int curstep=1;       //当前步骤数目
  Position curpos=start;     //当前位置
  Node node;
 
  if(!jugePos(start)||!jugePos(end))
  {
   return null;
  }
  else
  {
   do
   {
    if(isPass(curpos))
    {
     node=new Node(curstep,curpos,1);
     stack.push(node);
     footPrint(curpos);//这里有些小毛病，就是探索进入死胡同，而需要回溯的时候，显然我们已经打印了这些不该打印的路径，
    
     while(curpos.equals(end))
     {
      System.out.println("找到出口了，恭喜！");
      return stack;
     
     }
     curpos=nextPos(curpos,1);
     curstep=curstep+1;
    
    }
    else
    {
     if(!stack.isEmpty())
     {
      node=(Node)stack.peek();
      if(node.di<4)  //这个地方书上的算法是while，显然是不对的，应该是if；
      {
       Node n=(Node)stack.pop();
       ++n.di;      //如果di是3的话，由于3<4,满足进入第一个if分支条件，自增后di是4，
                    //随后实行push，和nextPos，实行nextPos时就是向左探索。
       stack.push(n);
       curpos=nextPos(n.position,n.di);
      
      }
      else            //注意，这里不能是if(node.di==4)，也不能是while(di==4)，因为如果那样，
      {               //则当di=3时，既满足实行第一个分支，又满足实行第二个分支（因为实行进入第一个if分支后，
          //di变成4，又满足了第二个分支的条件，这样就导致di=4时不能实行向左边探索的任务。
       markPrint(node.position);
       stack.pop();
       
      }
     }
    
    } 
   
   }while(!stack.isEmpty());
  }
 
  if(stack.getLength()==0)
   System.out.println("找不到出口！");
 
  return null;
 }
 
 public void markPrint(Position p)
 {
  System.out.println("点("+p.x+","+p.y+")碰壁！");
 }
 
 public Position nextPos(Position curpos,int di)
 {
  Position pos=new Position(curpos.x,curpos.y);
  if(flag=="ni"||flag.equals("ni"))
  {
   switch(di)
   { case 1:{pos.x+=1;break ;}//向下
    case 2:{pos.y+=1;break ;}//向右   
    case 3:{pos.x-=1;break ;}//向上
    case 4:{pos.y-=1;break ;}//向左 
   }
  
  
   i++;
   if(i>=count)   //1  50000 100000   150000
   {
    //flag="shun";
    i=1;
   }
   System.out.println("逆时针：下，右，上，左");
   count=0+r.nextInt(20);
  
  
  }
  else if(flag=="shun"||flag.equals("shun"))
  {
  
   switch(di)
   { case 2:{pos.x+=1;break ;}//向下
    case 1:{pos.y+=1;break ;}//向右   
    case 4:{pos.x-=1;break ;}//向上
    case 3:{pos.y-=1;break ;}//向左 
   }
  
  
   i++;
   if(i>=count)
   {
    //flag="luan";
    i=1;
   }
  
   System.out.println("顺时针：右，下，左，上");
   count=0+r.nextInt(30);
  }
 
  else
  {

   switch(di)
   { case 1:{pos.x+=1;break ;}//向下
    case 3:{pos.y+=1;break ;}//向右   
    case 2:{pos.x-=1;break ;}//向上
    case 4:{pos.y-=1;break ;}//向左 
   }
  
  
   i++;
   if(i>=count)
   {
    //flag="ni";
    i=1;
   }
  
   System.out.println("乱时针:下，上，右，左");
   count=0+r.nextInt(30);
  }
 
  
  return pos;
 }
 
 public void footPrint(Position curpos)
 {
  System.out.print("点("+curpos.x+","+curpos.y+")可通过！");
  System.out.println(" ");
 }
 
 public boolean isPass(Position curpos)//不仅测试当前位置是否为0，还需要把当前的Position构造成Node，然后
 {          //在stack找，看看是不是已经存在该位置，如果是，则该位置不能通过，否则可以通过;
  Stack<Node> temSt=stack;
  Node thisNode=new Node(curpos); 
  if(!temSt.isEmpty())
  {
  
   return (maze[curpos.x][curpos.y]==0&&!temSt.hasIt(thisNode));
  }
  else
  {
   return maze[curpos.x][curpos.y]==0;
  }
 
 }
 
 public int[][] initMaze()// 20行,40列,这个数目跟printMaze（)相关。
 {
  int maze[][]={ //       5         10        15        20        25        30        35        40
           {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
           {0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,1,1,0,1,0,1,0,0,1,0,1,1,0,0,1,0,0,0,1,0,1},
           {1,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,1,1,0,0,0,0,0,0,1,0,1,1},
           {1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,1,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,1,1},
           {1,1,1,1,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,1,1},//5
           {1,0,1,0,0,0,0,1,0,1,1,0,0,1,0,0,0,1,0,1,1,0,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,1,1,1},
           {1,0,1,0,0,0,1,1,0,1,1,0,0,1,0,0,0,1,0,1,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,1},
           {1,0,1,1,1,1,0,0,0,1,1,0,1,1,0,0,0,1,0,1,1,0,1,1,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1},
           {1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,1,0,1,0,1,1,0,0,1,0,0,0,1,0,0,1,0,1,0,1,1,0,1,1,1},
           {1,1,1,1,1,1,1,1,1,0,1,0,1,0,0,0,0,1,0,1,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1},//10
           {1,1,1,1,0,0,1,1,1,0,1,0,0,1,0,0,0,0,0,1,1,0,0,1,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,1},
           {1,1,1,1,1,0,0,0,0,0,1,0,1,1,0,0,0,1,0,1,1,0,0,1,1,1,1,1,0,0,1,0,0,1,0,0,0,1,0,1},
         {1,0,1,1,1,0,1,0,1,1,1,1,1,0,0,1,0,1,0,1,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1},
           {1,0,0,0,0,0,0,1,0,1,1,0,0,0,1,1,0,1,0,1,1,0,0,0,1,1,1,1,0,1,1,0,0,1,1,0,1,0,0,1},
           {1,0,1,0,0,0,1,1,0,1,1,1,0,1,1,0,0,1,0,1,1,0,1,1,1,0,0,1,0,1,1,0,0,0,1,1,0,1,0,1},//15
           {1,0,1,1,1,1,1,0,0,1,1,1,0,1,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,1,0,0,0,1,0,1,1,0,1},
           {1,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,1,1,0,1,1,0,1,0,1,0,0,1,0,1,1,1,1,0,0,0,1,1,0,1},
           {1,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,1,0,0,1,0,1,0,0,1,1,1,0,1,1,0,1},
         {1,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0},
           {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},//20
         
                };
  printMaze(maze);
  return maze;
 }
 
 public void printMaze(int maze[][])
 {
 
  for(int i=0;i<20;i++)
  {
   for(int j=0;j<40;j++)
   {
    if(maze[i][j]==1)
     System.out.print("■");
    else if(maze[i][j]==0)
     System.out.print("□");
    else
     System.out.print("＊");
   }
   System.out.println();
  }   
 }


 
}

class Node
{
 int ord;
 Position position;
 int di;
 public Node(Position p)
 {
  this.position=p;
 }
 public Node(int ord,Position p,int di)
 {
  this.ord=ord;
  this.position=p;
  this.di=di;
 }
 
 @Override
 public int hashCode() {
  final int PRIME = 31;
  int result = 1;
  result = PRIME * result + ((position == null) ? 0 : position.hashCode());
  return result;
 }
 @Override
 public boolean equals(Object obj) {
  if (this == obj)
   return true;
  if (obj == null)
   return false;
  if (getClass() != obj.getClass())
   return false;
  final Node other = (Node) obj;
  if (position == null) {
   if (other.position != null)
    return false;
  } else if (!position.equals(other.position))
   return false;
  return true;
 }
 
 
}

class Position
{
 int x;
 int y;
 public Position(){};
 public Position(int x,int y)
 {
  this.x=x;
  this.y=y;
 }
 @Override
 public int hashCode() {
  final int PRIME = 31;
  int result = 1;
  result = PRIME * result + x;
  result = PRIME * result + y;
  return result;
 }
 @Override
 public boolean equals(Object obj) {
  if (this == obj)
   return true;
  if (obj == null)
   return false;
  if (getClass() != obj.getClass())
   return false;
  final Position other = (Position) obj;
  if (x != other.x)
   return false;
  if (y != other.y)
   return false;
  return true;
 }
}

 

阁人
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构算法实现严蔚敏教材
04-13
给大家参加，因为数据结构是思想，大部分都是自己想的，又结合了C++的各种特性加深自己的记忆，所以看起来有点奇怪，因为是学习，所以肯定免费，相互交流，也顺便为自己算法存个档，以后好复习，哈哈。
严蔚敏数据结构课本算法实现（部分）
06-06
严蔚敏数据结构课本算法实现，不完全，实际运行代码要补充细节，调试
迷宫算法（DFS）
m0_53157173的博客
03-07 1万+
1.如果采用堆栈进行迷宫探测，则称之为深度优先搜索（DFS），它和递归的探测思路是基本一致的，可以看成是递归方式的非递归版本； 2.采用队列进行迷宫探测，则是广度优先搜索（BFS），广度优先搜索法利用队列的特点，一层层向外扩展查找可走的方块，直到找到出口为止，最先找到的这个答案就必然是最短的。 如果打比喻来说，DFS更适合模拟机器人走迷宫的方式，看到一个方向是通的，就一直走下去，遇到死胡同就退回；BFS则好比一个人站在迷宫入口处，拿出一堆小探测器，每个小探测器帮他搜索一个可能的路径去寻找，第一个找到出口的
游戏常用算法：四种迷宫生成算法
august5291的博客
09-18 8655
https://www.fgba.net/sitemap.xml
迷宫算法 之 迷宫生成和迷宫寻路
Globalizationa的博客
06-14 2409
本文讲解迷宫生成和迷宫寻路算法。 //////////////////////////////////////////////////////////////////////////////////////////////////// 一、三种迷宫生成算法 　　　　1、 DFS（即深度优先）算法生成，分为递归和非递归方法。 　　　　2、 十字分割算法生成，分为递归和非递归方法。 　　　　3、随机 Prim 算法生成，一种非递归方法。 二、两种迷宫寻路算法 　　　　1、DFS 寻路，采用非...
解密迷宫问题：三种高效算法Java实现，让你轻松穿越未知迷宫
xxxzzzqqq_的博客
04-26 4225
我们总结一下，在迷宫问题中，深度优先搜索（DFS）、广度优先搜索（BFS）和 A* 都可以用来寻找最短路径或最优解。空间要求低，不需要保存整个搜索树，只需要保存当前路径；所有解的路径长度差别不大，或者只需要找到其中一个解；迷宫比较大，而且有很多死路，采用 DFS 可以快速探索大面积空间。需要找到最短路径或最优解；迷宫中大部分路径长度差别不大；可以承受较大的空间复杂度，需要保存整个搜索树。需要找到最短路径或最优解；需要考虑迷宫中的障碍物，即寻找一条避开障碍物的路径；
迷宫问题的三种求解方法（递归求解、回溯求解和队列求解）
永远飞翔的鸟
03-25 1万+
目录 一、迷宫问题的三种求解方法 递归求解 回溯求解 队列求解 二、华为迷宫问题 一、迷宫问题的三种求解方法 在迷宫问题中，给定入口和出口，要求找到路径。本文将讨论三种求解方法，递归求解、回溯求解和队列求解。 在介绍具体算法之前，先考虑将迷宫数字化。这里将迷宫用一个二维的list存储（即list嵌套在list里），将不可到达的位置用1表示，可到达的位置用0表示，并将已经到过的位置用...
严蔚敏数据结构课本算法实现
06-17
严蔚敏数据结构课本上的算法算法实现，还有相关的例子，考研的同学可以看看，比较经典
数据结构算法实现（严蔚敏版配套实现程序）
02-03
1.1 数组和字符串 2 1.1.1 一维数组的倒置 2 范例1-1 一维数组的倒置 2 ∷相关函数：fun函数 1.1.2 一维数组应用 3 范例1-2 一维数组应用 3 1.1.3 一维数组的高级应用 5 范例1-3 一维数组的高级应用 5 ...
严蔚敏版《数据结构》代码实现
01-13
这些代码主要是针对严蔚敏老师的《数据结构》一书中的大部分伪代码编辑的代码，能够正常运行，是基于C++编写的代码，包括，数组线性表，链表线性表、双向链表、顺序栈、链栈、链队列，顺序队列，循环队列、KMP算法、...
三种迷宫算法（深度优先、随机Prim、递归分割）
积微成著
06-30 3681
之前同学参加面试，面试官问到迷宫生成算法，这个问题自己想了下也没有好办法，所以就查询了相关资料。这里进行了相关整理： 本文主要讲解的迷宫生成算法有三种： 2.Randomized Prim's algorithm（随机Prim算法，让我想起了最小生成树的Prim算法） 3.Recursive division （递归分割算法） 首先，为了方便后续处理，默认的迷宫元素表示为[x,y,w]： 1.我们的迷宫为常规的矩形，因此可以用二维表示一个迷宫单元,每个迷宫单元表示为一个二维数组元素[x,y...
经典算法----迷宫问题（找出所有路径）
m0_73633088的博客
10-07 2875
经典算法-----迷宫问题（栈的应用）-CSDN博客），但是这个方法只可以找到一条路径，那么今天我们就进一步去讲解迷宫问题，通过回溯算法来找到全部的路径，下面就一起来看看吧！同样的，每走到一个位置就要想该往哪一个方向去走，所以有东南西北这4个方向，每次往一个方向走之后就标记好当前方向和当前位置，然后同样的去进行分享的试探，当走到没路走的时候就进行原路返回。//试探方向存储结构int xx, yy;}Direction;//东南西北。
四大迷宫算法
ZJC'博客
09-22 860
下图是算法使用的地图，地图最外围默认是一圈墙，其中白色单元是迷宫单元，黑色单元是墙，相邻白色单元之前的墙是可以被去掉的。可以看到这个地图中所有的迷宫单元在地图中的位置(X,Y），比如（1，1），（5，9）都是奇数，可以表示成(2 * x+1, 2 * y+1), x和y的取值范围从0到4。在迷宫生成算法中会用到这个表示方式。同时迷宫的长度和宽度必须为奇数。 递归回溯是一个深度优先算法，如果当前单...
迷宫随机生成算法
twopointfive的专栏
03-23 5158
迷宫随机生成算法
迷宫生成算法总结
哆啦A瑶的博客
01-31 5041
最近闲来无事想做一个质量高一点的进阶版的迷宫小游戏，首先就要先生成最基础的迷宫地图，因此学习并整理了一下迷宫生成算法。由于python更容易实现这些算法，因此首先使用pyhon将各种生成算法整理一遍，之后再用Qt或者javascript重写一遍，再加上可视化。 大概了解了一下，生成迷宫的算法主要有三种思路，其中最小生成树算法又可以分为选点法（prim）和选边法（kruskal）： 随机深度优先算...
随机迷宫生成算法
m0_71281852的博客
06-16 1326
迷宫算法有三大算法：深度优先算法、prim算法和递归分割算法。这里用的是深度优先算法。要求首先是，迷宫只有一条正确的路径可以从起点走向终点，而我们要做的就是生成只有一条正确路径的迷宫，就像建立道路一样，我们挖的道路就像树结构，树上有很多的分支，分支也有子分支，每个子分支都不能相交，相交了就说明道路相同了，那么此时的迷宫就可能存在多条正确道路，这不是我们需要做的。那么基于唯一道路的原则，我们向某个方向挖一块新的区域时，要先判断新区域是否有和其他道路相通的可能，如果有我们应该换个方向建立道路，可以如此解释代码实
回溯算法解迷宫问题（java版）
tianyaleixiaowu的专栏
03-21 1万+
以一个M×N的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计程序，对任意设定的迷宫，求出从入口到出口的所有通路。     下面我们来详细讲一下迷宫问题的回溯算法。     该图是一个迷宫的图。1代表是墙不能走，0是可以走的路线。只能往上下左右走，直到从左上角到右下角出口。     做法是用一个二维数组来定义迷宫的初始状态，然后从左上角开始，不停的去试探所有可行的路线，碰到1就结束本次
迷宫算法
weixin_43793218的博客
11-01 1278
数据结构迷宫算法 目录一.题目叙述二.大致题意三.解题思路四.测试结果四.源码 一.题目叙述 从入口出发，按某一方向向前探索，若能走通（未走过的），即某处可以到达，则到达一个新点，否则试探下一个方向；若所有的方向均没有通路，则沿原路返回前一点，换下一个方向继续试探，直到所有可能的通路都搜索到，或找到一条通路，或无路可走又返回到入口点。这里可以用一个栈来实现，每走一步，将该位置压入栈中，若该点无路...
三大迷宫生成算法 (Maze generation algorithm) -- 深度优先，随机Prim，递归分割
热门推荐
Much effort, much prosperity.
06-12 7万+
之前同学参加面试，面试官问到迷宫生成算法，这个问题自己想了下也没有好办法，所有就查询了相关资料。这里进行了相关整理： 本文主要讲解的迷宫生成算法有三种： 1.Recursive backtracker ( 递归回溯，也是深度优先算法） 2.Randomized Prim's algorithm（随机Prim算法，让我想起了最小生成树的Prim算法） 3.Recursive division
数据结构与算法严蔚敏 c++
最新发布
01-20
《数据结构与算法》是由严蔚敏、吴伟民合著的一本经典教材。这本书系统地介绍了数据结构和算法方面的基本知识和应用技巧。它以清晰的逻辑结构和丰富的示例，深入浅出地向读者介绍了数据结构中的线性表、树、图等基本...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值