HEAP LABI

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

typedef struct entry_s
{
    char songtitle[255], interpreter[255];
} entry_t;

typedef struct heap_s
{
     entry_t *entries;
     long size;
     long next;
} heap_t;

heap_t *create_heap(long size);
void delete_heap(heap_t *heap);
long compare(heap_t *heap, long index, char songtitle[], char interpreter[]);
long is_empty(heap_t *heap, long index);
void insert_entry(heap_t *heap, char songtitle[], char interpreter[]);
long search_entry(heap_t *heap, char songtitle[], char interpreter[]);
void print_entry(heap_t *heap, long index);
void print(heap_t *heap);
long count_entries(heap_t *heap);
long count_entries_with_songtitle(heap_t *heap, char songtitle[]);

heap_t *create_heap(long size)
{
    heap_t *new_heap=calloc(1, sizeof(heap_t));
    if(!new_heap)
    {
        fprintf(stderr, "ALLOCATE ERROR.\n");
        return 0;
    }
    new_heap->entries=calloc(size, sizeof(entry_t));
    if(!new_heap->entries)
    {
        free(new_heap);
        fprintf(stderr, "ALLOCATE ERROR.\n");
        return 0;
    }
    new_heap->size=size;
    new_heap->next=0;
    return new_heap;
} // end create_heap

void delete_heap(heap_t *heap)
{
    if(!heap)
        return;
    free(heap->entries);
    heap->entries=0;
    free(heap);
} // end delete_heap

long compare(heap_t *heap, long index, char songtitle[], char interpreter[])
{
    if(!heap)
        return 0;
    if(!strcmp(heap->entries[index].songtitle, songtitle) && !strcmp(heap->entries[index].interpreter, interpreter))
    {
        printf("COMPARE TRUE.\n");
        return 1;
    }
    else
    {
        printf("COMPARE FALSE.\n");
        return 0;
    }
} // end compare

long is_empty(heap_t *heap, long index)
{
    if(!heap)
        return 0;
    if(heap->entries[index].interpreter[0] && heap->entries[index].songtitle[0])
    {
        printf("NOT EMPTY.\n");
        return 1;
    }
    printf("EMPTY.\n");
    return 0;
} // end is_empty

void up_heap(heap_t *heap, long index)
{
    entry_t *ent=heap->entries;
    entry_t tmp=ent[index];
    while((index>=1)&&(strcmp(ent[index/2].songtitle,tmp.songtitle)<0))
    {
        ent[index]=ent[index/2];
        index=index/2;
    }
    ent[index]=tmp;
} // end up_heap

void insert_entry(heap_t *heap, char songtitle[], char interpreter[])
{
    if(!heap)
    {
        fprintf(stderr, "ALLOCATE ERROR.\n");
        return;
    }
    strcpy(heap->entries[heap->next].interpreter, interpreter);
    strcpy(heap->entries[heap->next].songtitle, songtitle);

    up_heap(heap, heap->next);
    heap->next++;
} // end insert_entry

long search_entry(heap_t *heap, char songtitle[], char interpreter[])
{
    long i;
    if(!heap)
        return 0;
    for(i=0;i<heap->size;i++)
    {
        if(!strcmp(heap->entries[i].songtitle,songtitle)&&!strcmp(heap->entries[i].interpreter,interpreter))
        {
            printf("FOUND ENTRY @ %p\n", &heap->entries[i]);
            return i;
        }
    }
    return 0;
} // end search_entry

void print_entry(heap_t *heap, long index)
{
    if(!heap)
        return;
    printf("INDEX: %ld INTERPRETER: %s SONGTITLE: %s\n", index, heap->entries[index].interpreter, heap->entries[index].songtitle);
} // end print_entry

void print(heap_t *heap)
{
    long i;
    if(!heap)
        return;
    for(i=0;i<heap->size;i++)
        print_entry(heap, i);
} // end print

long count_entries(heap_t *heap)
{
    long i, count=0;
    if(!heap)
        return 0;
    for(i=0;i<heap->size;i++)
        if(heap->entries[i].interpreter[0] && heap->entries[i].songtitle[0])
            count++;
    return count;
} // end count_entries

long count_entries_with_songtitle(heap_t *heap, char songtitle[])
{
    long i, count=0;
    if(!heap)
        return 0;
    for(i=0;i<heap->size;i++)
    {
        if(!strcmp(heap->entries[i].songtitle, songtitle))
            count++;
    }
    return count;
} // end count_entries_with_songtitle

void rename_entry(heap_t *heap, char oldtitle[], char oldinterpreter[], char newtitle[], char newinterpreter[])
{
    long i=search_entry(heap, oldtitle, oldinterpreter);
    if(!i)
        return;
    strcpy(heap->entries[i].interpreter,newinterpreter);
    strcpy(heap->entries[i].songtitle, newtitle);

    up_heap(heap,i);
} // end rename

int main()
{
    long c=0, size=0, index=0;
    char songtitle[255], interpreter[255];
    char newsongtitle[255], newinterpreter[255];
    heap_t *myheap=0;
    do
    {
        printf("1. CREATE HEAP\n2. DELETE HEAP\n3. COMPARE\n4. IS EMPTY\n5. INSERT ENTRY\n6. SEARCH ENTRY\n7. PRINT\n8. COUNT ENTRIES\n9. COUNT ENTRIES WITH INTERPRETER\n10. RENAME\n");
        scanf("%ld", &c);
        switch(c)
        {
            case 1:
                printf("SIZE: ");
                scanf("%ld", &size);
                myheap=create_heap(size);
                break;
            case 2:
                delete_heap(myheap);
                myheap=0;
                break;
            case 3:
                printf("INDEX: ");
                scanf("%ld", &index);
                printf("INTERPRETER: ");
                scanf("%s", interpreter);
                printf("SONGTITLE: ");
                scanf("%s", songtitle);
                compare(myheap, index, songtitle, interpreter);
                break;
            case 4:
                printf("INDEX: ");
                scanf("%ld", &index);
                is_empty(myheap, index);
                break;
            case 5:
                printf("INTERPRETER: ");
                scanf("%s", interpreter);
                printf("SONGTITLE: ");
                scanf("%s", songtitle);
                insert_entry(myheap, songtitle, interpreter);
                break;
            case 6:
                printf("INTERPRETER: ");
                scanf("%s", interpreter);
                printf("SONGTITLE: ");
                scanf("%s", songtitle);
                search_entry(myheap, songtitle, interpreter);
                break;
            case 7:
                print(myheap);
                break;
            case 8:
                printf("%ld ENTRIES.\n", count_entries(myheap));
                break;
            case 9:
                printf("SONGTITLE: ");
                scanf("%s", songtitle);
                printf("%ld ENTRIES WITH SONGTITLE %s\n", count_entries_with_songtitle(myheap, songtitle), songtitle);
                break;
            case 10:
                printf("INTERPRETER: ");
                scanf("%s", interpreter);
                printf("SONGTITLE: ");
                scanf("%s", songtitle);
                printf("NEW INTERPRETER: ");
                scanf("%s", newinterpreter);
                printf("NEW SONGTITLE: ");
                scanf("%s", newsongtitle);
                rename_entry(myheap, songtitle, interpreter, newsongtitle, newinterpreter);
                break;
        }
    } while(c!=0);
    return 0;
}