Priorityqueue-windows消息队列

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

#define N 200000

typedef struct {
    char mesg[ 20 ];
    int priority;
} Win_Message;

Win_Message * fifo[ N ];
int entry_count = 0;

void swap( int i, int j );

Win_Message * entry_alloc(  );
void enqueue( Win_Message * entry );
Win_Message * dequeue(  );

int main( void ) {
    int n;
    char str[ 20 ];
    Win_Message * tmp;

    fifo[ 0 ] = NULL;
    scanf( "%d", &n );

    while ( n-- ) {
        scanf( "%s", str );
        if ( str[ 0 ] == 'G' ) {
            tmp = dequeue(  );
            if ( !tmp ) {
                printf( "EMPTY QUEUE!\n" );
            } else {
                printf( "%s\n", tmp -> mesg );
                free( tmp );
            }
        } else {
            tmp = entry_alloc(  );
            scanf( "%s%d", tmp -> mesg, & ( tmp -> priority ) );
            enqueue( tmp );
        }
    }

    return 0;
}

Win_Message * entry_alloc(  ) {
    Win_Message * entry = ( Win_Message * ) malloc( sizeof( Win_Message ) );
    return entry;
}

void swap( int i, int j ) {
    Win_Message * tmp = fifo[ i ];
    fifo[ i ] = fifo[ j ];
    fifo[ j ] = tmp;
}

void enqueue( Win_Message * entry ) {
    fifo[ ++entry_count ] = entry;

    int i = entry_count,
        p;

    while ( true ) {
        p  = ( i >> 1 );

        if ( p > 0
             &&
             fifo[ i ] -> priority < fifo[ p ] -> priority
           ) {
            swap( i, p );
            i = p;
        }
        else
            return;
    }
}

Win_Message * dequeue(  ) {
    if ( !entry_count )
        return NULL;
    else if ( entry_count == 1 )
        return fifo[ entry_count-- ];

    Win_Message * ret = fifo[ 1 ];

    swap( 1, entry_count );
    --entry_count;

    int i = 1,
        left,
        right,
        min;

    while ( true ) {
        left = ( i << 1 );
        right = 1 + left;
        min = i;

        if ( left <= entry_count
             &&
             fifo[ left ] -> priority < fifo[ min ] -> priority
           )
            min = left;
        if ( right <= entry_count
             &&
             fifo[ right ] -> priority < fifo[ min ] -> priority
           )
            min = right;

        if ( min != i ) {
            swap( min, i );
            i = min;
        }
        else
            return ret;
    }
}