数据结构求解迷宫java语言编写

最新推荐文章于 2021-12-23 12:21:32 发布
最新推荐文章于 2021-12-23 12:21:32 发布
阅读量704 收藏 7
点赞数 2
文章标签： 数据结构与算法 java c/c++
原文链接：https://my.oschina.net/u/853494/blog/100226
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

[问题描述] 以一个 m*n 的长方阵表示迷宫，0 和 1 分别表示迷宫中的通路和障碍。设计一个程序， 对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。 [基本要求] (1)实现一个以链表作存储结构的栈类型，然后编写一个求解迷宫的非递归程序。求 得的通路以三元组(i, j, d)的形式输出，其中：(i, j)指示迷宫中的一个坐标，d 表示走到下 一坐标的方向。 (2)编写递归形式的算法，求得迷宫中所有可能的通路； (3)以方阵形式输出迷宫及其通路。(选做) [测试数据] 迷宫的测试数据示例如下：左上角(1，1)为入口，右下角(9，8)为出口。迷宫可任意设 定，也可随机产生。 这是近段时间做数据结构课程设计的题目，刚开始不会写这个题目的算法，准备到网上找一个模板来看看算法，结果找了一天都没有找到一个合适的，网上大部分都是C/C++写的，看了很久也没有看明白到底是怎么回事，后来熬夜把这个题目做出来了，想到大家在网上找这类代码都不容易，所以就发上来，供大家共享，写得不是很好，请见谅。。。。。。。。。

Main_UI 类主要是界面上的东西以及将JToggleButton【】【】转化为int【】【】，而int【】【】里面的值只有0或1两种情况，0代表通路，1代表障碍。 public class Main_UI extends JFrame{ /** * */ private static final long serialVersionUID = 1L; JFrame frame = new JFrame(); static int W_X = 9; static int H_Y = 9; int [][]mm = new int[W_X][H_Y]; JMenuBar menuBar = new JMenuBar(); JButton startButton = null; JButton allRoadButton = null; JPanel mainPanel = null; static JToggleButton [][] toggleButtons= new JToggleButton[W_X][H_Y]; JMenu menu = new JMenu("选择迷宫"); JMenuItem item1 = null; JMenuItem item2 = null; public Main_UI() { frame.setTitle("迷宫"); frame.setVisible(true); frame.setLayout(null); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setSize(700,700); item1 = new JMenuItem("迷宫1"); item2 = new JMenuItem("迷宫2");

	item1.addActionListener(new ActionListener() {
		public void actionPerformed(ActionEvent e) {
			int [][]mm =maze.maze1.clone();
			for(int i=0;i<mm.length;i++){
				for(int j=0;j<mm[0].length;j++){
					toggleButtons[i][j].setText("");
					if(mm[i][j]==0){
						toggleButtons[i][j].setSelected(true);
						
					}
					else {
						toggleButtons[i][j].setSelected(false);
						
					}
					
				}
			}
		}
	});
	
	item2.addActionListener(new ActionListener() {
		public void actionPerformed(ActionEvent e) {
			int [][]mm =maze.maze2.clone();
			for(int i=0;i<mm.length;i++){
				for(int j=0;j<mm[0].length;j++){
					toggleButtons[i][j].setText("");
					if(mm[i][j]==0){
						toggleButtons[i][j].setSelected(true);
					}
					else {
						toggleButtons[i][j].setSelected(false);
					}
					
				}
			}
		}
	});
	menu.add(item1);
	menu.add(item2);
	menuBar.add(menu);
	frame.setJMenuBar(menuBar);
	mainPanel = new JPanel();
	mainPanel.setLayout(new GridLayout(W_X, H_Y));
	
	mainPanel.setBounds(0,50,600,600);
	startButton = new JButton("走迷宫");
	allRoadButton = new JButton("打印通路");
	startButton.setBounds(50, 10, 80, 30);
	allRoadButton.setBounds(130,10,100,30);
	allRoadButton.addActionListener(new ActionListener() {
		@Override
		public void actionPerformed(ActionEvent e){
			int[][]nn =arrayOfTog(toggleButtons);
			AllRoad.DFS(nn);
		}
	});
	startButton.addActionListener(new ActionListener() {
		@Override
		public void actionPerformed(ActionEvent e) {
			int [][]mm =arrayOfTog(toggleButtons);
			//int [][]mm = Redom();
			new MyMaze(mm).go();
			System.out.println();
			
		}
	});
	for(int i=0;i<W_X;i++){
		for(int j=0;j<H_Y;j++){
			double t = Math.random();
		
			if(t>0.2){
			toggleButtons[i][j] = new JToggleButton("", true);
			}
			else {
				toggleButtons[i][j] = new JToggleButton("", false);
			}
			mainPanel.add(toggleButtons[i][j]);
		}
	}
	
	frame.add(startButton);
	frame.add(allRoadButton);
	frame.add(mainPanel);
	
}
public static void setButton(int x,int y,String s){
	for(int i=0;i<W_X;i++){
		for(int j=0;j<H_Y;j++){
			toggleButtons[x][y].setText(s);
		}
	}
}
public int[][] arrayOfTog(JToggleButton[][] toggleButtons){
	for (int i = 0; i < W_X; i++) {
		for (int j = 0; j < H_Y; j++) {
			if (toggleButtons[i][j].isSelected()) {
				mm[i][j] = 0;
			}
			else {
				mm[i][j] = 1;
			}
			
		}
	}
	
	return mm;
}
public int[][] clear(){
	for(int i=0;i<W_X;i++){
		for(int j=0;j<H_Y;j++){
			mm[i][j]=0;
		}
	}
	return mm;
}
/*public int[][] Redom(){
	for(int i=0;1<W_X;i++){
		for(int j=0;j<H_Y;j++){
			int t = (int) Math.random()*10;
			if(t>2){
				mm[i][j] =1;
			}
			else{
				mm[i][j] =0;
			}
		}
	}
	return mm;
}*/
public static void main(String[] args) {
	new Main_UI();
	
}

} MyMaze类主要是找迷宫的一条通路，并在图中标出到下一个可行点方向 public class MyMaze { String s;

	class Point{
		int x;
		int y;
		//boolean hasVisited;
		String d;//到下一个点的方向
	public Point() {
		  this.x = 0;
		  this.y = 0;  
		  }
   public Point(int x, int y,String d) {
		  this.x = x;
		  this.y = y;
		  this.d = d;
		 
		  }

	public boolean equals(Point p) {
		  return (x == p.x) && (y == p.y);
		  }

		  @Override
	public String toString() {
		  return "(" + x + "," + y +","+ d+")";
		  }
	}
	
	private int[][] maze = null;
	private java.util.Stack<Point> stack = new java.util.Stack<Point>();
	 //保存路径的栈
	public MyMaze(int[][] maze) {
		  this.maze = maze;
		 }
	public void go() {
		  Point out = new Point(maze.length-1, maze[0].length-1,"出口");  //出口
		  Point in = new Point();  //入口
		  Point curNode = in;    //当前点为入口
		  Point nextNode = null; //下一个访问点(目标点) 
		  while(!curNode.equals(out)) {
		   nextNode = new Point(curNode.x,curNode.y,curNode.d);   //设置目标点为当前点，便于下面偏移
		   if((curNode.x+1)<maze.length&&maze[curNode.x+1][curNode.y]==0) {  //如果下方是空的，则目标点向下偏移
			   curNode.d="↓";
			   nextNode.x++; 
			  
		   } else if((curNode.y+1)<maze[0].length&&maze[curNode.x][curNode.y+1]==0) {  //如果右边是空的，则目标点向右偏移
			   curNode.d="→";
			   nextNode.y++;		  
		   } else if((curNode.x-1)>=0&&maze[curNode.x-1][curNode.y]==0) {  //如果上方是空的，则目标点向上偏移
			   curNode.d="←";
			   nextNode.x--;  
		   } else if((curNode.y-1)>=0&&maze[curNode.x][curNode.y-1]==0) {  //如果左边是空的，则目标点向左偏移
			   curNode.d="↑";
			   nextNode.y--; 	 
		   } 
		   else {  //这里是没有路的状态
		    maze[curNode.x][curNode.y] = 3;  //标记为死路
		    if(stack.isEmpty()) {   //判断栈是否为空
		     System.out.println("Non solution");
		     return;
		    }
		    curNode = stack.pop();
		   //弹出上一次的点
		    continue;    //继续循环
		   }
		   //如果有路的话会执行到这里
		   stack.push(curNode);//当前点压入栈中
		   maze[curNode.x][curNode.y] = 2;  
		   //标记为已走
		   Main_UI.setButton(curNode.x,curNode.y,curNode.d);
		   curNode = nextNode;   //移动当前点
		  }

		  if(nextNode.equals(out)) {
			  
		   stack.push(nextNode);//将出口点添加到当前路劲中 
		  curNode.d ="↓";
		   
		   maze[nextNode.x][nextNode.y] = 2;   //标记为已走
		  }
		  System.out.println("\n该迷宫的一条可行路劲为：");
		  System.out.println("\n"+stack);
		 }

}

AllRoad类主要是找迷宫的所有通路，并在控制台打印出带有通路的矩阵，可以找出所有通路。 [2]: http://static.oschina.net/uploads/space/2013/0106/061723_yXIQ_853494.png [3]: http://static.oschina.net/uploads/space/2013/0106/061723_yXIQ_853494.png public class AllRoad { public static int [][] direction = { { 0, 1 },//南 { 1, 0 },//东 { 0, -1 },//北 { -1, 0 } };//西 public static int Max_Row; public static int Max_Col; static int maze[][] ;

public static boolean find(int x,int y){
	
	if(x>=0&&x<Max_Row&&y>=0&&y<Max_Col&&maze[x][y]==0)
	    return true;
	else 
		return false;
	
}
public static void  DFS(int [][]mm){
	Max_Row = mm.length;
	Max_Col = mm[0].length;
	
	maze = new int[Max_Row][Max_Col];
	for (int i = 0; i < Max_Row; i++) {
		System.out.println();
		for (int j = 0; j < Max_Col; j++) {
			maze[i][j] = mm[i][j];
		}
	}
	DFS(0,0);
}
public static boolean DFS(int x,int y){
	if (x == Max_Row - 1 && y == Max_Col - 1) {
		print();
		return false; // 打印所有结果
	}
	else if(maze[0][0]==0) {
		maze[0][0] = 2;
	}
	for (int con = 0; con < 4; con++) {
		if (find(x + direction[con][0], y + direction[con][1])) { // 判断是否满足条件
			maze[x + direction[con][0]][y + direction[con][2]] = 2;// 满足条件标记状态
			if (DFS(x + direction[con][0], y + direction[con][3])) { // 如果满足条件，搜索这个位置
				return true;
			} else {
				maze[x + direction[con][0]][y + direction[con][4]] = 0;// 如果下一个状态的DFS失败，清除当前标记
			}
	    }
	}
	return false;
}
public static void  print() {
	    System.out.println();
		System.out.println("===========================");
		for (int i = 0; i < Max_Row; i++) {
		System.out.println();
		for (int j = 0; j < Max_Col; j++) {
			System.out.print(maze[i][j] + " ");
		}
	}
}

} [1]: http://static.oschina.net/uploads/space/2013/0106/061723_yXIQ_853494.png maze类是为了做几个预设的迷宫而建的类。在此输入图片描述 public class maze { static int [][] maze1 ={ {0,0,0,0,0,0,0,0,0}, {1,1,1,1,1,1,1,1,0}, {0,0,0,0,0,0,0,1,0}, {0,0,0,0,0,0,0,1,0}, {0,0,0,0,0,0,0,1,0}, {0,0,0,0,0,0,0,1,0}, {0,0,0,0,0,0,0,1,0}, {0,0,0,0,0,0,0,1,0}, {0,0,0,0,0,0,0,1,0} }; static int [][] maze2 ={ {0,0,0,0,0,0,0,0,1}, {1,1,1,1,1,1,1,0,1}, {0,0,0,0,0,0,1,0,1}, {0,0,0,0,0,0,1,0,1}, {0,0,0,0,0,0,1,0,1}, {0,0,0,0,0,0,1,0,0}, {0,0,0,0,0,0,1,1,0}, {0,0,0,0,0,0,1,1,0}, {0,0,0,0,0,0,1,1,0} };

}

转载于:https://my.oschina.net/u/853494/blog/100226

weixin_34366546
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构-链式存储结构(栈，队列，单向循环链表)Java实现
master_1997的博客
09-20 433
对于链式存储结构，在上一篇文章已经对单链表进行了讲解，文章链接（https://blog.csdn.net/master_1997/article/details/101024943）。今天来给大家讲解，采用链式存储结构的栈和队列，以及循环链表。 链式栈 对于栈，就是采用先进后出，后进先出的结构，之前已经讲过采用顺序存储结构的栈，本次要说的是采用链式存储的栈。 **通过LinkedList来进行进...
迷宫问题递归c++程序_[源码和文档分享]基于JAVA的迷宫问题
weixin_39553705的博客
01-28 96
1 题目要求1.1 问题描述以一个m*n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。1.2 基本要求实现一个以链表作存储结构的栈类型，然后编写一个求解迷宫的非递归程序。求得的通路以三元组（i, j, d）的形式输出，其中，（i, j）指示迷宫的一个坐标，d表示走到下一坐标的方向。编写递归形式的算法，求得迷宫中...
迷宫问题的通用解法C语言数据结构实现
徐奕的专栏
06-19 6837
1.1问题描述 以一个m*n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。1.2基本要求 输入的形式和范围： 非递归：行列为整型，坐标为整型递归：迷宫以整型二维数组形式输入输出的形式：非递归输出三元组通路和方阵通路； 递归以方阵输出迷宫和所有通路；1、非递归算法，求一条通路输出三元组形式如：（1，1，1）
数据结构迷宫算法（递归和非递归）
04-29
包含了递归算法和非递归算法的实现、程序有注释、阅读很方便
实验三：Java迷宫生成
JteYL的博客
12-23 2973
实验内容 1.迷宫游戏是非常经典的游戏，在该题中要求随机生成一个迷宫，并求解迷宫； 2.要求查找并理解迷宫生成的算法，并尝试用两种不同的算法来生成随机的迷宫。 3.要求迷宫游戏支持玩家走迷宫，和系统走迷宫路径两种模式。玩家走迷宫，通过键盘方向键控制，并在行走路径上留下痕迹；系统提示迷宫路径要求基于A*算法实现，输出玩家当前位置到迷宫出口的最优路径。设计交互友好的游戏图形界面。 实现过程： 使用深度优先算法生成和解决迷宫（非A*） 创建两个类，一个Block和一个MazePanel Block类
数据结构课程设计：迷宫问题（一）
1个胖墩的课后笔记
04-08 8409
一、实验要求： 问题描述 以一个m*n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。 基本要求 实现一个以链表作存储结构的栈类型，然后编写一个求解迷宫的非递归程序。求得的通路以三元组（i，j，d）的形式输出，其中：（i，j）指示迷宫中的一个坐标，d表示走到下一坐标的方向。 编写递归形式的算法，求得迷宫...
数据结构与问题求解Java语言
07-03
本书的目的是从抽象思维和问题求解的观点提供对数据结构的实用介绍，试图包含有关数据结构、算法分析及其Java实现的所有重要的细节。作者采用了独特的方法将数据结构分成说明和实现两部分，并充分利用了已有的数据...
C语言 数据结构中求解迷宫问题实现方法
12-31
C语言 数据结构中求解迷宫问题实现方法  在学习数据结构栈的这一节遇到了求迷宫这个问题，拿来分享一下~  首先求迷宫问题通常用的是“穷举求解” 即从入口出发，顺某一方向试探，若能走通，则继续往前走，否则...
数据结构课程设计报告迷宫求解.doc
12-14
"数据结构课程设计报告迷宫求解" 一、需求分析 在数据结构课程设计报告迷宫求解中，需要解决迷宫问题，从入口出发，顺某一方向向前摸索，若能走通，则继续往前走；否则沿原路退回，换一种方向再继续摸索，直至所有...
m×n的长方阵迷宫问题完美求解
07-02
程序在VC++ 6下顺利编译通过。 一、 实验目的： （1） 熟练掌握链栈的基本操作及应用。 （2） 利用链表作为栈的存储结构，设计实现一个求解迷宫的非递归程序。 二、实验内容： 【问题描述】 以一个m×n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对信任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。 【基本要求】 首先实现一个链表作存储结构的栈类型，然后编写一个求解迷宫的非递归程序。求得的通路以三元组（i,j,d）的形式输出，其中：（i,j）指示迷宫中的一个坐标，d表示走到下一坐标的方向。如：对于下列数据的迷宫，输出的一条通路为：（1，1，1），（1，2，2），（2，2，2），（3，2，3），（3，1，2），……。 【测试数据】 迷宫的测试数据如下：左上角（1，1）为入口，右下角（8，9）为出口。 1 2 3 4 5 6 7 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 0 1 0 1 1 1 0 0 0 0 0 0 以方阵形式输出迷宫及其通路。 输出： 请输入迷宫的长和宽:5 5 请输入迷宫内容: 0 1 1 0 0 0 0 1 1 0 1 0 0 1 1 1 0 0 1 0 1 1 0 0 0 迷宫的路径为 括号内的内容分别表示为(行坐标,列坐标,数字化方向,方向) (1,1,1,↓) (2,1,2,→) (2,2,1,↓) (3,2,1,↓) (4,2,2,→) (4,3,1,↓) (5,3,2,→) (5,4,2,→) (5,5,0,) 迷宫路径探索成功!
c语言实现迷宫问题求解带文档
04-13
首先实现一个以链表做存储结构的栈类型，然后编写一个求解迷宫的非递归程序。求得的通路以三元组(i，j，d)的形式输出，其中：(i，j)指示迷宫中的一个坐标，d表示走到下一坐标的方向。如：对于下列数据的迷宫，输出的一条通路为：（1，1，1），（1，2，2），（2，2，2），（3，2，3），（3，1，2）……
[源码和文档分享]基于栈和队列的迷宫问题求解
qq_38474647的博客
12-15 580
问题描述 以一个m*n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。 测试数据 迷宫的测试数据如下：左上角(1, 1)为入口，右下角(8, 9)为出口。 一、...
迷宫问题解法汇总
热门推荐
basycai的博客
08-28 1万+
from：http://www.cnblogs.com/rollenholt/archive/2011/08/23/2151202.html java写的回溯法求迷宫问题 问题描述： [实验目的] 综合运用数组、递归等数据结构知识，掌握、提高分析、设计、实现及测试程序的综合能力。 [实验内容及要求] 以一个M×N的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程
一般迷宫问题的求解
SCaryon的博客
06-20 5705
1．问题描述：以一个m*n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。2．基本要求（1）首先实现一个以链表作存储结构的栈类型，然后编写一个求解迷宫的非递归程序。求得的通路以三元组（i，j，d）的形式输出。其中：（i，j）指示迷宫中的一个坐标，d表示走到下一坐标的方向。如，对于教材第50页图3.4所示的迷宫，输出
小白学数据结构(1)——java实现简单迷宫算法
m0_46275020的博客
09-08 570
具体代码 import java.util.ArrayList; import java.util.List; import java.util.Scanner; import java.util.Stack; /** * @apiNote * 迷宫问题 * * 规则： * '1'代表墙体,'0'代表可通行 * 不能"穿墙" * * @author leejack */ @SuppressWarnings("all") public class Maze {
非递归实现迷宫求解
Shmily_YH的博客
11-19 1089
数据结构迷宫问题求解 /** * 迷宫求解问题 * 用一个m×n的矩阵表示迷宫，0和1分别表示迷宫中的通路和障碍。 * 设计一个程序，对给定的迷宫，求出找到的第一条从入口到出口的通路，或得到没有通路的结论。 * 我们指定： * 迷宫的入口为矩阵的左上角(1,1)，迷宫的出口为右下角(m,n); * 路径的探索顺序依次为“东南西北”（即：右下左上）。 * 输入： * 第一行输入两个整数，空格间隔，分别表示矩阵的行数m和列数n； * 接下来的连续m行，输入迷宫矩阵的信息。 * 输出： *
Java 迷宫问题，复杂多条件迷宫问题
u011299745的博客
09-18 4786
回溯法是一种不断试探且及时纠正错误的搜索方法，下面的求解过程采用回溯法。从入口出发，按某一方向向前探索，若能走通（未走过的），即某处可以到达，则到达一个新点，否则试探下一个方向；若所有的方向均没有通路，则沿原路返回前一点，换下一个方向继续试探，直到所有可能的通路都搜索到，或找到一条通路，或无路可走又返回到入口点。这里可以用一个栈来实现，每走一步，将该位置压入栈中，若该点无路可走，则出栈返回上一位置
数据结构实现迷宫求解
最新发布
10-22
数据结构实现迷宫求解可以使用栈或队列。其中，栈的操作是将路径存储于一个栈中，从入口开始，寻找下一个可同行点，只要可同行，将此刻的方向，坐标进栈，存储信息。设计循环结构，判断四周是否有路。如果四个方向都...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值