通過深度優先搜索產生的迷宮的Java代碼

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;//搜索是判斷是否曾被訪問過
    private int[][] colMatrix;//保存要輸出的的'|'矩陣
    private int[][] rowMatrix;//保存要輸出的的'_'矩陣
    private Random random;//用來生成隨機數，保證迷宮的復雜程度

public maziness(int M ,int N){
    this.M=M;
    this.N=N;
    visitMatrix=new int[M*N];
    colMatrix = new int[M][N+1];
    rowMatrix = new int[M+1][N];
    init(colMatrix,M,N+1);
    init(rowMatrix,M+1,N);
    for (int i=0;i<M*N;i++)
        visitMatrix[i]=0;
    random = new Random();
}

private void init(int matrix[][],int M ,int N){
    for (int i=0;i<M;i++)
        for (int j=0;j<N;j++)
            matrix[i][j]=1;
}

//返回num周圍可用的鄰居，即沒被訪問過，也沒到達邊緣
private void availableNeigbers(ArrayList<Integer> list,int num){
    int allNeigber[]=new int[4];
    if (num%N==1){
        allNeigber[0]=num-N;
        allNeigber[1]=num+N;
        allNeigber[2]=num+1;
        allNeigber[3]=-1;
    }
    else if (num%N==0){
        allNeigber[0]=num-N;
        allNeigber[1]=num+N;
        allNeigber[2]=num-1;
        allNeigber[3]=-1;
    }
    else{
        allNeigber[0]=num-N;
        allNeigber[1]=num+N;
        allNeigber[2]=num-1;
        allNeigber[3]=num+1;
    }
    for (int i=0;i<4;i++){
        if (allNeigber[i]>0 & allNeigber[i]<=M*N)
            if (visitMatrix[allNeigber[i]-1]==0 )
                list.add(allNeigber[i]);
    }       
}

//返回隨機選出的可用鄰居
private int neigber(int num){
    ArrayList<Integer> list=new ArrayList<Integer>();
    availableNeigbers(list,num);
    if (list.isEmpty())
        return -1;
    else{
        return (Integer) list.get(random.nextInt(list.size()));
    }
}

//移除num1和num2之間的墻
private void removeWall(int num1,int num2){
    int x1=(num1+N-1)/N-1;
    int y1=(num1-1)%N;
    if (Math.abs(num1-num2)==1){
        if (num1>num2)
            colMatrix[x1][y1]=0;
        else
            colMatrix[x1][y1+1]=0;
    }
    else {
        if (num1>num2)
            rowMatrix[x1-1][y1]=0;
        else
            rowMatrix[x1][y1]=0;
    }
}

//生成迷宮
public void process(){  
    ArrayList<Integer> list=new ArrayList<Integer>();
    int curr=(M*N)/2;
    visitMatrix[curr-1]=1;
    list.add(curr);
    int tmp;
    while (!list.isEmpty()){
        tmp=neigber(curr);
        if (tmp>0){
            visitMatrix[tmp-1]=1;
            removeWall(curr,tmp);
            curr=tmp;
            list.add(curr);
        }
        else
            curr=(Integer) list.remove(list.size()-1);
    }
}

//繪制迷宮，并輸出到txt文件中
public void draw(FileOutputStream fos){
    try {
        fos.write(' ');
        fos.write(' ');
        for (int i=0;i<N-1;i++){
            fos.write(' ');
            fos.write('_');
        }

        fos.write('\r');
        for (int i=0;i<M;i++){
            int j;
            for (j=0;j<N;j++){
                if (colMatrix[i][j]==1)
                    fos.write('|');
                else
                    fos.write(' ');
                if (rowMatrix[i][j]==1)
                    fos.write('_');
                else
                    fos.write(' ');
            }
            if (i!=M-1 || j!=N){
                fos.write('|');
                fos.write('\r');
            }
        }
        fos.close();    
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
/**
 * @param args
 */
public static void main(String[] args) {
    // TODO Auto-generated method stub
    try {
        FileOutputStream fos=new FileOutputStream("F://maze.txt");
        maziness m=new maziness(30,60);
        m.process();
        m.draw(fos);

    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
        System.out.println(e);
    }

}


}
</pre>