Huffman decoding in c using tree

Question

I've got to decompress a string that was encoded with a Huffman tree, but the code has variable length and not all inputs are in prefix, in which case I should print "invalid" and finish execution. The input consists of: number of different characters; characters and their codes; length of the encoded message; encoded message.

I'd ask a more specific question if I could, but I really don't know what's wrong, because I feel like everything is wrong.

A sample input would be: 6 e 11 m 101 x 100 l 011 p 010 o 00 18 111001110101001100

and it's output would be: "exemplo"

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef struct node_t
{
    struct node_t *left, *right;
    char* codigo;
    unsigned char c;
} *node;

void decode(const char *s, node t)
{
    node q = t;
    while (*s)
    {
        if (*s++ == '0') q = q->left;
        else q = q->right;

        if (q->c) putchar(q->c), q = t;
    }
    putchar('\n');
}

struct node_t *insere(struct node_t *root, char x, char* h, int a)
{
    if(!root)
    {
        root=(struct node_t*)malloc(sizeof(struct node_t));
        root->c = x;
        root->codigo=h;
        root->left = NULL;
        root->right = NULL;
        return(root);
    }
    else
    {
        if(h[a]=='0')
        {
            if(root->left!=NULL)
            {
                printf("invalid\n");
                exit(0);
             }
            root->left = insere(root->left,x, h, a+1);
        }
        else
        {
            if(h[a]=='1')
            {
                if(root->left!=NULL)
                {
                    printf("invalid\n");
                    exit(0);
                }
                root->right = insere(root->right,x, h, a+1);
            }
        }
    }
    return(root);
}

void inorder(struct node_t *root)

{
    if(root != NULL)
    {
        inorder(root->left);
        free(root);
        inorder(root->right);
    }
    return;
}

int main(void)
{
    struct node_t *root;
    root = NULL;
    int i, N, M, k;
    scanf("%d", &N);
    char item, num[2*N];
    for (i = 0; i < N; i++)
    {
        scanf("%c %s\n", &item, num);
        root= insere(root, item, num, 0);
    }
    scanf("%d\n", &M);
    char buf[M];
    for (k=0; k<M; k++)
        scanf ("%c", &buf[k]);
    decode (buf, root);
    inorder(root);
    return 0;
}

Answer 1

#include <stdio.h>
#include <stdlib.h>

typedef struct node_t {
    struct node_t *left, *right;
    char codigo;
    char ch;
} *node;

char decode_aux(const char **s, node np){
    if(!np){
        fprintf(stderr, "invalid\n");
        exit(0);
    }
    if(np->ch)
        return np->ch;
    if(**s=='\0')
        return '\0';

    if(*(*s)++ =='0')
        return decode_aux(s, np->left);
    else //if(**s=='1')
        return decode_aux(s, np->right);
}

void decode(char *out, const char *s, node root){
    const char *p = s;
    while(*out++ = decode_aux(&p, root))
        ;
}

void insere(node *np, char ch, char *code){
    if(!*np){
        *np = malloc(sizeof(**np));
        (*np)->left = (*np)->right = NULL;
        (*np)->codigo = *code;
        (*np)->ch = 0;
    }
    if(*++code == '\0')
        (*np)->ch = ch;
    else if(*code == '0')
        insere(&(*np)->left, ch, code);
    else // if(*code == '1')
        insere(&(*np)->right, ch, code);
}

void inorder(node root){
    if(root != NULL){
        inorder(root->left);
        inorder(root->right);
        free(root);
    }
    return;
}

int main(void){
    node root = calloc(1, sizeof(*root));
    int i, N, M;
    scanf("%d", &N);
    char item, num[2*N+1];
    num[0] = ' ';//dummy for root
    for (i = 0; i < N; i++){
        scanf(" %c %s", &item, num+1);
        insere(&root, item, num);
    }
    scanf("%d", &M);
    char buf[M+1], out[M];
    scanf("%s", buf);
    decode(out, buf, root);
    printf("%s\n", out);
    inorder(root);
    return 0;
}

#if 0
         root (root is special node)
      /         \
     0           1
    / \         / \
   0   1       0   1
  (o) / \     / \ (e)
     0   1   0   1
    (p) (l) (x) (m)
#endif

Answer 2

void decode_huff(node * root , string s){
 int len = s.length();
 node *my_root = root;
 for(int i = 0 ; i<len  ; i++){
      if(s[i] == '1')
           my_root=my_root->right;        
      else
           my_root = my_root->left;
      if(my_root->data){
           cout<<my_root->data;
           my_root=root;
      }
 }  
}