Autor
por qué mi código no funciona como debería. Debo hacerla mediante funciones
recursivas y no puedo utilizar métodos iterativos.
Las funciones donde probablemente tenga el error son la g_MoverDiscos o g_TorreDeHanoiRecursiva.
En mi programa utilicé 3 arreglos unidimensionales para la "torres".
Uno que se llama Origen que se imprime a la izquierda, otro que se
llama intermedio que se imprime en el centro y el final se llama destino.
Dados 3 discos este debería ser el output del programa
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
2 0 0 2 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 2 0 0 2
3 0 0 3 0 1 3 2 1 3 2 0 0 2 3 1 2 3 1 0 3 0 0 3
Inicio paso 1 paso 2 paso 3 paso 4 paso 5 paso 6 paso 7
Esto es lo que me está imprimiendo
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
2 0 0 2 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 2 0 0 0 2
3 0 0 3 0 1 3 2 1 0 3 2 0 3 2 2 3 1 0 3 1 0 0 3
Inicio paso 1 paso 2 paso 3 paso 4 paso 5 paso 6 paso 7
Error1 Error2 Error3 Error4 Correcto
Mientras escribia esto note que los errores parecen de impresion.
.Cualquier ayuda es útil muchas gracias.
Aqui debajo pondre las funciones donde creo que tengo el problema
Código:
#define kMAX 30
void g_MoverDiscos(int liFilas,int liNDiscos,
int liTorreOrigen[kMAX],int liTorreDestino[kMAX])
{
int liPosOrigen =0;
int liPosDestino=liFilas-1;
//Busqueda de la posicio del menor disco en el origen
while(liTorreOrigen[liPosOrigen]==0 && liPosOrigen<liFilas-1)
{
liPosOrigen++;
}
//Busqueda de la posicion del tope de la torre destino
while(liTorreDestino[liPosDestino]!=0 && liPosDestino>0)//Menor o igual
{
liPosDestino--;
}
liTorreDestino[liPosDestino]=liTorreOrigen[liPosOrigen];//Transferencia del disco
liTorreOrigen[liPosOrigen]=0;//Al moverse el disco esta posicion se hace cero.
}
void g_TorreDeHanoiRecursivo(int liFilas, int liNDiscos,int liTorreOrigen[kMAX],
int liTorreIntermedia[kMAX],int liTorreDestino[kMAX])
{
if(liNDiscos==1)
{
g_MoverDiscos(liFilas, liNDiscos, liTorreOrigen, liTorreDestino);
system("cls");
g_ImprimirDiscos(liFilas, liTorreOrigen,
liTorreIntermedia, liTorreDestino);
}//END if
else
{
g_TorreDeHanoiRecursivo(liFilas, liNDiscos-1,liTorreOrigen,
liTorreDestino,liTorreIntermedia);
g_MoverDiscos(liFilas, liNDiscos, liTorreOrigen, liTorreDestino);
system("cls");
g_ImprimirDiscos(liFilas, liTorreOrigen,
liTorreDestino,liTorreIntermedia);
g_TorreDeHanoiRecursivo(liFilas, liNDiscos-1,liTorreIntermedia,
liTorreOrigen,liTorreDestino);
}//END else
}//END g_TorreDeHanoiRecursivo
void g_MoverDiscos(int liFilas,int liNDiscos,
int liTorreOrigen[kMAX],int liTorreDestino[kMAX])
{
int liPosOrigen =0;
int liPosDestino=liFilas-1;
//Busqueda de la posicio del menor disco en el origen
while(liTorreOrigen[liPosOrigen]==0 && liPosOrigen<liFilas-1)
{
liPosOrigen++;
}
//Busqueda de la posicion del tope de la torre destino
while(liTorreDestino[liPosDestino]!=0 && liPosDestino>0)//Menor o igual
{
liPosDestino--;
}
liTorreDestino[liPosDestino]=liTorreOrigen[liPosOrigen];//Transferencia del disco
liTorreOrigen[liPosOrigen]=0;//Al moverse el disco esta posicion se hace cero.
}
void g_TorreDeHanoiRecursivo(int liFilas, int liNDiscos,int liTorreOrigen[kMAX],
int liTorreIntermedia[kMAX],int liTorreDestino[kMAX])
{
if(liNDiscos==1)
{
g_MoverDiscos(liFilas, liNDiscos, liTorreOrigen, liTorreDestino);
system("cls");
g_ImprimirDiscos(liFilas, liTorreOrigen,
liTorreIntermedia, liTorreDestino);
}//END if
else
{
g_TorreDeHanoiRecursivo(liFilas, liNDiscos-1,liTorreOrigen,
liTorreDestino,liTorreIntermedia);
g_MoverDiscos(liFilas, liNDiscos, liTorreOrigen, liTorreDestino);
system("cls");
g_ImprimirDiscos(liFilas, liTorreOrigen,
liTorreDestino,liTorreIntermedia);
g_TorreDeHanoiRecursivo(liFilas, liNDiscos-1,liTorreIntermedia,
liTorreOrigen,liTorreDestino);
}//END else
}//END g_TorreDeHanoiRecursivo
///
/// Estas son las demás funciones de mi programa (todas estas están bien)
///
Código:
/// Esta es para leer los discos
int giLeerDiscos(void)
{
int liN;
do
{
printf("\nIndique la cantidad de discos: ");
scanf("%d",&liN);
if(liN<1||liN>kMAX_DISCOS)
{
system("cls");
printf("ERROR.OPCION NO ES VALIDA. VUELVA A INTENTAR\n\n");
}
}while(liN<1||liN>kMAX_DISCOS);
return liN;
}
//Funcion incializa los arreglos a la condicion que deben tener antes de jugar
void g_CondicionInicialHanoi(int liNDiscos,int liTorreOrigen[kMAX],
int liTorreIntermedia[kMAX],int liTorreDestino[kMAX])
{
int i;
for (i=0;i<liNDiscos;i++)
{
liTorreOrigen[i]=i+1; //Se colocan los discos desde el 1 en manera ascendente
liTorreIntermedia[i]=0; //Se hace cero
liTorreDestino[i]=0; //Se hace cero
}
}
void g_ImprimirDiscos(int liFilas,int liTorreOrigen[kMAX],
int liTorreIntermedia[kMAX],int liTorreDestino[kMAX])
{
int i;
for (i=0;i<liFilas;i++)
{
printf("%d\t",liTorreOrigen[i]);
printf("%d\t",liTorreIntermedia[i]);
printf("%d\t",liTorreDestino[i]);
printf("\n");
}
}
int main()
{
int liTorreOrigen[kMAX];
int liTorreIntermedia[kMAX];
int liTorreDestino[kMAX];
int liNDiscos;
int liFilas; // Es igual al numero inicial de discos. Define el espacio
// de juego.
liNDiscos=giLeerDiscos();
liFilas=liNDiscos;
//Condicion inicial del juego
g_CondicionInicialHanoi(liNDiscos,liTorreOrigen,
liTorreIntermedia,liTorreDestino);
//Imprimir condicion inicial del juego
system("cls");
g_ImprimirDiscos(liNDiscos,liTorreOrigen,
liTorreIntermedia,liTorreDestino);
g_TorreDeHanoiRecursivo(liFilas, liNDiscos,liTorreOrigen,
liTorreIntermedia,liTorreDestino);
printf("\n");
return 0;
}
int giLeerDiscos(void)
{
int liN;
do
{
printf("\nIndique la cantidad de discos: ");
scanf("%d",&liN);
if(liN<1||liN>kMAX_DISCOS)
{
system("cls");
printf("ERROR.OPCION NO ES VALIDA. VUELVA A INTENTAR\n\n");
}
}while(liN<1||liN>kMAX_DISCOS);
return liN;
}
//Funcion incializa los arreglos a la condicion que deben tener antes de jugar
void g_CondicionInicialHanoi(int liNDiscos,int liTorreOrigen[kMAX],
int liTorreIntermedia[kMAX],int liTorreDestino[kMAX])
{
int i;
for (i=0;i<liNDiscos;i++)
{
liTorreOrigen[i]=i+1; //Se colocan los discos desde el 1 en manera ascendente
liTorreIntermedia[i]=0; //Se hace cero
liTorreDestino[i]=0; //Se hace cero
}
}
void g_ImprimirDiscos(int liFilas,int liTorreOrigen[kMAX],
int liTorreIntermedia[kMAX],int liTorreDestino[kMAX])
{
int i;
for (i=0;i<liFilas;i++)
{
printf("%d\t",liTorreOrigen[i]);
printf("%d\t",liTorreIntermedia[i]);
printf("%d\t",liTorreDestino[i]);
printf("\n");
}
}
int main()
{
int liTorreOrigen[kMAX];
int liTorreIntermedia[kMAX];
int liTorreDestino[kMAX];
int liNDiscos;
int liFilas; // Es igual al numero inicial de discos. Define el espacio
// de juego.
liNDiscos=giLeerDiscos();
liFilas=liNDiscos;
//Condicion inicial del juego
g_CondicionInicialHanoi(liNDiscos,liTorreOrigen,
liTorreIntermedia,liTorreDestino);
//Imprimir condicion inicial del juego
system("cls");
g_ImprimirDiscos(liNDiscos,liTorreOrigen,
liTorreIntermedia,liTorreDestino);
g_TorreDeHanoiRecursivo(liFilas, liNDiscos,liTorreOrigen,
liTorreIntermedia,liTorreDestino);
printf("\n");
return 0;
}
En línea
