algoritmo maestro-detalle

[ras_chalo]

Hola a todos!,
acabo de hacer un algoritmo que ordena en forma maestro-detalle la siguiente tabla:

A || B
======
H1 DA1
H1 DA2
H1 DA3
H1 DA4
H2 DB1
H3 DC1
H3 DC2
H4 DD1


Bueno si se fijan se tiene en la columna 'A' H1 esta repetida 4 veces, y ademas, en la columna 'B' tiene distintos datos. Aquellos datos son hijos de H1. y se podria expresar asi:

H1
DA1
DA2
DA3
DA4
H2
DB1
H3
DC1
DC2
H4
DD1


el algoritmo que construi es el siguiente:
============================

i=0
j=0
familia[ i ] <-- campo[Aj]
familia[ i ] <-- campo[Bj]

i<-- 2
j<--2

DONDE ( j< n )

SI (campo[Aj] == campo[A (j+1)] )
familia[ i ] <-- campo [Bj]
i<-- i+1
j<-- j+1

SINO
familia[ i ] <-- campo[Bj]
familia[ i+1 ] <-- campo[A (j+1)]
i<-- i+1
j<-- j+1
FIN SI

==============================

Me preguntaba si me estará correcto el que acabo de hacer, o si le falta algo?

desde ya muchas gracias,
espero sus respuestas,
saludos!

[HackmanC]

Hola,

Código:

i=0
j=0
familia[ i ] <-- campo[Aj]
familia[ i ] <-- campo[Bj]

i<-- 2
j<--2

DONDE ( j< n ) 

   SI (campo[Aj] == campo[A (j+1)] )
       familia[ i ]  <-- campo [Bj]
        i<-- i+1
        j<-- j+1

   SINO
        familia[ i ] <-- campo[Bj]
        familia[ i+1 ] <-- campo[A (j+1)] 
        i<-- i+1
        j<-- j+1
   FIN SI

Un par de comentarios, nada más, en la primera línea roja se produce una instrucción NOP (posiblemente, un buen compilador de cualquier lenguaje debería de eliminarla completamente), es decir, esa instrucción no es útil porque no hace nada, inmediatamente después le asignas un valor diferente a "familia[ i ]".

La otra es que las instrucciónes "i<-- i+1" están tanto dentro del "SI" como dentro del "SINO" y son idénticas, es decir, tanto si entra al "SI" como al "SINO" siempre las ejecuta. Así que podrías sacarlas del SI y ponerlas después del SI; pero siempre dentro del "DONDE".

Si funciona o no el algoritmo es otra cosa,

Saludos,

[ras_chalo]

Iniciado por HackmanC

Hola,

Código:

i=0
j=0
familia[ i ] <-- campo[Aj]
familia[ i ] <-- campo[Bj]

i<-- 2
j<--2

DONDE ( j< n ) 

   SI (campo[Aj] == campo[A (j+1)] )
       familia[ i ]  <-- campo [Bj]
        i<-- i+1
        j<-- j+1

   SINO
        familia[ i ] <-- campo[Bj]
        familia[ i+1 ] <-- campo[A (j+1)] 
        i<-- i+1
        j<-- j+1
   FIN SI

Un par de comentarios, nada más, en la primera línea roja se produce una instrucción NOP (posiblemente, un buen compilador de cualquier lenguaje debería de eliminarla completamente), es decir, esa instrucción no es útil porque no hace nada, inmediatamente después le asignas un valor diferente a "familia[ i ]".

La otra es que las instrucciónes "i<-- i+1" están tanto dentro del "SI" como dentro del "SINO" y son idénticas, es decir, tanto si entra al "SI" como al "SINO" siempre las ejecuta. Así que podrías sacarlas del SI y ponerlas después del SI; pero siempre dentro del "DONDE".

Si funciona o no el algoritmo es otra cosa,

Saludos,

tienes razon, no me fije al pasarlo al computador, ya que lo escribi a mano alzada...

aqui lo dejo con las modificaciones,

Código seudocodigo:

i=0
j=1
familia[ i ] <-- campo[Aj]
familia[ i + 1 ] <-- campo[Bj]
 
i<-- 2
j<--2
 
DONDE ( j< n ) 
 
SI (campo[Aj] == campo[A (j+1)] )
   familia[ i ] <-- campo [Bj]
 
 
SINO
   familia[ i ] <-- campo[Bj]
   familia[ i+1 ] <-- campo[A (j+1)] 
 
FIN SI
   i<-- i+1
   j<-- j+1
FIN DONDE
 
RETORNAR (familia[])
 

que dices ahora, esta correcto??

[HackmanC]

Hola,

Código:

i=0
j=1
familia[ i ] <-- campo[Aj]
familia[ i + 1 ] <-- campo[Bj]

i<-- 2
j<--2

DONDE ( j< n ) 

SI (campo[Aj] == campo[A (j+1)] )
   familia[ i ] <-- campo [Bj]


SINO
   familia[ i ] <-- campo[Bj]
   familia[ i+1 ] <-- campo[A (j+1)] 

FIN SI
   i<-- i+1
   j<-- j+1
FIN DONDE

RETORNAR (familia[])

Un par de comentarios adicionales, la línea marcada en rojo todavía se repite tanto en el "SI" como en el "SINO", por lo tanto siempre se va a ejecutar sin importar en donde esté.

Ahora, a simple vista, creo que no funcionaria, simplemente porque el ciclo se repite 'n' veces, donde 'n' supongo que es la cantidad de datos en la lista de datos de entrada. Y las variables 'i' y 'j' se aumentan en 1 en cada ciclo.

En la lista de entrada hay 8 filas, y la salida se espera que tenga 12 filas, si el ciclo se repite 8 veces, seguramente solo van a existir 8 filas en la salida.

Saludos,