Allora cerco di farla breve. Sto lavorando con delle immagini .raw fatte in questo modo: ogni due byte rappresentano un pixel, il primo byte sono i bit meno significativi e il secondo sono i più significativi. Sto cercando di applicare l'algoritmo di huffman a queste immagini (bell'impresa) cosi da comprimerle senza perdere informazione. Tralasciamo gli altri dettagli cmq il mio obbiettivo è quello di creare un albero binario che contenga i valori dei bit con le liste in c. Di seguito vi aggiungo il codice.

codice:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>

struct pxl_freq{			// struct che rappresenta i nodi dell'heap delle frequenze
	int val;				// valore del pixel
	int frq;				// frequenza del pixel
	struct pxl_freq *destro;	// figlio destro	
	struct pxl_freq *sinistro;	// figlio sinistro
};


int cmp(const void *a,const void *b){
	struct pxl_freq primo = *(struct pxl_freq *)a;
	struct pxl_freq secondo = *(struct pxl_freq *)b;
	if(primo.frq==0 | secondo.frq==0) return 0;
	if (primo.frq>secondo.frq) return 1;
	if (primo.frq<secondo.frq) return -1;
	return 0;
}

struct pxl_freq extract_min(struct pxl_freq freq[], int *lenght){
	struct pxl_freq min;
	min=freq[0];
	freq[0]=freq[*lenght-1];
	freq[*lenght-1].val=-2;
	freq[*lenght-1].frq=0;
	freq[*lenght-1].sinistro=NULL;
	freq[*lenght-1].destro=NULL;
	*lenght=*lenght-1;
	if(*lenght>1)
		qsort(freq,*lenght,sizeof(struct pxl_freq),cmp);
	return min;
	
}

void scrivi_albero(FILE *compr, struct pxl_freq* freq,int bin[]){
	fprintf(stdout,"la frequenza del numero %d e' %d \n",freq->val,freq->frq);
	fprintf(compr,"la frequenza del numero %d e' %d \n",freq->val,freq->frq);
	if(freq->sinistro!=NULL){
		struct pxl_freq* sinistro = freq->sinistro;
		fprintf(stdout,"il valore del figlio sinistro %d \n",sinistro->val);
		fprintf(compr,"il valore del figlio sinistro %d \n",sinistro->val);
		fflush(compr);
		scrivi_albero(compr,sinistro,bin);
	}
	if(freq->destro!=NULL){
		struct pxl_freq* destro = freq->destro;
		fprintf(stdout,"il valore del figlio destro %d \n",destro->val);
		fprintf(compr,"il valore del figlio destro %d \n",destro->val);
		fflush(compr);
		scrivi_albero(compr,destro,bin);
	}
}

int main(int argc, char **argv)
{	
	if (argc!=3){
		printf("Usage: %s <img16bit.raw> <nameFileCompressed>\n",argv[0]);
		return 1;
	}
	char *buf1,*buf2;											// inizializzo tutte le variabili che mi serviranno
	buf1=calloc(2,1);
	buf2=calloc(1,2);
	int img16, i, j=0,size, freq[4096], temp,lenght,bin[12];
	struct pxl_freq min_freq[4096],destro, sinistro;
	unsigned int num;
	FILE *compr;
	if((img16=open(argv[1],O_RDONLY))==-1){						// apro il file che contiene l'immagine
		fprintf(stdout,"errore nell'apertuta del file %s\n",argv[1]);
		exit(EXIT_FAILURE);
	}
	else{
		if((compr=fopen(argv[2],"w"))==NULL){					// apro il file che conterra l'immagine compressa
			fprintf(stdout,"errore nell'apertuta del file %s\n",argv[2]);
			exit(EXIT_FAILURE);
		}
		else{
			for(i=0;i<4095;i++)								// inizializzo l'array che conterrà le frequenze dei vari valori
				freq[i]=0;
			while((read(img16,buf1,2))!=0){						// scorro tutti i pixel dell'immagine e ne controllo il valore
				if(j<510){									// aumentando di 1 il valore della casella dell'array 
					num=((buf1[1]<<8)|buf1[0])&4095;			// con indice il valore del pixel
					freq[num]++;								// facendo attenzione a saltare gli ultimi 2 pixel di ogni riga
				}											// perchè sono solo pixel di controllo
				j=(j++)%512;
			}
			j=0;
			for(i=0;i<4095;i++){					// con le frequenze trovate riempio un array di min_freq
				fprintf(stdout,"1");
				fflush(stdout);
				if(freq[i]!=0){
					min_freq[j].val=i;
					min_freq[j].frq=freq[i];
					min_freq[j].destro=NULL;
					min_freq[j].sinistro=NULL;
					j++;
				}
				fprintf(stdout,"1");
				fflush(stdout);
			}
			lenght=j;
			qsort(min_freq,j,sizeof(struct pxl_freq),cmp);			// ordino l'array per frequenze crescenti
			fprintf(stdout,"1");
			fflush(stdout);
			for(i=0;i<lenght-1;i++){				//creo la lista che rappresenta il codice di huffman
				struct pxl_freq *padre;
				fprintf(stdout,"%d \n",i);
				padre= (struct pxl_freq *)malloc(sizeof(struct pxl_freq));
				sinistro=extract_min(min_freq,&j);
				fprintf(compr,"%d - ho estratto come sinistro %d con frequenza %d \n",i,sinistro.val,sinistro.frq);
				destro=extract_min(min_freq,&j);
				fprintf(compr,"%d - ho estratto come destro %d con frequenza %d \n",i,destro.val,destro.frq);
				padre->sinistro=&sinistro;
				padre->destro=&destro;
				padre->frq=sinistro.frq+destro.frq;
				padre->val=-1;
				j++;
				min_freq[j-1]=*padre;
				fprintf(stdout,"2");
				fflush(stdout);
			}
			fprintf(stdout,"3");
			fflush(stdout);
			for(i=0;i<12;i++) bin[i]=-1;
			scrivi_albero(compr,&min_freq[0],bin);
		}
			
	}
}
Il mio problema è che quando vado a scorrere la lista nella funzione scrivi_albero() in pratica mi rendo conto nel figlio destro sono memorizzati sempre i soliti figlio destro e figlio sinistro. So che la descrizione è ambigua cosi vi copio una parte del file che la scrivi_albero() crea:

0 - ho estratto come sinistro 1029 con frequenza 1
0 - ho estratto come destro 4006 con frequenza 1
1 - ho estratto come sinistro 0 con frequenza 508
1 - ho estratto come destro -1 con frequenza 2
la frequenza del numero -1 e' 510
il valore del figlio sinistro 0
la frequenza del numero 0 e' 508
il valore del figlio destro -1
la frequenza del numero -1 e' 2
il valore del figlio sinistro 0
la frequenza del numero 0 e' 508
il valore del figlio destro -1
la frequenza del numero -1 e' 2
il valore del figlio sinistro 0
la frequenza del numero 0 e' 508
il valore del figlio destro -1
la frequenza del numero -1 e' 2
il valore del figlio sinistro 0
la frequenza del numero 0 e' 508
il valore del figlio destro -1
la frequenza del numero -1 e' 2
il valore del figlio sinistro 0
....
....

e via di seguito sempre uguale. Spero di essere stato abbastanza chiaro altrimenti chiedetemi informazioni ma vi prego aiutatemi prima che prenda tutto e faccia un bel falò!