Java For循环冻结了我的程序

我正在尝试创建一个9 X 9的数独随机生成的网格，但我遇到了一个问题。每次我运行程序时，它总是冻结，只显示大约5行随机生成的数字。我对4x4和6x6网格没有问题，只有9x9。我不知道为什么它一直冻着。我希望有人能帮助我。这是我的密码

public class Sudoku9x9
{
    public static void main(String[] args)
    {
        Random rand = new Random();
        int[][] sudoku = new int[9][9];
        int rnum = 0;

        for(int a = 0; a < 9; a++)
        {
            for(int b = 0; b < 9; b++)
            {
                boolean checkWhile = false;
                while(checkWhile == false)
                {
                    rnum = rand.nextInt(9) + 1;
                    if(CheckRow(a, b, sudoku, rnum) && CheckCol(a, b, sudoku, rnum)))
                    {
                        sudoku[a][b] = rnum;
                        checkWhile = true;
                    }
                }

                System.out.print(rnum + " ");
            }

            System.out.println("");
        }

        for(int a = 0; a < 9; a++)
        {
            for(int b = 0; b < 9; b++)
            {
                System.out.print(sudoku[a][b] + " ");
            }

            System.out.println("");
        }
    }

    public static boolean CheckRow(int a, int b, int[][] sudoku, int rnum)
    {
        boolean check = true;
        for(int c = b; c > 0; c--)
        {
            if(sudoku[a][c - 1] == rnum)
            {
                check = false;
            }
        }

        return check;
    }

    public static boolean CheckCol(int a, int b, int[][] sudoku, int rnum)
    {
        boolean check1 = true;
        for(int c = a; c > 0; c--)
        {
            if(sudoku[c - 1][b] == rnum)
            {
                check1 = false;
            }
        }

        return check1;
    }
}

公共类Sudoku9x9
{
公共静态void main（字符串[]args）
{
Random rand=新的Random（）；
int[][]数独=新int[9][9]；
int rnum=0；
对于（int a=0；a<9；a++）
{
for（int b=0；b<9；b++）
{
布尔checkWhile=false；
while（checkWhile==false）
{
rnum=rand.nextInt（9）+1；
if（勾选行（a，b，数独，rnum）和勾选列（a，b，数独，rnum）））
{
数独[a][b]=rnum；
checkWhile=true；
}
}
系统输出打印（rnum+“”）；
}
System.out.println（“”）；
}
对于（int a=0；a<9；a++）
{
for（int b=0；b<9；b++）
{
System.out.print（数独[a][b]+“”）；
}
System.out.println（“”）；
}
}
公共静态布尔校验行（int a、int b、int[][]数独、int rnum）
{
布尔检查=真；
对于（int c=b；c>0；c--）
{
if（数独[a][c-1]==rnum）
{
检查=错误；
}
}
退货检查；
}
公共静态布尔校验列（int a、int b、int[][]数独、int rnum）
{
布尔校验1=真；
对于（int c=a；c>0；c--）
{
if（数独[c-1][b]==rnum）
{
check1=假；
}
}
返回支票1；
}
}

我可以发现一种避免不必要检查的方法，就是改变你的检查方法，一旦发现错误就返回

public static boolean CheckCol(int a, int b, int[][] sudoku, int rnum)
    {
        boolean check1 = true;
        for(int c = a; c > 0; c--)
        {
            if(sudoku[c - 1][b] == rnum)
            {
                return false;
            }
        }

        return check1;
    }

对于row也是如此

---

阅读locoyou的答案。此外，您的程序没有回溯功能，它可能会出现无法解决所需问题的情况，然后您需要回溯。你可能想检查数独的另一个重要元素是检查数字所在的3x3框。

你的循环很慢，因为当你的程序填满大部分数独时，很难生成一个合适的随机整数来填充下一个插槽，因此，

rnum

将一次又一次地生成，并生成许多重复的整数。例如，如果只有一个数字可以使checkRow和checkCol为真，则生成它的概率为1/9！更糟糕的是，你的程序将陷入无法解决的境地

所以你需要一个回溯程序，类似于八皇后问题。这是我的密码：

static int[][] sudoku = new int[9][9];

public static boolean CheckRow(int a, int b, int[][] sudoku, int rnum)
{
    boolean check = true;
    for(int c = b; c > 0; c--)
    {
        if(sudoku[a][c - 1] == rnum)
        {
            return false;
        }
    }

    return check;
}

public static boolean CheckCol(int a, int b, int[][] sudoku, int rnum)
{
    boolean check1 = true;
    for(int c = a; c > 0; c--)
    {
        if(sudoku[c - 1][b] == rnum)
        {
            return false;
        }
    }

    return check1;
}

public static boolean fill(int a, int b) {
    Random rand = new Random();
    int rnum = rand.nextInt(9) + 1;
    boolean checkWhile = false;
    for(int i = 0; i < 9 && !checkWhile; i++) {
        if(CheckRow(a, b, sudoku, rnum) && CheckCol(a, b, sudoku, rnum))
        {
            sudoku[a][b] = rnum;
            if(a == 8 && b == 8) return true;
            if(b == 8) checkWhile = fill(a+1,0);
            else checkWhile = fill(a,b+1);
        }
        if(rnum == 9) rnum = 1;
        else rnum += 1;

    }
    return checkWhile;
}

public static void main(String[] args) {    
    fill(0,0);
    for(int i = 0; i < 9; i++) {
        for(int j = 0; j < 9; j++) {
            System.out.print(sudoku[i][j]+" ");
        }
        System.out.println("");
    }

}

static int[][]数独=新int[9][9]；
公共静态布尔校验行（int a、int b、int[][]数独、int rnum）
{
布尔检查=真；
对于（int c=b；c>0；c--）
{
if（数独[a][c-1]==rnum）
{
返回false；
}
}
退货检查；
}
公共静态布尔校验列（int a、int b、int[][]数独、int rnum）
{
布尔校验1=真；
对于（int c=a；c>0；c--）
{
if（数独[c-1][b]==rnum）
{
返回false；
}
}
返回支票1；
}
公共静态布尔填充（int a，int b）{
Random rand=新的Random（）；
int rnum=rand.nextInt（9）+1；
布尔checkWhile=false；
对于（int i=0；i<9&！checkWhile；i++）{
if（勾选行（a，b，数独，rnum）和勾选列（a，b，数独，rnum））
{
数独[a][b]=rnum；
如果（a==8&&b==8）返回true；
如果（b==8）checkWhile=fill（a+1,0）；
else checkWhile=填充（a、b+1）；
}
如果（rnum==9）rnum=1；
否则rnum+=1；
}
返回checkWhile；
}
公共静态void main（字符串[]args）{
填充（0,0）；
对于（int i=0；i<9；i++）{
对于（int j=0；j<9；j++）{
System.out.print（数独[i][j]+“”）；
}
System.out.println（“”）；
}
}

调试并检查导致延迟的行。调用方法

CheckCol

返回的

布尔值是什么？Sai Gowthami：好的，我会试试。战术建议：永远不要将布尔表达式与
true
或
false
进行比较Christian:CheckRow和CheckCol方法中的布尔值用于检查如果随机生成的数字在该行/列中。如果是，则CheckRow/CheckCol将返回false，否则将返回true。然后while（checkWhile==false）循环将继续循环，并为CheckRow/CheckCol生成另一个要检查的随机数。哦，好的，我明白你的意思了。：）我试过你的代码，但有一件事我遇到了问题，
sudoku[a][b]=rnum。它不会在数组中存储
rnum
，但是如果我替换
sudoku[a][b]=rnum带有
系统输出打印（rnum+“”），它运行得很好。@quevinrai你可以看到我编辑的文章。我给出了一个回溯版本。但这需要很长时间，对于每个插槽，它将在同一时间尝试9次most@quevinrai我认为生成数独的更好方法是给出一个数独，例如1-9；2-9,1;3-9,1-2…，并生成两个随机整数，例如1和2，然后交换数独中的所有1和2。你可以生成多对数字，让数独游戏更随机。好的，我试试你的建议。：）我正在尝试你的回溯版本，我正在等待它显示输出，但它仍然不会显示。@quevinrai抱歉，我在编辑它时输入了一个错误：（你可以尝试最新的编辑，确实不会太长：）好的，谢谢你，我会记住的。：）是的，我想尝试回溯，但我对算法有点困惑，但在我解决我的程序后，我会学习回溯