recorrido caballo

[Aleinshir]

hola estoy haciendo el recorrido del caballo en java es una clase que se encarga de crear el array terminado luego lo retorna y la interfaz que hare en jframe lo representara primero lo quise hacer con fuerza bruta pero no carga es un error logico o es por la propia caracteristica de java ya que hice uno parecido "parecido" en c y lo saca en un santiamen se nota tanto la dif entre java y c mi duda es mas sobre ello el codigo luego lo puedo optimizar este es el codigo

Código Java:

package tableroajedrez.caballo;
 
import java.util.Random;
 
/**
 *
 * @author aleinshir
 */
public class Kernel {
    
    private int Tablero[][];                                                        // Tablero de ajedre representado en una matriz
    private static int horizontal[] = new int[] {  2,  1, -1, -2, -2, -1, 1, 2 };                       // Movimientos posibles de manera horizonta
    private static int vertical[] = new int[]      { -1, -2, -2, -1,  1,  2, 2, 1 };                        // Movimientos posibles de manera vertical
    private int movimientos;                                                        // Movimientos realizados
    private boolean aux_mov;                                                        // Auxiliar de prueba
    private int prueba;                                                         // Variable para probar todos los movimientos
    private boolean auxiliar;                                                       // Auxiliar para saber si se soluciono el problema
    private int siguiente_mov;                                                      // Siguiente movimiento que hara el caballo
    private int errores;                                                            // Se asegura que el caballo no este atrapado
    private Random rand;                                                        // Numero aleatorio
    private boolean auxiliar_ex;
    private boolean auxiliar_listo;
    private int numero;
    /**
     * Inicializa el tablero y randomiza la clase "Random".
     */
    public Kernel() {
        this.Tablero = new int[8][8];
        rand = new Random(System.nanoTime());
        construir_array();
    }
    
    /**
     * 
     * Clase que inicial el kernel para determina el final del problema.
     * 
     * @param posicionH Posicion inicial vertical
     * @param posicionV Posicion inicial vertical
     * @return El tablero ya resuelto
     */
    @SuppressWarnings("empty-statement")
    public int [][] start(int posicionH, int posicionV) {
        do
            auxiliar_listo =  recorrido_completo(posicionH, posicionV);
        while (auxiliar_listo == false);
        return Tablero;
    }
    
    /**
     * 
     * @return True si esta completo el recorrido
     */
    private  boolean recorrido_completo(int posicionH, int posicionV) {
        
        auxiliar = true;
        for (movimientos = 1, errores = 0; movimientos <= 64 && auxiliar; movimientos++)    // Ciclo exterior
        {
            aux_mov = true;
            siguiente_mov = rand.nextInt(8);                                        // Determina el proximo movimiento
            for (prueba = 0; prueba < 8 && aux_mov; prueba++, siguiente_mov++, errores++)// Prueba todos los posibles movimientos
            {
                
                if (siguiente_mov == 8)                                         // Pasa al movimento 0 cuando llega al 8
                    siguiente_mov = 0;
                
                try 
                {
                    if (Tablero[posicionH + horizontal[siguiente_mov]][posicionV + vertical[siguiente_mov]] == 0)
                    {
                        Tablero[posicionH][posicionV] = movimientos;
                        
                        errores = 0;
                        aux_mov = false;
                        posicionV += vertical[siguiente_mov] ;
                        posicionH += horizontal[siguiente_mov] ;
                    }
                }
                catch(ArrayIndexOutOfBoundsException e)
                {
                    
                }
            }
            
            if (errores >= 8)                                                   // Si hay mas de 8 errores corta el recorrido
                auxiliar =false;
        }
        
        return movimientos >= 64;                                               // True si hizo los 64 movimiento
    }
    
    /**
     * 
     * Construye el array dandole 0 (no necesario en java pero es mejor inicializarlo.
     */
    private void construir_array() {
        for (int i = 0; i < 8; i++)
        {
            for (int j = 0; j < 8; j++)
            {
                Tablero[i][j] = 0;
            }
        }
    }
}
 

use un manejo de excepciones trate de hacerlo asi porque era mas "estetico"
por cierto este es el de c

Código C:

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
 
#define TAMANIOV 12                                     // Altura del tablero
#define TAMANIOH 12                                     // Anchura del tablero
 
int despliega_tablero(const int tablero[][TAMANIOV]);
int llamar(int posicionH, int posicionV, int intento);
 
int main()
{
    srand(time(NULL));
    int posicionH, posicionV;
    scanf("%d%d", &posicionH, &posicionV);
    posicionH += 2;
    posicionV += 2;
    int i, intento = 0;
    for (i = 0; i == 0;)
    {
        intento++;
        if (llamar(posicionH, posicionV, intento) == 1)
        {
            intento = 0;
        }
    }
    system("pause");
    return 0;
}
 
int llamar(int posicionH, int posicionV, int intento)
{
    int Tablero[TAMANIOH][TAMANIOV] = { 0 };
    int horizontal[8] = { 02, 01, -1, -2, -2, -1, 1, 2 };
    int vertical[8] =   { -1, -2, -2, -1, 01, 02, 2, 1 };
    int movimientos, errorlevel, almacenaH, almacenaV;
    int siguiente, fun;
    for  (movimientos = 1, errorlevel = 0; movimientos != 65;)
    {
         siguiente = rand() % 7;
         for (fun = 0; fun < 8; siguiente++, fun++)
         {
             if (siguiente == 8)
                 siguiente = 0;
             if (Tablero[posicionH + horizontal[siguiente]][posicionV + vertical[siguiente]] == 0)
             {
                 errorlevel = 0;
                 Tablero[posicionH][posicionV] = movimientos;
                 almacenaH = posicionH;
                 almacenaV = posicionV;
                 posicionH += horizontal[siguiente];
                 posicionV += vertical[siguiente];
                 if (posicionH == 0 || posicionH == 1 || posicionV == 0 || posicionV == 1)
                 {
                     Tablero[posicionH][posicionV] = 1;
                     posicionH = almacenaH;
                     posicionV = almacenaV;
                     continue;
                 }
 
                 if (posicionH == 10 || posicionH == 11 || posicionV == 10 || posicionV == 11)
                 {
                     Tablero[posicionH][posicionV] = 1;
                     posicionH = almacenaH;
                     posicionV = almacenaV;
                     continue;
                 }
                 movimientos++;
                 break;
             }
         }
        errorlevel++;
        if (errorlevel >= 8)
           break; 
 
    }
 
    if (movimientos >= 64)
    {
        system("cls");
        despliega_tablero(Tablero);
        printf("movimientos = %d\nintentos = %d\n", movimientos, intento);
        system("pause");
        return 1;
    }
    else
    {
        return 0;
    }
 
 
}
 
int despliega_tablero(const int tablero[][TAMANIOV])
{
     int columna, fila;
     for (columna = 2; columna < 10; columna++)
     {
         for(fila = 2; fila < 10; fila++)
         {
                  if( tablero[columna][fila] == 0)
                      printf("%3s", "0" );
                  if(tablero[columna][fila] != 0)
                      printf("%3d", tablero[columna][fila]);
         }
         printf("\n");
     
     }
     return 0;
}
 

//**
como ven arregle el problema usando un array mas grande (12x12) el cual daba para un margen de "error" luego pense que podia usar la posicion si esta era menor que 0 no lo ejecutaba y si era mayor que 7 igual pero como ya habia implementado aquel ah y tambien pense que quizas funcionaria aprobechandome del desplazamiento de c (eso de que un array de 8x8 i[8][0] si le quitas 2 a 0 este se transforma en i[7][6] pero no me gusto (ademas que en java no se puede) gracias de adelantado
PD: si quieren ignoran todo despues del //** ya que no tiene que ver a mi pregunta :D
PD de la PD: seguro algunos me dicen que es malo usar break por eso de la programacion estructurada etc pero cuando hice el code no lo sabia xd y me dio lala corregirlo en java si use una variable de "escape"