Insert calls with priority in a row using nested struct

Personal speech !!! All beauty?

I made another code that is showing the result and I can also dequeue and insert the values removed from this main queue into a secondary structure according to the priority. Oops, I advanced a bit. hehehe.

But when trying to show this secondary structure memory garbage is shown.

Calling the secondary function, Priority1_england (& p1, value1, value2); in priopria main (), I can print the secondary structure.

Follow the code for this new implementation.

    /****** arquivo.h ************/

    #define TAM 5
    typedef struct fila {
        int id[TAM];
        int priori[TAM];
        int nChamadas;
    }Fila;

    typedef struct prioridade1{
        int id1[TAM];
        int priori1[TAM];
        int nPriori1;
        struct prioridade1 * Fila;
    }Prioridade1;



    //***************************************

    int fila_vazia (Fila * );

    int fila_cheia (Fila * );

    void fila_inicializar (Fila * );

    void enfileirar (Fila * f, int , int );

    void desenfileirar (Fila * f );

    void fila_mostrar (Fila * f);

    //****************************************

    int Prioridade1_vazia (Prioridade1 * );

    int Prioridade1_cheia (Prioridade1 * );

    void Prioridade1_inicializar (Prioridade1 * );

    void Prioridade1_enfileirar (Prioridade1 * , int , int );

    void Prioridade1_mostrar (Prioridade1 * );

    /**** Prioridade 2 ***********/

    /**** Prioridade 3 ***********/

    /****** arquivo.c ************/

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


    int fila_vazia (Fila * f){
        return f->nChamadas <= 0;
    }

    int fila_cheia (Fila * f){
        return f->nChamadas >= TAM;
    }

    void fila_inicializar (Fila * f){
        f->nChamadas = 0;
    }

    void enfileirar (Fila * f, int id, int pr){
        if (!fila_cheia(f)){
            f->id[(f->nChamadas)] = id;
            f->priori[(f->nChamadas)++] = pr;
        }
    }

    void desenfileirar (Fila * f){
        Prioridade1 p1;
        int i;
        int aux1 = f->id[0];
        int aux2 = f->priori[0];
        switch(aux2){
            case 1:
                Prioridade1_enfileirar( &p1, aux1, aux2 );
            break;
        }
        //int i;
        for (i = 1; i < f->nChamadas; i++){
            f->id[i - 1] = f->id[i];
            f->priori[i - 1] = f->priori[i];
        }
        f->nChamadas = f->nChamadas - 1;
    }

    void fila_mostrar (Fila * f){
        int i;
        printf ("*************** Mostrar Fila ************\n");
        for (i = 0; i < f->nChamadas; i++){
            printf ("qtde: %d\t", i+1);
            printf ("id:%d\t", f->id[i]);
            printf ("priori: %d\n\n", f->priori[i]);
        }
    }

    //**************Prioridade1*******************

    int Prioridade1_vazia (Prioridade1 * p1){
        return p1->nPriori1 <= 0;
    }

    int Prioridade1_cheia (Prioridade1 * p1){
        return p1->nPriori1 >= TAM;
    }

    void Prioridade1_inicializar (Prioridade1 * p1){
        p1->nPriori1 = 0;
    }

    void Prioridade1_enfileirar (Prioridade1 * p1, int id1, int pr1){
        p1->id1[p1->nPriori1] = id1;
        p1->priori1[p1->nPriori1] = pr1;
    }

    void Prioridade1_mostrar (Prioridade1 * p1){
        int i;
        printf ("/*************Prioridade 1 *****************/\n");
        printf ("p1->nPriori1: %d\n", p1->nPriori1);
        for (i = 0; i < 5; i++){
            printf ("id1: %d\n", p1->id1[i]);
            printf ("priori1: %d\n\n", p1->priori1[i]);
        }
    }


    /****** main.c ************/

    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #include "filaPriori.h"


    int main (){

        Fila f;
        Prioridade1 p1;
        fila_inicializar(&f);
        Prioridade1_inicializar(&p1);

        int i, chamada, prioridade, tmp;

        srand( (unsigned)time(NULL) );

        for(i = 0; i < TAM; i++)
        {
            tmp = rand () % 20;
            chamada  = rand () % 20 + tmp;
            prioridade  = rand () % 3 + 1;
            tmp = prioridade;
            enfileirar(&f, chamada, prioridade);
        }

        fila_mostrar(&f);
        desenfileirar(&f);
        fila_mostrar(&f);
        //Prioridade1_enfileirar(&p1, 13, 1);
        Prioridade1_mostrar(&p1);

        return 0;
    }