java写的迷宫代码

最新推荐文章于 2023-09-22 11:01:47 发布
最新推荐文章于 2023-09-22 11:01:47 发布
阅读量263 收藏 2
点赞数
文章标签： java 数据结构与算法
原文链接：http://www.cnblogs.com/luzhihen/p/3703649.html
版权 


迷宫代码：
截图如下：

package com.zxl.maze;

/*
 * 抽象类表示选择不同的算法*/
public abstract class AbstractMap
{
    /*
     * 得到数据*/
    public abstract boolean[][] getData(int m,int n);
    /*
     * 重置*/
    public abstract void reset(int m,int n);
}


package com.zxl.maze;

/*
 *深度优先，生成迷宫*/
import java.awt.Point;
import java.util.Random;
import java.util.Stack;

public class DFSMap extends AbstractMap
{
    private int m = 30, n = 30;
    private boolean a[][];
    private int currX, currY;
    private Stack<Point> stack;// 保存已走路径
    private int[] X_GO1 = { -2, 2, 0, 0 };
    private int[] Y_GO1 = { 0, 0, 2, -2 };
    private int[] X_GO2 = { -1, 1, 0, 0 };
    private int[] Y_GO2 = { 0, 0, 1, -1 };

    public DFSMap()
    {
        stack = new Stack<Point>();
    }

    @Override
    public boolean[][] getData(int m,int n)// 得到数据
    {
        // TODO Auto-generated method stub

        reset(m, n);
        return a;
    }

    @Override
    public void reset(int m, int n)// 重置
    {
        // TODO Auto-generated method stub

        a = new boolean[2 * m + 1][2 * n + 1];
        this.m = 2 * m + 1;
        this.n = 2 * n + 1;
        for (int i = 0; i < this.m; i++)
            for (int j = 0; j < this.n; j++)
                a[i][j] = false;
        currX = 1;
        currY = 1;
        stack.clear();
        stack.push(new Point(1, 1));
        a[1][0] = true;
        a[1][1] = true;
        start();
    }

    private boolean check()// 判断是否全部走过。。。
    {
        for (int i = 1; i < m; i += 2)
        {
            for (int j = 1; j < n; j += 2)
            {
                if (a[i][j] == false)
                    return false;
            }
        }
        return true;
    }

    private void forward()// 后退一步
    {
        if (stack.size() > 0)
        {
            Point p = stack.pop();
            currX = (int) p.getX();
            currY = (int) p.getY();
        }
        else
        {
            goRandPosition();
        }
    }

    private void goRandPosition()
    {
        int i, j;
        while (true)
        {
            i = (int) (Math.random() * m);
            j = (int) (Math.random() * n);
            if (a[i][j] == true && i % 2 == 1 && j % 2 == 1)
            {
                stack.push(new Point(i, j));
                currX = i;
                currY = j;
                break;
            }
        }
    }

    private void start()// 具体操作
    {
        while (!check())
        {
            go();
        }
        a[m - 2][n - 1] = true;
    }

    private void go()
    {
        int orders[] = getOrder(4);
        for (int i = 0; i < orders.length; i++)
        {
            if (isSafe(currX + X_GO1[orders[i]], currY + Y_GO1[orders[i]]))// 上
            {
                goNext(orders[i]);
                return;
            }
        }
        forward();
    }

    private void goNext(int i)// 下一步
    {
        // TODO Auto-generated method stub
        a[currX + X_GO1[i]][currY + Y_GO1[i]] = true;
        a[currX + X_GO2[i]][currY + Y_GO2[i]] = true;
        stack.push(new Point(currX, currY));
        currX += X_GO1[i];
        currY += Y_GO1[i];
    }

    private int[] getOrder(int i)// 产生随机序列
    {
        // TODO Auto-generated method stub
        int a[] = new int[i];
        Random ran = new Random();
        for (int j = 0; j < i; j++)
            a[j] = j;
        for (int k = 0; k < i; k++)
        {
            int r1 = ran.nextInt(i);
            int r2 = ran.nextInt(i);
            int b = a[r1];
            a[r1] = a[r2];
            a[r2] = b;
        }
        return a;
    }

    private boolean isSafe(int x, int y)
    {

        if (x < 0 || x >= m || y < 0 || y >= n || a[x][y] == true)
        {
            return false;
        }
        return true;
    }

}

package com.zxl.maze;

/*
 * 随机prim算法的核心是（翻译的维基）：
 1、让迷宫全是墙
 2、选一个格作为迷宫的通路，然后把它的邻墙放入列表
 3、当列表里还有墙时
 ——1、从列表里随机选一个墙，如果它对面的格子不是迷宫的通路
 ————1、把墙打通，让对面的格子成为迷宫的通路
 ————2、把那个格子的邻墙加入列表
 ——2、如果对面的格子已经是通路了，那就从列表里移除这面墙*/
import java.awt.Point;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class PriMap extends AbstractMap
{
    private int m = 0, n = 0;
    private boolean a[][];
    private int currX, currY;// 记录当前格子位置
    private List<Point> set;// 用作队列，存放墙
    private int[] X_GO1 = { 1, 0, -1, 0 };
    private int[] Y_GO1 = { 0, -1, 0, 1 };

    public void reset(int m, int n)
    {
        this.m = 2 * m + 1;
        this.n = 2 * n + 1;
        a = new boolean[this.m][this.n];
        for (int i = 0; i < this.m; i++)
            for (int j = 0; j < this.n; j++)
                a[i][j] = false;
        currX = 1;
        currY = 1;
        set.clear();
        set.add(new Point(1, 2));
        set.add(new Point(2, 1));
        a[1][0] = true;
        a[1][1] = true;
        go();
        a[this.m - 2][this.n - 1] = true;

    }

    public void go()
    {
        while (set.size() > 0)
        {
            if (choiceWall())// 选择墙
            {
                addWall(currX, currY);// 将墙的临墙加入队列
            }
        }

    }

    private boolean choiceWall()
    {
        // TODO Auto-generated method stub
        Random r = new Random(System.currentTimeMillis());
        Point p = set.remove(r.nextInt(set.size()));
        int x = (int) p.getX();
        int y = (int) p.getY();
        if (test(x, y) == 1)
        {
            if (isSafe(x - 1, y) && a[x - 1][y] == false)
            {
                a[x][y] = true;
                currX = x - 1;
                currY = y;
                a[currX][currY] = true;
                return true;
            }
            else if (isSafe(x + 1, y) && a[x + 1][y] == false)
            {
                a[x][y] = true;
                currX = x + 1;
                currY = y;
                a[currX][currY] = true;
                return true;
            }
        }
        else if (test(x, y) == 2)
        {
            if (isSafe(x, y - 1) && a[x][y - 1] == false)
            {
                a[x][y] = true;
                currX = x;
                currY = y - 1;
                a[currX][currY] = true;
                return true;
            }
            else if (isSafe(x, y + 1) && a[x][y + 1] == false)
            {
                a[x][y] = true;
                currX = x;
                currY = y + 1;
                a[currX][currY] = true;
                return true;
            }
        }
        return false;
    }

    private void addWall(int x, int y)
    {
        // TODO Auto-generated method stub
        for (int i = 0; i < X_GO1.length; i++)
        {
            if (isSafe(currX + X_GO1[i], currY + Y_GO1[i]))
            {
                if (!set.contains(new Point(currX + X_GO1[i], currY + Y_GO1[i])))
                {
                    set.add(new Point(currX + X_GO1[i], currY + Y_GO1[i]));
                }
            }
        }
    }

    private int test(int x, int y)
    {
        if (x % 2 == 0)
            return 1;// 竖线
        else if (y % 2 == 0)
            return 2;// 横线
        else
            return 0;// 出错了
    }

    private boolean isSafe(int x, int y)
    {

        if (x <= 0 || x >= m || y <= 0 || y >= n || a[x][y] == true)
        {
            return false;
        }
        return true;
    }

    @Override
    public boolean[][] getData(int m,int n)
    {
        // TODO Auto-generated method stub
        set = new ArrayList<Point>();
        reset(m, n);
        return a;
    }
}

package com.zxl.maze;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;

import javax.swing.JPanel;

public class MainPanel extends JPanel
{
    int x = 0;
    int y = 0;
    boolean b[][]=null;

    public MainPanel()
    {
        this.setSize(400, 400);
        
    }

    public void setMap(boolean b[][])
    {
        this.b = b;
    }

    @Override
    public Dimension getPreferredSize()
    {
        // TODO Auto-generated method stub
        return new Dimension(400,400);
    }

    public void paintMap(int x, int y)
    {
        this.x = x;
        this.y = y;
        
        repaint();
    }

    @Override
    public void paintComponent(Graphics g)
    {
        // TODO Auto-generated method stub
        if (x == 0&&y==0)
        {
            g.clearRect(0, 0, this.getWidth(), this.getHeight());
        }
        else 
        {
            for(int i=0;i<=x;i++)
                for(int j=0;j<=y;j++)
                {
                    if (b[i][j] == true)
                    {
                        g.setColor(Color.blue);
                        g.fillRect(50 + i * 10, 50 + j* 10, 10, 10);
                    }
                    else
                    {
                        g.setColor(Color.red);
                        g.fillRect(50 + i * 10, 50 + j * 10, 10, 10);
                    }

                }
        }
    }

}

package com.zxl.maze;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;

public class MainFrame extends JFrame
{
    //JButton resetButton;
    Container con;
    boolean b[][];
    JMenu menu;
    JMenuBar bar;
    JMenuItem item;
    MainPanel pan=new MainPanel();
    public MainFrame()
    {
        this.setSize(600,550);
        this.setDefaultCloseOperation(EXIT_ON_CLOSE);
        //resetButton=new JButton("重    绘");
        con=this.getContentPane();
        con.setLayout(new BorderLayout());
        //con.add(resetButton,BorderLayout.SOUTH);
        menu=new JMenu("菜单");
        item=new JMenuItem("绘制地图");
        bar=new JMenuBar();
        bar.add(menu);
        menu.add(item);
        this.add(pan);
        this.setJMenuBar(bar);
        this.setVisible(true);
        //setMap();
        item.addActionListener(new ActionListener()
        {
            
            @Override
            public void actionPerformed(ActionEvent e)
            {
                // TODO Auto-generated method stub
                setMap();
                Thread t=new Thread(new DrawHandler(pan));
                t.start();
            }
        });
    }
    private void setMap()
    {
        // TODO Auto-generated method stub
        this.requestFocus();
        AbstractMap map=new DFSMap();
        b=map.getData(20, 20);
        pan.setMap(b);
        /*for(int i=0;i<b.length;i++)
        {
            for(int j=0;j<b[0].length;j++)
            {        
                pan.paintMap(i, j);    
                try
                {
                    Thread.sleep(10);
                }catch(Exception ex)
                {
                    ex.printStackTrace();
                }
            }
        }*/
    }


class DrawHandler implements Runnable{
    private MainPanel pan;
    public DrawHandler(MainPanel pan){
        this.pan=pan;
    }
    public void run(){
        for(int i=0;i<b.length;i++)
        {
            for(int j=0;j<b[0].length;j++)
            {        
                pan.paintMap(i, j);    
                try
                {
                    Thread.sleep(10);
                }catch(Exception ex)
                {
                    ex.printStackTrace();
                }
            }
        }
    }
}
}

package com.zxl.maze;

public class Test
{
    public static void main(String []args)
    {
        new MainFrame();
    }
}


package com.zxl.maze;

import java.util.Random;

/*
 *深度优先，生成迷宫*/

public class TreeMap extends AbstractMap
{
    private int m = 0, n = 0;
    private boolean a[][];
    private int currX, currY;
    private int[] X_GO1 = { -2, 2, 0, 0 };
    private int[] Y_GO1 = { 0, 0, 2, -2 };
    private int[] X_GO2 = { -1, 1, 0, 0 };
    private int[] Y_GO2 = { 0, 0, 1, -1 };

    @Override
    public boolean[][] getData(int m,int n)// 得到数据
    {
        // TODO Auto-generated method stub
        reset(m,n);
        return a;
    }

    @Override
    public void reset(int m, int n)// 重置
    {
        // TODO Auto-generated method stub
        a = new boolean[2 * m + 1][2 * n + 1];
        this.m = 2 * m + 1;
        this.n = 2 * n + 1;
        for (int i = 0; i < this.m; i++)
            for (int j = 0; j < this.n; j++)
                a[i][j] = false;
        currX = 1;
        currY = 1;
        a[1][0] = true;
        a[1][1] = true;
        start();
    }

    private boolean check()// 判断是否全部走过。。。
    {
        for (int i = 1; i < m; i += 2)
        {
            for (int j = 1; j < n; j += 2)
            {
                if (a[i][j] == false)
                    return false;
            }
        }
        return true;
    }

    private void forward()// 后退一步
    {
        int i, j;
        while (true)
        {
            i = (int) (Math.random() * m);
            j = (int) (Math.random() * n);
            if (a[i][j] == true && i % 2 == 1 && j % 2 == 1)
            {
                currX = i;
                currY = j;
                return;
            }
        }

    }

    private void start()// 具体操作
    {
        while (!check())
        {
            go();
        }
        a[m - 2][n - 1] = true;
    }

    private void go()
    {
        int orders[] = getOrder(4);
        for (int i = 0; i < orders.length; i++)
        {
            if (isSafe(currX + X_GO1[orders[i]], currY + Y_GO1[orders[i]]))// 上
            {
                goNext(orders[i]);
                return;
            }
        }
        forward();
    }

    private void goNext(int i)// 下一步
    {
        // TODO Auto-generated method stub
        a[currX + X_GO1[i]][currY + Y_GO1[i]] = true;
        a[currX + X_GO2[i]][currY + Y_GO2[i]] = true;
        currX += X_GO1[i];
        currY += Y_GO1[i];
    }

    private int[] getOrder(int i)// 产生随机序列
    {
        // TODO Auto-generated method stub
        int a[] = new int[i];
        Random ran = new Random();
        for (int j = 0; j < i; j++)
            a[j] = j;
        for (int k = 0; k < i; k++)
        {
            int r1 = ran.nextInt(i);
            int r2 = ran.nextInt(i);
            int b = a[r1];
            a[r1] = a[r2];
            a[r2] = b;
        }
        return a;
    }

    private boolean isSafe(int x, int y)
    {

        if (x < 0 || x >= m || y < 0 || y >= n || a[x][y] == true)
        {
            return false;
        }
        return true;
    }

}

 

转载于:https://www.cnblogs.com/luzhihen/p/3703649.html

weixin_30672295
关注
java简单迷宫生成代码
02-24
自己写的迷宫生成代码，生成效率还算可以，保证有入口和出口，并且保证能从迷宫走出来，简单的算法，可以研究一下。
java生成迷宫_通过深度优先搜索产生的迷宫的Java代码详解
weixin_29351351的博客
02-21 223
import java.io.FileOutputStream;import java.io.IOException;import java.util.ArrayList;import java.util.Random;public class maziness {private int M;//行数private int N;//列数private int[] visitMatrix;//搜索是...
迷宫游戏代码（java语言编写）
ws_PersonalSpace的博客
09-09 8797
迷宫游戏 题目描述: 用0和1组成一个矩形矩阵，0代表当前位置可走，1代表当前位置不可走。 eg: 0 0 0 0 1 0 1 0 1 0 0 0 1 1 1 0 实现功能: 1.创建迷宫 2.选择迷宫入口和出口 3.搜索从迷宫入口到迷宫出口的所有路径，输出（路径用2表示） 如上例，寻找从迷宫左上角到右下角的路径，结果如下： 第一条： 2 2...
迷宫java游戏代码
05-14
自己做的迷宫代码，主运用在com.wcj.Migong中。应用的是深度搜索方法，可以自己生成地图。值得大虾们学习下。
迷宫java代码_java写的迷宫代码
weixin_42509616的博客
02-12 876
迷宫代码：截图如下：packagecom.zxl.maze;/** 抽象类表示选择不同的算法*/public abstract classAbstractMap{/** 得到数据*/public abstract boolean[][] getData(int m,intn);/** 重置*/public abstract void reset(int m,intn);}packagecom.zx...
使用栈的迷宫算法java版代码
08-28
使用栈的迷宫算法java版代码 使用栈的迷宫算法java版代码是迷宫算法的一种实现方式，主要使用栈来存储迷宫的路径信息。该算法的主要思路是使用栈来标记当前位置是否可走，并保存当前位置信息，然后根据当前位置的...
Java 3D迷宫游戏源代码.rar
07-10
Java游戏源码： 3D迷宫游戏源代码,Java 3D 迷宫,3D Mazes in Java,如果迷宫对键盘没有反应，请点击"About" ,找不到出口的时候点击"Solve" 按钮显示红色的出口线路，点击"Clear" 清除解答。按上、下、左、右光标键...
Java游戏三维迷宫源代码
03-16
内容索引:JAVA源码,游戏娱乐,迷宫　Java Maze3D迷宫游戏源码，浏览器上只要安上JAVA解释器就能运行，三维显示迷宫，点击 "New" 按钮开始迷宫之旅, 找不到出口的时候点击"Solve" 按钮显示红色的出口线路，点击"Clear...
基于JAVA迷宫游戏源码代码.zip
06-15
本游戏的模块大致分为后台引擎和用户界面两大块，后台引擎模块包括深度优先迷宫生成算法和普里姆迷宫生成算法。界面模块包括总体界面设计和设置界面设计。除此之外，还包括一个主界面控制类，用于界面算法和界面生成...
Java迷宫项目代码
Yan_tutou的博客
11-10 1648
java迷宫项目 项目介绍： 一个网格迷宫由n行m列的单元格组成，每个大院要么是空地（用0表示），要么是障碍物（用1表示）。你的任务是找一条从起点到终点的移动序列，其中只能上下左右移动到相邻单元格。任何时候都不能在有障碍物的单元格中，也不能走到迷宫之外。起点为左上角和终点右下角。 项目功能： 解决迷宫路径查找问题，寻找一条从左上角迷宫入口到右下角迷宫出口的一条有效路径，0代表可走，1代表不能行走，找到请输出最终的迷宫和路径信息，找不到请输出不存在有效路径。 项目所用知识点： 采用Java面向对象思想，二维数
java迷宫源码
04-12
这是用java开发的迷宫源码 这要用来DFS算法 Prim算法 树生成算法等
java迷宫程序及代码
12-12
基于深度优先算法与广度优先算法的迷宫生成，及游戏
一个简单的java迷宫生成程序
09-07
我在自己的老电脑上成功了 但是不知道为什么在hp cq45上不成功
Java可视化迷宫（含源代码）
01-18
java写的可视化迷宫 点击画墙 可以拖动画墙 输入起点终点坐标 mark后 可以进行find
随机生成迷宫算法及其 Java 实现
05-27
NULL 博文链接：https://stupid.iteye.com/blog/224414
java迷宫生成代码_maxe.java 源代码在线查看 - Java Maze 计算机自动生成迷宫 资源下载 虫虫电子下载站...
weixin_39530437的博客
02-27 128
public class Maxe{ private int startI, startJ; // 入口 private int endI, endJ; // 出口public void setStart(int i, int j) { this.startI = i; this.startJ = j; } public void se...
【Java基础】迷宫问题的Java代码实现
yubao0723的专栏
04-16 2076
本文使用递归算法来解决迷宫问题，并用java实现
Java实现迷宫
最新发布
CyberSparkZ的博客
09-22 250
首先，让我们定义迷宫的结构。我们使用递归的方式进行深度优先搜索，尝试四个方向的移动：上、下、左、右。在这篇文章中，我将向您展示如何使用Java编程语言实现一个简单的迷宫，并提供相应的源代码。在上面的示例中，我们创建了一个5x5的迷宫网格，并将起点设置为左上角(0, 0)，终点设置为右下角(4, 4)。在这篇文章中，我将向您展示如何使用Java编程语言实现一个简单的迷宫，并提供相应的源代码。在上面的示例中，我们创建了一个5x5的迷宫网格，并将起点设置为左上角(0, 0)，终点设置为右下角(4, 4)。
Java代码实现迷宫找路
qq_53689721的博客
07-15 1790
用Java代码写的迷宫找路问题的程序，其中用到了二维数组和递归，有我这个编程小白对递归思想的浅显见解
用Java语言写走迷宫代码
03-11
我可以回答这个问题。以下是一个简单的Java代码示例，用于解决迷宫问题： ``` public class MazeSolver { private int[][] maze; private boolean[][] visited; private int startRow, startCol, endRow, endCol; public MazeSolver(int[][] maze, int startRow, int startCol, int endRow, int endCol) { this.maze = maze; this.visited = new boolean[maze.length][maze[0].length]; this.startRow = startRow; this.startCol = startCol; this.endRow = endRow; this.endCol = endCol; } public boolean solve() { return solve(startRow, startCol); } private boolean solve(int row, int col) { if (row < 0 || row >= maze.length || col < 0 || col >= maze[0].length || maze[row][col] == 1 || visited[row][col]) { return false; } visited[row][col] = true; if (row == endRow && col == endCol) { return true; } if (solve(row - 1, col) || solve(row + 1, col) || solve(row, col - 1) || solve(row, col + 1)) { return true; } return false; } } ``` 这个代码使用递归算法来解决迷宫问题。它接受一个迷宫数组，起点和终点的行列坐标作为参数，并返回一个布尔值，表示是否找到了一条通路。如果找到了通路，那么visited数组将记录所有已经访问过的位置。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值