Java Sodoku回溯算法

我已经编写了使用回溯方法从Java中的空白网格生成数独的代码。但是，我在运行程序时没有得到任何输出

 public class SodokuGenerator {

int[][] puzzle=new int[9][9];
int num_givens=0;

public static int get_random_value(int high, int low)
{
    //Returns a random value between the given maximum and minimum values(both     inclusive)
    Random r=new Random();
    return (r.nextInt(high+1-low) + low);
}

     public boolean check_column(int x, int y, int curr_value)
{
    for (int i=0;i<9;i++)
    {
        if (this.puzzle[i][y]==curr_value)
        {
            return false;
        }
    }
    return true;
}

public boolean check_row(int x, int y, int curr_value)
{
    for (int j=0;j<9;j++)
    {
        if (this.puzzle[x][j]==curr_value)
        {
            return false;
        }
    }
    return true;
}

public boolean check_block(int x, int y, int curr_value)
{
    int block_row_start=0, block_row_end=0,block_col_start=0, block_col_end=0;

    if (x==0 || x==3 || x==6)
    {
        block_row_start=x;
        block_row_end=x+3-1;
    }
    else if (x==2 || x==5 || x==8)//At the end of a block
    {
        block_row_start=x-3+1; //both bounds are inclusive
        block_row_end=x;
    }
    else if (x==1 || x==4 || x==7) //Neither multiples of 2 nor 3.
    {
        block_row_start=x-1;
        block_row_end=x+1;
    }

    if (y==0 || y==3 || y==6)
    {
        block_col_start=y;
        block_col_end=y+3-1;
    }
    else if (y==2 || y==5 || y==8)//At the end of a block
    {
        block_col_start=y-3+1; //both bounds are inclusive
        block_col_end=y;
    }
    else if (y==1 || y==4 || y==7) //Neither multiples of 2 nor 3.
    {
        block_col_start=y-1;
        block_col_end=y+1;
    }
    //Established the bounds of the block based on the current position
    //System.out.println("block_row_start="+block_row_start);
    //System.out.println("block_row_end= "+block_row_end);
    for (int i=block_row_start;i<=block_row_end;i++)
    {
        for (int j=block_col_start;j<=block_col_end;j++)
        {
            //System.out.println("i="+i);
            //System.out.println("j="+j);
            if (this.puzzle[i][j]==curr_value)
            {
                return false;
            }
        }
    }
    return true;
}



public void create_puzzle()
{
    int curr_value=0;
    int index=0;
    int[] possible_values={1,2,3,4,5,6,7,8,9};

    this.puzzle[0][0]=get_random_value(9,1);
    int x=0,y=1; //Holds the coordinates of the current position in the puzzle


    while (x<=8 && y<=8)
    {
        this.puzzle[x][y]=0;
        curr_value= get_random_value(9,1);
        if (this.check_block(x,y, curr_value) &&  this.check_row(x,y,curr_value) 
        && this.check_column(x,y,curr_value))
        {
            this.puzzle[x][y]=curr_value;
        }
        else //If there is a conflict with another element
        {
            index=-1;
            //Checks for a conflict using all possible values
            do //Using a do-while loop prevents a repeated computation
            {
                index++;
                curr_value=possible_values[index];
            }
            while (index<8 && (this.check_block(x,y, curr_value)==false || 
                    this.check_row(x,y,curr_value)==false 
                    || this.check_column(x,y,curr_value)==false));


            if (index==8)//This means that no possible solution was found
            {
                //BACKTRACKING
                if (y==0 && x!=0)
                {
                    y=8;
                    x--;
                }
                else
                {
                    y--;
                }

                continue;
            }
            else //If a possible solution was found
            {
                this.puzzle[x][y]=curr_value;
            }
        }

        //Advancing the current position coordinates to the next position
        if (y==8)
        {
            y=0;
            x++;
        }
        else
        {
            y++;
        }
        }
}

public类SodokuGenerator{
int[][]拼图=新int[9][9]；
int num_givens=0；
公共静态int get_random_值（int高，int低）
{
//返回给定的最大值和最小值之间的随机值（包括两者）
随机r=新随机（）；
回报率（r.nextInt（高+1-低）+低）；
}
公共布尔校验列（整数x、整数y、整数curr\u值）
{
对于（int i=0；iwhile）（将您的其余代码添加到问题中可能会有所帮助。特别是关于谜题。@Asher您需要多少时间才能找到解决方案并编写代码：）。只是好奇而已，什么都没有much@Dexters老实说，不会太长。调试需要更长的时间：）你说得对。不过，我真的很难想出一个合适的替代方案。
        if (index==8)//This means that no possible solution was found
        {
            //BACKTRACKING
            if (y==0 && x!=0)
            {
                y=8;
                x--;
            }
            else
            {
                y--;
            }

            continue;
        }

if (y==8) //This if statement only runs once. Y always gets subtracted back to 7 in the code above.
    {
         y=0;
        x++;
    }
    else
    {
        y++;
    }
    }