Riscrivo il problema allora:
i miei pc sono realizzati in questo modo:
struct job{
struct job *left;
struct job *right;
int valore;
};
struct pc{
int codice;
int priorita;
struct pc *next;
struct pc *last;
struct job *lavoro;
};
in parole povere sono liste di alberi.Quello che sto cercando di fare,è di stampare i job dei pc.Questi job sono dei valori che sono contenuti negli alberi di ogni singolo nodo della lista.Stampando i job dei pc, devo controllare che questi valori non siano contenuti nei job degli altri pc
esempio:
se il pc 1 ha come job 3 4 5 6 e il pc 2 ha come job 4 6 7 8 la stampa sarà: pc 1 3 4 5 6 il pc 2: stamperà 7 8
l'algoritmo che mi fa questo lavoro è questo:
struct job *elimina_job(struct job *radice, int x){
if(radice != NULL){//se non e vuoto l'albero
/*
if(x < radice->valore)//scendi a sinistra
radice->left = elimina_job(radice->left,x);
else if(x > radice->valore)//scendi a destra
radice->right = elimina_job(radice->right,x);
*/
radice->left=elimina_job(radice->left,x);
if(radice->valore>x)
return radice;
else if(radice->valore == x){//elemento trovato
struct job *nodo = (struct job *)malloc(sizeof(struct job));//crea un nodo d'appoggio
nodo = radice; //appoggio
if (nodo->right == NULL)//se ha solo il figlio sinistro
radice = nodo->left;
else if(nodo->left == NULL)//se ha solo il figlio destro
radice = nodo->right;
else{
nodo = stacca_min(radice->right,radice);//assegna il minimo al nodo d'appoggio
radice->valore = nodo->valore;//assegna il campo valore
}
free(nodo);//libera spazio nodo d'appoggio
}
radice->right=elimina_job(radice->right,x);
}
return radice;//ritorna la nuova radice
}
struct pc *prova(struct pc *iniziale, int x){
if (iniziale->next != NULL){//se il pc successivo esiste
if(iniziale->lavoro != NULL){//se il pc ha dei job
iniziale->lavoro = elimina_job(iniziale->lavoro, x);// elimina dall albero il job x
iniziale->next = prova(iniziale->next, x);
}
}
else
iniziale->lavoro = elimina_job(iniziale->lavoro, x);
return iniziale;
}
struct pc * elimina_generale(struct job * radice, struct pc *iniziale){
//visita inorder dell albero attuale usato per cancellare gli altri
if(radice != NULL){
elimina_generale(radice->left,iniziale);
if(iniziale->next != NULL)
iniziale->next = prova(iniziale->next ,radice->valore);//elimina negli alberi successivi
elimina_generale(radice->right, iniziale);
}
else
if(iniziale->next != NULL)//se c'è il pc successivo
iniziale->next = elimina_generale(iniziale->next->lavoro,iniziale->next);
return iniziale;
}
Ho dimenticato di scrivere che per caricare i job negli alberi,ho usato la funzione srand che genera numeri a caso,ho scritto questi valori in un file e poi li ho letti caricandoli nell'albero.ogni albero ha circa 200 job e inizialmente l'algoritmo ha 5 pc