Added Heuristic

Ready for release
Code documented as well

Author: Dev-eloperr

src/com/company/Main.java

@@ -8,10 +8,9 @@ public class Main {
     static protected int[][] sudoku_array = new int[9][9]; //Stores the sudoku
     static protected ArrayList<Point> points = new ArrayList<>(); //stores the EMPTY points
     static protected guiController gui = new guiController();//Initializes program, calls sudokuInitializer as well
-    public static void main(String[] args) {
 
-        //gui.setVisible(true);//sets the GUI as visible
-        System.out.println("points : "+ points);
+
+    public static void main(String[] args) {
 
         Thread t1 = new Thread(gui);
         t1.start();

src/com/company/guiController.java

@@ -113,6 +113,11 @@ private void guiInit() {
         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         setLocationRelativeTo(null);
     }
+    /*
+    \Function below clears the GUI
+    sets the array to 0
+    and textfields to null
+     */
     private void clearGUI(){
         for (int i = 0; i < 9; i++)
             for (int j = 0; j < 9; j++) {

src/com/company/solver.java

@@ -1,28 +1,115 @@
 package com.company;
 
-class solver implements Runnable{
-    //Choose a box with minimum empty values - MVP(minimum value remaining) heuristic
-    //Reduce the domain of each box by prechecking the already fixed value in the box
+import java.awt.*;
+import java.util.*;
+import java.util.List;
 
-    public void run(){
-        if(getResult())
+class solver implements Runnable{ //Implemented as a Thread to avoid freezing and maximum efficiency for GUI with heavy operation
+    //Chooses a box with MINIMUM VALUES REMAINING (It acts as a heuristic which optimizes the search for the solution
+    ArrayList<Point> sortedPoints = new ArrayList<>(); //It stores the sorted points according
+                                                // to box with least number of values unfilled
+    public void run(){              //acts as a constructor for the class, works with Thread.start function
+        setSortedPoints();          //sets sorted point
+        if(getResult())             //calls the solving function
             Main.gui.sud.printArray();
 
     }
+    /*
+    This function creates a map for all the 9 boxes
+    Sorts them, and creates a new arraylist of points which are sorted according to the boxes
+     */
+    private void setSortedPoints(){
+        HashMap<String,Integer> box_size= new HashMap<>(); //creates a map with default frequency one
+        box_size.put("00",0);
+        box_size.put("03",0);
+        box_size.put("06",0);
+
+        box_size.put("30",0);
+        box_size.put("33",0);
+        box_size.put("36",0);
+
+        box_size.put("60",0);
+        box_size.put("63",0);
+        box_size.put("66",0);
+        /*
+        Below loop, calculates the size of each of unfilled elements in each box
+         */
+        for (int i=0; i<Main.points.size(); i++) {
+                String s = Integer.toString(boxRowCol((int)Main.points.get(i).getX()));
+                s+=Integer.toString(+boxRowCol((int)Main.points.get(i).getY()));
+                //System.out.println(s);
+
+                switch (s) {
+                    case "00":box_size.put("00",box_size.get("00")+1); break;
+                    case "03":box_size.put("03",box_size.get("03")+1);break;
+                    case "06":box_size.put("06",box_size.get("06")+1);break;
+
+                    case "30":box_size.put("30",box_size.get("30")+1);break;
+                    case "33":box_size.put("33",box_size.get("33")+1);break;
+                    case "36":box_size.put("36",box_size.get("36")+1);break;
+
+                    case "60":box_size.put("60",box_size.get("60")+1);break;
+                    case "63":box_size.put("63",box_size.get("63")+1);break;
+                    case "66":box_size.put("66",box_size.get("66")+1);break;
+                }
+        }
+
+        box_size = sortByValue(box_size); //This function sorts the hash map by value
+
+        /*
+        Below loop sets the sortedpoints arraylist
+         */
+        for (String key:box_size.keySet())
+            for (int i=0; i<Main.points.size(); i++) {
+                String s = Integer.toString(boxRowCol((int) Main.points.get(i).getX()));
+                s += Integer.toString(+boxRowCol((int) Main.points.get(i).getY()));
+                if (s.equals(key)){
+                    sortedPoints.add(new Point((int)Main.points.get(i).getX(),(int)Main.points.get(i).getY()));
+                }
+
+            }
+    }
+/*
+This function is soleley used for sorting the MAP by using list and default collections fucntions
+ */
+    private static HashMap<String, Integer> sortByValue(HashMap<String , Integer> map_sorting)
+    {
+        // Create a list from elements of HashMap
+        List<Map.Entry<String, Integer> > list =
+                new LinkedList<>(map_sorting.entrySet());
+
+
+        list.sort(Comparator.comparing(Map.Entry::getValue));
+
+
+        HashMap<String, Integer> temp = new LinkedHashMap<>();
+        for (Map.Entry<String, Integer> aa : list) {
+            temp.put(aa.getKey(), aa.getValue());
+        }
+        return temp;
+    }
+    /*
+    This is the MAIN function which solves the sudoku by using sortedpoints arraylist and constraints
+     */
     private boolean getResult(){
         if (checkSolved()) {
             return true;
         }
-        int row_num = -1;
-        int col_num = -1;
-        for (int i=0; i<9; i++)
-            for (int j=0; j<9; j++){
-                if (Main.sudoku_array[i][j] == 0){
-                    row_num=i;
-                    col_num=j;
-                }
+        int row_num = -1,col_num = -1;
+        /*
+        sets col, row to get started
+         */
+        for (Point pointIndex : sortedPoints) {
+            if (Main.sudoku_array[(int) pointIndex.getX()][(int) pointIndex.getY()] == 0) {
+                row_num = (int) pointIndex.getX();
+                col_num = (int) pointIndex.getY();
+                break;
             }
+        }
 
+        /*
+        it check for constraint and refreshes GUI after every move
+         */
         for (int i=1; i<=9; i++){
             if (checkConstraint(i,row_num,col_num)){
 
@@ -47,21 +134,30 @@ private boolean getResult(){
         return false;
 
     }
+    /*
+    adds delay
+     */
     private void timer(){
         try {
-            Thread.sleep(1);
+            Thread.sleep(5); //CHANGE DELAY TIME HERE , SET minimum 5ms for noticable difference and faster result
             //Thread.sleep(10000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
+    /*
+    It checks weather the sudoku has been solved or not
+     */
     private boolean checkSolved(){
         for (int i = 0 ; i < 9 ; i++)
             for (int j = 0 ; j < 9 ; j++)
                 if (Main.sudoku_array[i][j] == 0)
                     return false;
         return true;
     }
+    /*
+    it checks constraint on rows, cols and boxes
+     */
     private boolean checkConstraint(int value, int row_num,int col_num){
         /*
         Below for loop checks for the given value in row and col specified
@@ -84,6 +180,9 @@ private boolean checkConstraint(int value, int row_num,int col_num){
         //if every constraint is satisfied
         return true;
     }
+    /*
+    Returns box number
+     */
     private int boxRowCol(int num){
         if (num==0||num==1||num==2)
             return 0;

src/com/company/sudokuInitializer.java

@@ -8,7 +8,7 @@ class sudokuInitializer {
 
     /*
     Function to check whether the input given via file or manually is valid or not
-    Thorws exception for Invalid Input
+    Throws exception for Invalid Input
      */
     boolean checkValidInput(String input) throws Exception{
         int n = Integer.parseInt(input+"");