使用递归遍历的方式生成所有的九宫格数独

程序很简单，就是从九宫格的（0,0）位置开始，从左到右从上到下对每个位置进行遍历，找到当前位置能用的所有数字，然后依次选取一个数字填充到当前位置，然后对下一个位置递归调用本函数进行遍历，最终会生成所有的数独。因为符合条件的数独比较多有6,670,903,752,021,072,936,960（约有6.67×10的21次方）个，而且采用递归效率比较低，程序运行时间是相当长的，通过运行程序得知，想穷举所有的数独完全不可能，例如我的电脑枚举10000000个数独需要1小时左右，大体估算按照当前的速度，需要67亿年才能穷举所有数独，看来是等不到程序运行完了。写程序的时候有个误区：相信大家也都遇到过，就是在使用数组作为函数参数传递的时候，java语言是采用的传引用的方式，即调用的函数和被调用的函数使用的是同一个数组，所以要想使被调用的函数使用自己的数组，要在父函数中为子函数重新创建一个数组，然后将原数组中的值复制给他。

package myAlgotithmTest;

import java.util.ArrayList;

/**
 * 列举出所有数独矩阵
 * @author chao
 *
 */
public class Sudoku {
	
	private static int count=0;
//	private static int level=0;
    private static int signal=0;
	/**
	 * 找到(x,y)位置可用的值
	 * @param x
	 * @param y
	 * @return
	 */
	public static ArrayList<Integer> findValues(int x,int y,int[][] sudoku){
		ArrayList<Integer> values=new ArrayList<Integer>();
		int X=x/3+1,Y=y/3+1;
		/*
		 * 先搜索对应方块内的所有出现值
		 */
		for(int i=(X-1)*3;i<X*3;i++){
			for(int j=(Y-1)*3;j<Y*3;j++){
				if(sudoku[i][j]==signal)
					continue;
				if(i==x&&j==y)
					continue;
				if(values.indexOf(sudoku[i][j])==-1){
					values.add(sudoku[i][j]);
				}
					
			}
		}

		/*
		 * 搜索对应的列
		 */
		for(int i=0;i<9;i++){
			if(i==x)continue;
			if(sudoku[i][y]==signal)continue;
			if(values.indexOf(sudoku[i][y])==-1){
				values.add(sudoku[i][y]);
			}
		}

		/*
		 * 搜索对应的行
		 */
		for(int j=0;j<9;j++){
			if(j==y)continue;
			if(sudoku[x][j]==signal)continue;
			if(values.indexOf(sudoku[x][j])==-1){
				values.add(sudoku[x][j]);
			}
		}

		/*
		 * 将没有出现过的数保存到返回结果中
		 */
		ArrayList<Integer> result=new ArrayList<Integer>();
		for(int i=1;i<=9;i++){
			if(values.indexOf(i)==-1){
				result.add(i);
			}
		}

		return result;
	}
	public static void showSudoku(int [][] sudoku){
		for(int i=0;i<9;i++){
			for(int j=0;j<9;j++)
				System.out.print(" "+sudoku[i][j]);
			System.out.println();
		}	
	}
	public static boolean findSudoku(int x,int y,int [][] sudoku,int level){
//		System.out.println("进行第x="+x+"||y="+y+"个位置的查找");
//		showSudoku(sudoku);

//		level++;
		ArrayList<Integer> values=findValues(x, y,sudoku);

		if(values.size()==0){
//			System.out.println("查找失败，返回上一层");
			return false;
		}
		
		for(int n=0;n<values.size();n++){

			sudoku[x][y]=values.get(n);
			
//			System.out.println("进行第x="+x+"||y="+y+"个位置的查找");
//            System.out.println("sudoku[x][y]="+sudoku[x][y]+"|||size()=="+values.size()+"|||n="+n);
//            showSudoku(sudoku);
			if(x==8&&y==8){
				System.out.println("==============================level="+level);
				showSudoku(sudoku);
				System.out.println("现在是第"+(++count)+"数独矩阵\n");
//				System.exit(0);
			}else{
			    int tx,ty;
			    if(y==8){
					ty=0;
					tx=x+1;
				}else {
					ty=y+1;	
					tx=x;
				}
			    int [][] tmpsudoku=new int [9][9];
				for(int i=0;i<9;i++)
					for(int j=0;j<9;j++)
						tmpsudoku[i][j]=sudoku[i][j];
			    findSudoku(tx,ty,tmpsudoku,level+1);
			}

			  
		}
//        System.out.println("可用数值链表查找完成，返回");
		return true;

	}
	public static void main(String [] args){
		System.out.println("+++++++++++++++++++++ 开始 +++++++++++++++++++++++");
//		int [][] sudoku={{0,1,2,0,4,0,6,7,8},
//				         {0,0,0,0,0,0,0,0,0},
//				         {0,0,5,0,0,0,0,0,0},
//				         {0,0,0,0,0,0,0,0,0},
//				         {0,0,0,0,0,0,0,0,0},
//				         {0,0,0,0,0,0,0,0,0},
//				         {0,0,0,0,0,0,0,0,0},
//				         {3,0,0,0,0,0,0,0,0},
//				         {0,0,0,0,0,0,0,0,0}};
//        System.out.println("数独数字：");
//        ArrayList<Integer> values=Sudoku.findValues(0, 0, sudoku);
//        for(int i=0;i<values.size();i++){
//        	System.out.println("数字"+values.get(i));
//        }
		long start=System.currentTimeMillis();
		int [][] sudoku=new int[9][9];
		for(int i=0;i<9;i++)
			for(int j=0;j<9;j++){
				sudoku[i][j]=0;
			}
		Sudoku.findSudoku(0, 0, sudoku,0);
		long end=System.currentTimeMillis();
		
		System.out.println("++++++++++++++++++++++结束++++++++++++++++++++++++");
		System.out.println("使用时间："+(end-start));
		
	}

}