java迷宫

package 迷宫;

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

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
/**
*
* @author Wang Jianxin
*
*/
public class MainUI extends JFrame {

public static int[][] array = new int[DealTool.Rows][DealTool.Columns]; // 创建一个矩阵
public static int[][] array_2 = new int[DealTool.Rows][DealTool.Columns];// 创建第二个数组用来存放初始数据
public int i2, j2;

// 函数重载 得到矩阵数组
public MainUI(int[][] array) {
this.array = array;
this.array_2 = array;
}

/**
* @param args
*/
public static void main(String[] args) {
DealTool dt = new DealTool();
MainUI test = new MainUI(dt.array);
test.printarray();
test.FindStart();// 找到迷宫入口坐标

test.FindPath();    //开始查找路径
// System.out.println("找到所有点>>>>>>>>>>>>>>>>>>"
// + DealTool.PointList.size());

// 画出迷宫
test.DrawPanel();

}

/**
* 查找迷宫路径的方法
*/
public void FindPath() {
try {
// 得到队列最后一个的point对象
Point p_end1 = DealTool.PointList
.get(DealTool.PointList.size() - 1);
// 得到当前点在数组中的位置 用以查找 8个方向的值
int i1 = p_end1.y;
int j1 = p_end1.x;

if (DealTool.PointList.size() > 1) {   // 得到队列中倒数第二个point对象

Point p_end2 = DealTool.PointList
.get(DealTool.PointList.size() - 2);
i2 = p_end2.y;
j2 = p_end2.x;
} else {
i2 = 0;
j2 = 0;
}

/************************* 找到出口的条件 ******************************************/
if ((i1 == DealTool.Rows - 2) && (j1 == DealTool.Columns - 2)) {
return;
}

/********************* 从3点钟方向逆时针遍历查找周围8个point及其对应数组 *********************/

if (array[i1][j1 + 1] == 0) {// 向 右 方向找
Point p = new Point(j1 + 1, i1);   //将找到的通路的点对应的下表存入Point对象
DealTool.PointList.add(p);  //再将Point对象存入队列中
array[i1][j1] = 1;     //并将原来的点改为“障碍点”

System.out.println("<<<<<<<<<<<右>>>>>>>>>>>"+
DealTool.PointList.get(DealTool.PointList.size() - 1));
FindPath();
return;
}
if (array[i1 - 1][j1 + 1] == 0) { // 向 右上方向找
Point p = new Point(j1 + 1, i1 - 1);
DealTool.PointList.add(p);
array[i1][j1] = 1;

System.out
.println("<<<<<<<<<<<右上>>>>>>>>>>>"
+ DealTool.PointList.get(DealTool.PointList
.size() - 1));
FindPath();
return;

}
if (array[i1 - 1][j1] == 0) { // 向上方向找
Point p = new Point(j1, i1 - 1);
DealTool.PointList.add(p);
array[i1][j1] = 1;

System.out
.println("<<<<<<<<<<<上>>>>>>>>>>>"
+ DealTool.PointList.get(DealTool.PointList
.size() - 1));
FindPath();
return;

}
if (array[i1 - 1][j1 - 1] == 0) { // 向 左上方向找
Point p = new Point(j1 - 1, i1 - 1);
DealTool.PointList.add(p);
array[i1][j1] = 1;

System.out
.println("<<<<<<<<<<<左上>>>>>>>>>>>"
+ DealTool.PointList.get(DealTool.PointList
.size() - 1));
FindPath();
return;

}
if (array[i1][j1 - 1] == 0) { // 向左方向找

Point p = new Point(j1 - 1, i1);
DealTool.PointList.add(p);
array[i1][j1] = 1;

System.out
.println("<<<<<<<<<<<左>>>>>>>>>>>"
+ DealTool.PointList.get(DealTool.PointList
.size() - 1));
FindPath();
return;

}
if (array[i1 + 1][j1 - 1] == 0) { // 向 左下方向找
Point p = new Point(j1 - 1, i1 + 1);
DealTool.PointList.add(p);
array[i1][j1] = 1;

System.out
.println("<<<<<<<<<<<左下>>>>>>>>>>>"
+ DealTool.PointList.get(DealTool.PointList
.size() - 1));
FindPath();
return;

}
if (array[i1 + 1][j1] == 0) { // 向下方向找

Point p = new Point(j1, i1 + 1);
DealTool.PointList.add(p);
array[i1][j1] = 1;

System.out
.println("<<<<<<<<<<<下>>>>>>>>>>>"
+ DealTool.PointList.get(DealTool.PointList
.size() - 1));
FindPath();
return;
}
if (array[i1 + 1][j1 + 1] == 0) { // 向右下方向找

Point p = new Point(j1 + 1, i1 + 1);
DealTool.PointList.add(p);
array[i1][j1] = 1;

System.out
.println("<<<<<<<<<<<右下>>>>>>>>>>>"
+ DealTool.PointList.get(DealTool.PointList
.size() - 1));
FindPath();
return;
}
array[i1][j1] = 1;   //如果找不到通路点，就将该点改为“路障点”
array[i2][j2] = 0;   //并且使栈中倒数第二个点  “路长点”恢复为“通路点”  方便下一次查找
DealTool.PointList.remove(DealTool.PointList.size() - 1);   //将现在的“路障点”从栈中删除
System.out.println("删除了一个点  " + "  现在还有"
+ DealTool.PointList.size() + "个点");
FindPath();   //继续递归
return;

} catch (Exception ef) {//异常处理
JOptionPane.showMessageDialog(null, "该迷宫找不到出路了,请重新启动程序！");
ef.printStackTrace();
}

}

/**
* 找到迷宫矩阵入口
*/
private void FindStart() {
for (int i = 1; i < DealTool.Rows - 1; i++) {
for (int j = 1; j < DealTool.Columns - 1; j++) {
if (array[i][j] == 0) {
// 存储点的横纵坐标 横坐标为 j 纵坐标为 i
Point p = new Point(j, i);
DealTool.PointList.add(p);
// System.out.println(p.x+"   "+p.y);
return;
}
}
}

}

/**
* 打印矩阵
*/
public void printarray() {
// 测试矩阵
for (int i = 0; i < DealTool.Rows; i++) {
for (int j = 0; j < DealTool.Columns; j++) {
System.out.print(array[i][j] + "  ");
}
System.out.println();
}
}

/**
* 绘制迷宫图的方法
*/
public void DrawPanel() {
this.setTitle("简单迷宫1.0");
this.setSize(500, 600);
this.setLayout(new FlowLayout());

JPanel panel = new NewPanel();
panel.setLayout(null);
panel.setName("panel");
panel.setPreferredSize(new Dimension(450, 550));
panel.setBackground(Color.LIGHT_GRAY);

Graphics g = panel.getGraphics();

this.add(panel);
this.setLocationRelativeTo(null);
this.setDefaultCloseOperation(3);
this.setVisible(true);

}

/**
* 继承了JPanel的内部类，作为绘制图形的面板
*
* @author Wang Jianxin
*
*/
class NewPanel extends JPanel {
public void paint(Graphics g) {
super.paint(g);
// g.drawLine(0, 0, 50, 60);

for (int k = 0; k < DealTool.PointList.size(); k++) {
Point p = DealTool.PointList.get(k);
int i = p.y;
int j = p.x;

array_2[i][j] = 2; // 将路径标记为2
}

int xc, yc;

for (int i = 0; i < array_2.length; i++) {
for (int j = 0; j < array_2[0].length; j++) {
int x = (j + 1) * 30;
int y = (i + 1) * 30;
int size = DealTool.Chess_Size;

if (array_2[i][j] == 2) {   //画出路径
g.setColor(Color.green);
g.fillOval(x, y, size, size);
g.setColor(Color.LIGHT_GRAY);
} else if (array_2[i][j] == 0) {  //画出通路点（还不是路径点）
g.setColor(Color.WHITE);
g.drawOval(x, y, size, size);
g.setColor(Color.LIGHT_GRAY);
} else {                          //画出"障碍点"
g.setColor(Color.BLACK);
g.fillOval(x, y, size, size);
g.setColor(Color.LIGHT_GRAY);
}
}
}
g.setColor(Color.RED);    //画出起始点
g.fillOval((DealTool.PointList.get(0).x + 1) * 30,
(DealTool.PointList.get(0).y + 1) * 30,
DealTool.Chess_Size, DealTool.Chess_Size);

g.setColor(Color.BLUE);    //画出出口点
g.fillOval((DealTool.Columns - 2 + 1) * 30,
(DealTool.Rows - 2 + 1) * 30, DealTool.Chess_Size,
DealTool.Chess_Size);
}
}

}
/********************************************************/
/********************************************************/
/********************************************************/
/********************************************************/
/********************************************************/
/********************************************************/
/********************************************************/

package 迷宫;

import java.awt.Point;
import java.util.ArrayList;
import java.util.Random;

/**
* 迷宫数据处理类
*
* @author Wang Jianxin
*
*/

public class DealTool {


// 函数重载，初始化一个矩阵， 1 代表障碍 0代表通路
// 要求矩阵四周都是障碍
public DealTool() {
/***************************矩阵初始化部分**************************************/
for (int i = 0; i < DealTool.Columns; i++) { // 矩阵第一行模型全赋值为 1
array[0][i] = 1;
}
for (int i = 0; i < DealTool.Columns; i++) { // 矩阵最后一行模型全赋值为 1
array[DealTool.Rows - 1][i] = 1;
}
for (int i = 0; i < DealTool.Rows; i++) { // 矩阵第一列模型全赋值为 1
array[i][0] = 1;
}
for (int i = 0; i < DealTool.Rows; i++) { // 矩阵最后一列模型全赋值为 1
array[i][DealTool.Columns - 1] = 1;
}

for (int i = 1; i < DealTool.Rows - 1; i++) {
for (int j = 1; j < DealTool.Columns - 1; j++) {
Random rand = new Random();
int temp = rand.nextInt(2); // 产生一个0或1的随机数作为模型
array[i][j] = temp;
}
}

array[DealTool.Rows-2][DealTool.Columns-2] = 0;  //规定迷宫最右下角为出口
/************************************************************************/


}

public static ArrayList<Point> PointList = new ArrayList<Point>();

public static int Rows = 11; // 图形矩阵的行数

public static int Columns = 11; // 图形矩阵的列数

public static int Chess_Size =30;   //迷宫绘制时的图形大小

public static int[][] array = new int[DealTool.Rows][DealTool.Columns]; // 创建一个矩阵

public void testarray (){
//测试矩阵
for (int i = 0; i < DealTool.Rows; i++) {
for (int j = 0; j < DealTool.Columns; j++) {
System.out.print(array[i][j]+"  ");
}
System.out.println();
}
}

}