[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..
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]

Originariamente inviato da _fast_

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.