Cuando el número es negativo está en complemento a 2 (usado en arquitecturas de PC, otras pueden usar otro tipo de representación). Para que un entero sea negativo el bit de mayor peso debe estar a 1.

Ahora, en cada iteración de tu programa generas un valor, x, que no llega a tener el bit de mayor peso a 1 hasta el final. Por esa razón C interpreta que tiene un número grande todo el rato.

Con la función htons. Es una función muy usada en la comunicación por internet ya que acomoda la representación interna, sea cual sea la de la máquina a big endian, que es el estándar de internet, y de paso, la representación que necesitas en tu archivo.

Para nodos con usa sola rama sí, pero si tienen dos esta solución no es suficiente.
Para el siguiente árbol:

Si se elimina el 3 debe quedar así:

Pero si se elimina el 5 debe quedar así:

Pon, con tus propias palabras, qué quieres conseguir.

Dice cuando x = 0.

Observa las siguientes funciones, puede que te ayude con lo que buscas.

char* purge_char(const char *buff, char c) {
    /* Genera un nuevo dato en el montón que debe ser liberado
     * con la función free.
     */
    char *retval = NULL;
    int buff_len;
    int i;
    int pos = 0;
 
    if(buff) {
        buff_len = strlen(buff);
        retval = malloc(buff_len + 1);
        if(retval) {
            for(i = 0; i < buff_len; ++i) {
                if(buff[i] != c) {
                    retval[pos] = buff[i];
                    pos++;
                }
            }
        }
        retval[i] = '\0';
    }
    /* La línea de código que viene a continuación es por si
     * prima el espacio a la velocidad. En caso contrario coméntala
     * o bórrala.
     */
    retval = realloc(retval, strlen(retval) + 1);
 
    return retval;
}

void purge_char2(char *buff, char c) {
    /* Modifica el argumento buff para no gastar memoria. Por
     * contrapartida el contenido anterior de buff queda destruido.
     * El tamaño asignado a buff sigue teniendo el tamaño origina.
     * La función no puede ser llamada usando una constante de cadena
     * o va a fallar.
     */
    int i, j;
 
    if(buff) {
        for(i = 0, j = 0; i < strlen(buff); ++i) {
            if(buff[i] != c) {
                buff[j] = buff[i];
                j++;
            }
        }
        buff[j] = '\0';
    }
}

¿Así?

¿O así?

Si estás detrás de un compilador GCC o parecido este es el makefile:

CC=gcc
 
p: main.o dato.o dato.h
	${CC} main.o dato.o dato.h -o p
dato.o: dato.c dato.h
	${CC} -c dato.c dato.h
main.o: main.c dato.h
	${CC} -c main.c dato.h

Aquí se generan dos objetos que después se enlazan: por un lado el propio del tipo de dato, aquí dato.o, y por otro el del cliente consumidor del tipo de dato, aquí main.o.
dato.o se compila a partir de dato.c, del cual el cliente no sabe nada, y dato.h. Como programador darás el objeto generado y la cabecera dato.h a tu cliente.

Tu cliente hará su propio programa incluyendo la cabecera dato.h a su código (aquí representado por main.c) y enlazando su código objeto, aquí representado por main.o, con el que tu le proporcionas.
Compilado de esta forma no puede acceder al miembro del struct ya que solo ve el dato incompleto de la cabecera. Los datos internos están ocultos en el código objeto.
Lo único que ve el cliente es la interfaz proporcionada por el archivo de cabecera.

Lo irás viendo con el tiempo pero las funciones deben ser lo más independientes posibles. Deben pasársele los datos mínimos para realizar su trabajo.
por ejemplo, está mal diseñada. Le pasas una variable control para que te la saque otra vez y dentro de la función ésta sirve solo para saber si debe repetir el ciclo. Esto es mucha dependencia y se debe reestructurar.
Le pasas por referencia la 'opcion' pero la usa dentro y no debe variarla. Has gastado tiempo y recursos realizando un trabajo que podría haber hecho la función sola. Y de nuevo has creado una dependencia que se podría haber evitado.
La interfaz de las funciones siempre debe ser lo más simple posible.

Por otra parte has escrito algo sin sentido
Supongo que es una cadena de control para mostrar el dato dificultad. El doble error que hay en ella es que querías hacer %2f, pero resulta que dificultad en un entero, no un real. Tampoco tiene sentido terminarlo en \t, a lo mejor te referirías \n. Su código debería ser

Como puedes ver la lista de errores, tanto técnicos como de lógica eran muchos y opté por reescribir el código, era más rápido que enumerarlos, de esta forma podrías comparar las dos formas de hacer y que sacaras tus conclusiones al ver las diferencias entre uno y otro.

Como digo esto se trata de C y no de C++.

Es posible emular, en C, el comportamiento de miembros privados de datos definidos por el programador, al estilo de la POO, para que los usuarios de esa estructura no puedan acceder directamente a los datos que hay dentro de ella.

Las ventajas que tiene esta técnica:
1. El usuario no puede modificar los datos directamente y deben pasar por los filtros que imponga el programador.
2. El programador puede cambiar los datos internos que tiene la estructura y su interfaz (funciones getters y setters) sin que el usuario tenga que recompilar todo su código para hacer uso de estas modificaciones.

Los inconvenientes:
1. Sólo se puede situar la estructura en memoria del montón con lo que aparece el problema de la fragmentación de la memoria
2. La memoria se debe liberar ya sea mediante free o una función que proporcione el programador a modo de destructor.

Aquí va el código:


dato.h

#ifndef __DATO_H__
#define __DATO_H__
 
typedef struct __dato__ DATO;
 
DATO* new_dato();
void delete_dato(DATO* objeto);
int get_dato(DATO* objeto);
void set_dato(DATO* objeto, int valor);
 
#endif

dato.c

#include <stdlib.h>
#include "dato.h"
 
struct __dato__ {
    int miembro_privado;
};
 
DATO* new_dato() {
    DATO* d = malloc(sizeof(DATO));
    d->miembro_privado = 0;
    return d;
}
 
void delete_dato(DATO* objeto) {
    free(objeto);
}
 
int get_dato(DATO* objeto) {
    return objeto->miembro_privado;
}
 
void set_dato(DATO* objeto, int valor) {
    objeto->miembro_privado = valor;
}

Ahora el cliente:

main.c

#include <stdio.h>
#include "dato.h"
 
int main() {
    DATO *d;
 
    d = new_dato();
    set_dato(d, 5);
    printf("%i\n", get_dato(d));
 
    /* d->miembro_privado = 4; /* <- Esto va a fallar */
    /* printf("%i\n", get_dato(d)); */
 
    delete_dato(d);
 
    return 0;
}