数独之Java实现

最新推荐文章于 2021-03-08 09:22:09 发布
最新推荐文章于 2021-03-08 09:22:09 发布
阅读量1.2k 收藏 11
点赞数 2
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xjtuse2014/article/details/53725563
版权

整个工程代码不多，使用Java图形库

1‘核心算法模块’

package sudouku.calcuate;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.TreeSet;

import sudouku.ui.Myframe;

public class Calculate implements Runnable{
    //二维数组 boo 用于判断该格是否为空，如果已经填入了数值，就不用再填了。
    public static boolean[][] boo = new boolean[9][9];

    public static int upRow = 0;
    public static int upColumn = 0;
    //二维数据 b 将存储九宫格中的数据，
    public static int[][] b = new int[9][9]; 
    /**
     * flyBack 函数用于查找没有填入数值的空格，
     * @param judge
     * @param row
     * @param column
     */
    public static void flyBack(boolean[][] judge,int row,int column){
        int s = column * 9 + row;
        s--;
        int quotient = s / 9;
        int remainder = s % 9;
        if (judge[remainder][quotient]) {
            flyBack(judge, remainder, quotient);
        } else {
            upRow = remainder;
            upColumn = quotient;
        }
    }
    /**
     * arrayAdd 函数添加新的数值（1~9）到一行中，如果数据已经有了，跳过，没有就继续赋值。
     * @param array
     * @param tree
     */
    public static void arrayAdd(ArrayList<Integer> array,TreeSet<Integer> tree){
        for (int z = 1; z < 10; z++) {
            boolean flag3 = true;
            Iterator<Integer> it = tree.iterator();
            while (it.hasNext()) {// 10
                int b = it.next().intValue();
                if (z == b) {
                    flag3 = false;
                    break;
                }
            }
            if (flag3) {
                array.add(new Integer(z));
            }
            flag3 = true;
        }
    }

    /**
     * assume 函数将大九宫格分成9个小九宫格，主要是判断在同行同列同一个小九宫格内哪些数值已经被填充了，
     * 添加该格备选的数值，就是候选法的思想。
     * @param row
     * @param column
     * @return
     */
    public static ArrayList<Integer> assume(int row,int column){
        ArrayList<Integer> array = new ArrayList<Integer>();
        TreeSet<Integer> tree = new TreeSet<Integer>();
        if (0 <= row && row <= 2 && 0 <= column && column <= 2) {
            for (int a = 0; a < 9; a++) {
                if (a != column && b[row][a] != 0) {
                    tree.add(new Integer(b[row][a]));
                }
            }
            for (int b1 = 0; b1 < 9; b1++) {
                if (b1 != row && b[b1][column] != 0) {
                    tree.add(new Integer(b[b1][column]));
                }
            }
            for (int a2 = 0; a2 < 3; a2++) {
                for (int b4 = 0; b4 < 3; b4++) {
                    if ((!(a2 == row && b4 == column)) && b[a2][b4] != 0) {
                        tree.add(new Integer(b[a2][b4]));
                    }
                }
            }
            arrayAdd(array, tree);
        } else if (0 <= row && row <= 2 && 3 <= column && column <= 5) {
            for (int a = 0; a < 9; a++) {
                if (a != column && b[row][a] != 0) {
                    tree.add(new Integer(b[row][a]));
                }
            }
            for (int b1 = 0; b1 < 9; b1++) {
                if (b1 != row && b[b1][column] != 0) {
                    tree.add(new Integer(b[b1][column]));
                }
            }
            for (int a2 = 0; a2 < 3; a2++) {
                for (int b4 = 3; b4 < 6; b4++) {
                    if ((!(a2 == row && b4 == column)) && b[a2][b4] != 0) {
                        tree.add(new Integer(b[a2][b4]));
                    }
                }
            }
            arrayAdd(array, tree);
        } else if (0 <= row && row <= 2 && 6 <= column && column <= 8) {
            for (int a = 0; a < 9; a++) {
                if (a != column && b[row][a] != 0) {
                    tree.add(new Integer(b[row][a]));
                }
            }
            for (int b1 = 0; b1 < 9; b1++) {
                if (b1 != row && b[b1][column] != 0) {
                    tree.add(new Integer(b[b1][column]));
                }
            }
            for (int a2 = 0; a2 < 3; a2++) {
                for (int b4 = 6; b4 < 9; b4++) {
                    if ((!(a2 == row && b4 == column)) && b[a2][b4] != 0) {
                        tree.add(new Integer(b[a2][b4]));
                    }
                }
            }
            arrayAdd(array, tree);
        } else if (3 <= row && row <= 5 && 0 <= column && column <= 2) {
            for (int a = 0; a < 9; a++) {
                if (a != column && b[row][a] != 0) {
                    tree.add(new Integer(b[row][a]));
                }
            }
            for (int b1 = 0; b1 < 9; b1++) {
                if (b1 != row && b[b1][column] != 0) {
                    tree.add(new Integer(b[b1][column]));
                }
            }
            for (int a2 = 3; a2 < 6; a2++) {
                for (int b4 = 0; b4 < 3; b4++) {
                    if ((!(a2 == row && b4 == column)) && b[a2][b4] != 0) {
                        tree.add(new Integer(b[a2][b4]));
                    }
                }
            }
            arrayAdd(array, tree);
        } else if (3 <= row && row <= 5 && 3 <= column && column <= 5) {
            for (int a = 0; a < 9; a++) {
                if (a != column && b[row][a] != 0) {
                    tree.add(new Integer(b[row][a]));
                }
            }
            for (int b1 = 0; b1 < 9; b1++) {
                if (b1 != row && b[b1][column] != 0) {
                    tree.add(new Integer(b[b1][column]));
                }
            }
            for (int a2 = 3; a2 < 6; a2++) {
                for (int b4 = 3; b4 < 6; b4++) {
                    if ((!(a2 == row && b4 == column)) && b[a2][b4] != 0) {
                        tree.add(new Integer(b[a2][b4]));
                    }
                }
            }
            arrayAdd(array, tree);
        } else if (3 <= row && row <= 5 && 6 <= column && column <= 8) {
            for (int a = 0; a < 9; a++) {
                if (a != column && b[row][a] != 0) {
                    tree.add(new Integer(b[row][a]));
                }
            }
            for (int b1 = 0; b1 < 9; b1++) {
                if (b1 != row && b[b1][column] != 0) {
                    tree.add(new Integer(b[b1][column]));
                }
            }
            for (int a2 = 3; a2 < 6; a2++) {
                for (int b4 = 6; b4 < 9; b4++) {
                    if ((!(a2 == row && b4 == column)) && b[a2][b4] != 0) {
                        tree.add(new Integer(b[a2][b4]));
                    }
                }
            }
            arrayAdd(array, tree);
        } else if (6 <= row && row <= 8 && 0 <= column && column <= 2) {
            for (int a = 0; a < 9; a++) {
                if (a != column && b[row][a] != 0) {
                    tree.add(new Integer(b[row][a]));
                }
            }
            for (int b1 = 0; b1 < 9; b1++) {
                if (b1 != row && b[b1][column] != 0) {
                    tree.add(new Integer(b[b1][column]));
                }
            }
            for (int a2 = 6; a2 < 9; a2++) {
                for (int b4 = 0; b4 < 3; b4++) {
                    if ((!(a2 == row && b4 == column)) && b[a2][b4] != 0) {
                        tree.add(new Integer(b[a2][b4]));
                    }
                }
            }
            arrayAdd(array, tree);
        } else if (6 <= row && row <= 8 && 3 <= column && column <= 5) {
            for (int a = 0; a < 9; a++) {
                if (a != column && b[row][a] != 0) {
                    tree.add(new Integer(b[row][a]));
                }
            }
            for (int b1 = 0; b1 < 9; b1++) {
                if (b1 != row && b[b1][column] != 0) {
                    tree.add(new Integer(b[b1][column]));
                }
            }
            for (int a2 = 6; a2 < 9; a2++) {
                for (int b4 = 3; b4 < 6; b4++) {
                    if ((!(a2 == row && b4 == column)) && b[a2][b4] != 0) {
                        tree.add(new Integer(b[a2][b4]));
                    }
                }
            }
            arrayAdd(array, tree);
        } else if (6 <= row && row <= 8 && 6 <= column && column <= 8) {
            for (int a = 0; a < 9; a++) {
                if (a != column && b[row][a] != 0) {
                    tree.add(new Integer(b[row][a]));
                }
            }
            for (int b1 = 0; b1 < 9; b1++) {
                if (b1 != row && b[b1][column] != 0) {
                    tree.add(new Integer(b[b1][column]));
                }
            }
            for (int a2 = 6; a2 < 9; a2++) {
                for (int b4 = 6; b4 < 9; b4++) {
                    if ((!(a2 == row && b4 == column)) && b[a2][b4] != 0) {
                        tree.add(new Integer(b[a2][b4]));
                    }
                }
            }
            arrayAdd(array, tree);
        }
        return array;
    }
    /**
     * run 函数开始运行整个程序，生成最后的结果。
     */
    @Override
    public void run() {
        for (int a = 0; a < 9; a++) {
            for (int b1 = 0; b1 < 9; b1++) {
                if (b[a][b1] != 0) {
                    boo[a][b1] = true;
                } else {
                    boo[a][b1] = false;
                }
            }
        }
        boolean flag = true;
        ArrayList<Integer>[][] utilization = new ArrayList[9][9];
        int row = 0;
        int column = 0;
        while (column < 9) {
            if (flag == true) {
                row = 0;
            }
            while (row < 9) {
                if (b[row][column] == 0) {
                    if (flag) {
                        ArrayList<Integer> list = assume(row, column);
                        utilization[row][column] = list;
                    }
                    if (utilization[row][column].isEmpty()) {
                        flyBack(boo, row, column);
                        row = upRow;
                        column = upColumn;
                        b[row][column] = 0;
                        column--;
                        flag = false;
                        break;
                    } // if(list.isEmpty())
                    else {
                        b[row][column] = utilization[row][column].get(0);
                        utilization[row][column].remove(0);
                        flag = true;
                        boolean r = true;
                        for (int a1 = 0; a1 < 9; a1++) {
                            for (int b1 = 0; b1 < 9; b1++) {
                                if (r == false) {
                                    break;
                                }
                                if (b[a1][b1] == 0) {
                                    r = false;
                                }
                            }
                        }
                        if (r) {
                            for (int a1 = 0; a1 < 9; a1++) {
                                for (int b1 = 0; b1 < 9; b1++) {
                                    System.out.print("b[" + a1 + "][" + b1 + "]" + b[a1][b1] + ",");
                                    Myframe.filed[a1][b1].setText(b[a1][b1] + "");
                                }
                            }
                        }
                    }
                } // if(int[row][column]==0)
                else {
                    flag = true;
                }
                row++;
            }
            column++;
        }

    }

}

2、UI部分

package sudouku.ui;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.TreeSet;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextField;

import sudouku.calcuate.Calculate;

public class Myframe extends JFrame {
    public static Object obj = new Object();
    public final static JTextField[][] filed = new JTextField[9][9];

    public Myframe() {
        for (int a = 0; a < 9; a++) {
            for (int b = 0; b < 9; b++) {
                filed[a][b] = new JTextField();
                filed[a][b].setText("");
            }
        }
        JPanel jpan = new JPanel();
        jpan.setLayout(new GridLayout(9, 9));
        for (int a = 8; a > -1; a--) {
            for (int b = 0; b < 9; b++) {
                jpan.add(filed[b][a]);
            }
        }
        add(jpan, BorderLayout.CENTER);
        JPanel jpb = new JPanel();
        JButton button1 = new JButton("calc");
        JButton button2 = new JButton("close");
        jpb.add(button1);
        jpb.add(button2);
        button1.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent event) {
                synchronized (obj) {
                    for (int a = 0; a < 9; a++) {
                        for (int b3 = 0; b3 < 9; b3++) {
                            int pp = 0;
                            if (!(filed[a][b3].getText().trim().equals(""))) {
                                pp = Integer.parseInt(filed[a][b3].getText().trim());
                                Calculate.b[a][b3] = pp;
                            }
                        }
                    }
                }
                synchronized (obj) {
                    new Thread(new Calculate()).start();
                }
            }
        });

        button2.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent event) {
                System.exit(0);
            }
        });

        add(jpb, BorderLayout.SOUTH);
    }
}

3、程序入口

package sudouku.main;

import javax.swing.JFrame;

import sudouku.ui.Myframe;

public class Sudoku {
    public static void main(String[] args) {
        Myframe myf = new Myframe();
        myf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        myf.setTitle("sudoku");
        myf.setSize(500, 500);
        myf.setVisible(true);
    }
}

4、运行效果
题目：
数字填充
计算结果：
计算结果

简单的Java代码示例：数独游戏
Gdhjdjdvdg的博客
07-11 1341
​ 方法需要根据实际需求进行实现，以与玩家进行交互并验证移动的合法性。你可以根据自己的喜好和具体情况来设计这些方法的实现方式。此外，你还需要在构造函数中初始化数独棋盘，并根据实际需求填入具体的数独初始数字。请注意，上述代码中的 ​。
java编写数独_简单实现java数独游戏
weixin_42350940的博客
02-12 2712
本文实例为大家分享了java数独游戏的具体代码，供大家参考，具体内容如下打算把javaFx需要的组件装好以后直接用javaFx的，但似乎eclipse的版本不对，安装了也不能用...数独代码是在之前寒假受命写的，学了一个月java的成果，现在看来有些不足但毕竟是第一个程序，就直接放上来，数独终盘的实现直接用了暴力，时间复杂度有点高，懒得改了直接放代码终盘实现：import java.util.Ra...
基于java的数独游戏
05-17
该游戏可以选择不同的游戏难度， 游戏难度需在后台修改。 ShuduHelper.java是生成一个随机二维数组，里面每行每列每个九宫格都只有1-9九个数。UI文件夹是生成界面。
java 数独游戏
08-30
这是本人到目前为止做的最完善的一个程序，也是本人 的一个课程设计，希望大家给点建议。谢谢了。要注意的是，要运行本程序需要安装 JDK 6.0 以上版本。
java实现数独游戏(九宫格)
07-01
用java实现的数独游戏，无论界面还是算法，都挺不错
Java数独游戏
12-28
Java数独游戏 好玩。
python实现数独游戏 java简单实现数独游戏
01-20
使用python和java实现数独游戏，有比较才有收获哦。 1、Python版 #--coding:utf-8-- import random import itertools from copy import deepcopy def make_board(m=3): numbers = list(range(1,m**2+1)) #可能...
shudu_Java.rar_9*9数独java_java 数独_java数独_数独
09-24
在标签中，"9*9数独java java_数独 java数独 数独"进一步强调了这个项目专注于Java实现的9x9数独求解器。 压缩包内的两个文件名"**HoleManage.java**"和"**HoleTest.java**"可能是关键的类文件。"HoleManage"可能是...
java完成九宫格数独_简单实现java数独游戏
weixin_34190683的博客
03-08 1656
本文实例为大家分享了java数独游戏的具体代码，供大家参考，具体内容如下打算把javaFx需要的组件装好以后直接用javaFx的，但似乎eclipse的版本不对，安装了也不能用...数独代码是在之前寒假受命写的，学了一个月java的成果，现在看来有些不足但毕竟是第一个程序，就直接放上来，数独终盘的实现直接用了暴力，时间复杂度有点高，懒得改了直接放代码终盘实现：import java.util.Ra...
数独游戏（java版）
11-15
个人写的数独游戏的java代码。是在美国这边上课professor布置的作业。
简单实现java数独游戏
08-28
主要教大家如何简单实现java数独游戏，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Java数独游戏代码
03-06
本文档包含两个版本：网页版数独游戏；jar 包直接游戏运行
java数独小游戏
07-25
本程序是数独小游戏，java开发的，里面还有不少漏洞，欢迎大家指正，注意把题库放到D盘根目录
Java实现数独游戏源代码，包含界面
07-16
由于学生水平有限，所以只是实现了数独的功能，作为一个练习题并为考虑算法效率。
java数独游戏
qq_24624539的博客
01-02 330
数独.java
05-14 855
package innerclasses; import java.util.Stack; public class Sudo { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub // int[][] question = {
[内附完整源码和文档] 基于Java实现的数独游戏
LEMFOooO的博客
07-24 1492
一、本游戏背景介绍 相传数独源起于拉丁方阵（Latin Square）,1970年代在美国发展，改名为数字拼图（Number Place）,之后流传至日本并发扬光大，以数字智力游戏智力拼图游戏发表。在1984年一本游戏杂志《パズル通信ニコリ》正式把它命名为数独，意思是“在每一格只有一个数字”。拼图是九宫格（即3格宽×3格高）的正方形状，每一格又细分为一个九宫格。在每一个小九宫格中，分别填上1至9的数字，让整个大九宫格每一列、每一行的数字都不重复。 数独的玩法逻辑简单，数字排列方式千变万化，不少教育者认为数独
Java图形化界面数独
11-13
带有图形界面的数独游戏，支持排行榜、存读档、计时以及随即题目等功能
Java实现数独游戏界面详解
"java版数独游戏界面实现的第二部分，涉及主函数启动、主窗体类的设计，包括消息区、时间区和游戏区的布局，以及相关事件监听处理。" 在本篇关于“java版数独游戏界面实现（二）”的文章中，作者主要讲解了如何使用...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值