[C] albero semplice

[_fast_]

hola!
come posso costruire in C un albero di questo tipo?:

----8541
--/ -- |-- \
8542 8543 8548
-------|
------8544
----/----|----\
8545 8546 8547

In questo caso riceve 4 in input e quindi lo fa4 volte..:confused:
quando io provo a fare fork() mi agiunge un figlio per ogni figlio!

ps partito dalla radice creo 3 figlio e solo uno di questi puo' fare3 figli(non piu, non mneo..)

[wingman87]

Potresti spiegare meglio? Magari con il codice e il problema riscontrato

[_fast_]

Devo riuscire a fare un programma in C che prende in input "x"
e fa l'albero alto x.
se per esempio x è 2 sara cosi:

8541 processo padre
8542 - 8543 - 8544 processi figli

(i numeri sono i pid)

se x è 4
8541 processo padre
8542 - 8543 - 8548 processi figli di 8541
...........8544..........processo figlo di 8543
8545 - 8546 - 8547 processi figli di 8544

il problema è che se faccio i fork(), non mi aggiunge solo un figlio al processo padre ma aggiunge figli a tutte le "foglie"

spero di essermi spiegato un po meglio :)

[wingman87]

il problema è che se faccio i fork(), non mi aggiunge solo un figlio al processo padre ma aggiunge figli a tutte le "foglie"

spero di essermi spiegato un po meglio :)
Sì, un po' meglio. A sto punto il problema sarà lì dove vai a fare la fork. Se posti il codice forse posso aiutarti e se non posso aiutarti io ci sarà sicuramente qualcuno che ne è in grado :)
Comunque una cosa che non ho capito è questa: il programma prende in input x, e poi con quale criterio decide quanti processi figli lanciare per ogni singolo processo? Nel senso, se la richiesta è solo quella di avere alla fine un albero di altezza x, basta creare un figlio solo per ogni processo fino a raggiungere l'altezza desiderata, es:
8541
--|--
8542
--|--
8543
--|--
8544

[_fast_]

la richiesta è come l'immagine che ti ho allegato

mettiamo x=5
con livelli da 1 a 5
il processo del livello 1 fa3 figli
nel livello 2 ci sono 3 figli ma solo un figlio fa un'altro figlio
nel livello 3 cè solo un figlio e ne fa 3
nel livello 4 ci sono 3 figli ma solo un figlio fa un'altro figlio
...

l'immagine allegata rende un po piu l'idea :)

piu tardi posto il codice ma non ho fatto molto..
(la maggior parte sono stati tentativi accompagnati da relative arrabbiature)

[wingman87]

Sì, ora è tutto chiaro. Appena puoi posta il codice, nel frattempo provo a scrivermi una soluzione in pseudocodice (all'uni abbiamo visto solo la teoria per ora).

[_fast_]

son disperato..
devo consegnare per lunedi un mega esercizio e l'albero è solo una minima parte...

una delle tante prove è questa:
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
pid_t pid;
pid = fork();
switch (pid)
{
case -1:
printf ("No he podido crear el proceso hijo \n");
break;
case 0:
printf ("Soy el hijo, mi PID es %d y mi PPID es %d \n", getpid(), getppid());
fork();
fork();

sleep (20);
break;
default:
printf ("Soy el padre, mi PID es %d y el PID de mi hijo es %d \n", getpid(), pid);
sleep (30);
}
printf ("Final de ejecución de %d \n", getpid());
exit (0);
}

ma mi crea un albero sbilanciato (come tutte le altre prove che ho fatto)

[wingman87]

Allora, io ho scritto uno pseudocodice, ecco quello che ho scritto:
altezza=x
triplo=false
while(x>0){
triplo=!triplo
x--
pidcorrente=pid
if(triplo){
pid=fork()
if(pid==0)
break
}
pid=fork()
if(pid==0)
continue
wait(pid)
if(triplo)
fork()
break
}
Penso che la logica sia corretta. Purtroppo non ho linux al momento e quindi non posso testarlo. L'idea è questa:
all'inizio ho un processo, questo prenderà in input l'altezza dell'albero ed entrerà nel ciclo. Per questo processo triplo sarà true, quindi, dopo aver decrementato x lancerà un processo figlio A (primo ramo sinistro) che però non proseguirà il ciclo, poi lancerà un altro processo B (il ramo centrale) (*). Poi attenderà che questo abbia terminato e solo allora farà partire un altro processo C (il ramo destro), a quel punto sia C che il processo padre usciranno dal ciclo.
(*) B ripartirà dall'inizio del ciclo, stavolta triplo sarà false e x sarà di nuovo decrementata. Verrà lanciato solo il processo B2 (ramo centrale).
B2 ripartirà dall'inizio del ciclo, triplo sarà true e così via...

Spero di non aver scritto cose sbagliate e di esserti stato di aiuto. Ciao

[_fast_]

ciao,
sì, sei d'aiuto!
ho capito cosa vorresti fare ma non conosco il comando:

triplo=!triplo

cosa fa??

grazie!

[wingman87]

Si usa proprio così in C, ! è l'operatore di negazione, quindi se prima triplo era true !triplo è false. Comunque in C non c'è true e false, quindi false sarà lo zero e true 1.