PRIM算法(2)

实现表粗糙了些，代码没有释放内存，没有使用函数。。
#define MAX_SIZE    100

struct route
{
    char dest;
    int weight;

    struct route * next;
};
struct point
{
    char src;
    int key;
    char pi;
    int in_heap;
    int index;
    struct route *edges;
};

struct point g_points[MAX_SIZE];

 

struct heap
{
    int heap_size;
    struct point *item_list[MAX_SIZE];
};

struct heap g_heap;
void min_heapify( struct heap * heap_instance, int index )
{
    while(1)
    {
        int left_index = 2 * index + 1;
        int right_index  = left_index + 1;

        int mini_value = heap_instance->item_list[index]->key;
        int mini_index = index;
        if(left_index < heap_instance->heap_size && heap_instance->item_list[left_index]->key < mini_value )
        {
            mini_value = heap_instance->item_list[left_index]->key;
            mini_index = left_index;
        }

        if(right_index < heap_instance->heap_size && heap_instance->item_list[right_index]->key < mini_value)
        {
            mini_value = heap_instance->item_list[right_index]->key;
            mini_index = right_index;
        }

        if(mini_value != heap_instance->item_list[index]->key)
        {
            heap_instance->item_list[index]->index = mini_index;
            heap_instance->item_list[mini_index]->index = index;
            struct point *tmp = heap_instance->item_list[index];
            heap_instance->item_list[index] = heap_instance->item_list[mini_index];
            heap_instance->item_list[mini_index] = tmp;
            index = mini_index;
        }
        else
        {
            break;
        }
    }
}

 

void build_min_heap(struct heap * heap_instance )
{
    int i;
    for( i = (heap_instance->heap_size - 1) / 2; i>= 0; i--)
    {
        min_heapify(heap_instance, i);
    }
}    

void extract_min(struct heap *heap_instance, struct point **min)
{
    if( heap_instance->heap_size < 1)
    {
        return;
    }

    *min = heap_instance->item_list[0];
    (*min)->in_heap = 0;
    heap_instance->item_list[0] = heap_instance->item_list[heap_instance->heap_size - 1];
    heap_instance->item_list[0]->index = 0;
    heap_instance->heap_size--;
    min_heapify(heap_instance, 0);
}

void decrease_key(struct heap *heap_instance, int index, int key)
{
    if(heap_instance->heap_size < index + 1)
    {
        return;
    }

    if( heap_instance->item_list[index]->key < key )
    {
        return;
    }

    heap_instance->item_list[index]->key = key;

    int parent_index;
    while( (parent_index = (index - 1) /2) >= 0 && heap_instance->item_list[parent_index]->key >  heap_instance->item_list[index]->key)
    {
        heap_instance->item_list[index]->index = parent_index;
        heap_instance->item_list[parent_index]->index = index;
        struct point *tmp = heap_instance->item_list[index];
        heap_instance->item_list[index] = heap_instance->item_list[parent_index];
        heap_instance->item_list[parent_index] = tmp;
        index = parent_index;
    }
}

void heap_insert(struct heap *heap_instance, struct point * it)
{
    heap_instance->heap_size++;
    heap_instance->item_list[heap_instance->heap_size-1] = it;
    int key = it->key;
    heap_instance->item_list[heap_instance->heap_size -1]->key =((unsigned int)(1 << 31) - 1);
    heap_instance->item_list[heap_instance->heap_size-1]->index = heap_instance->heap_size - 1;
    decrease_key(heap_instance, heap_instance->heap_size-1, key);
}

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

int main(void)
{
    freopen("input.txt", "r", stdin);
/*    struct heap heap_instance;
    scanf("%d", &heap_instance.heap_size);
    int i;
    for(i = 0; i < heap_instance.heap_size; i++)
    {
        scanf("%d", &heap_instance.item_list[i].key);
        heap_instance.item_list[i].id = 0;
    }

    build_min_heap(&heap_instance);

    struct item min;
    extract_min(&heap_instance, &min);

    struct item new_item;
    new_item.key = 77;
    heap_insert(&heap_instance, &new_item);    */

    int number_of_vertices;
    int number_of_edges;

    scanf("%d %d", &number_of_vertices, &number_of_edges);
    int i;
    for( i = 0; i < number_of_vertices; i++)
    {
        char id_of_point;
        scanf(" %c", &id_of_point);
        g_points[i].src = id_of_point;
        g_points[i].edges = NULL;
        g_points[i].key = (int)((unsigned int)(1 << 31) -1);
        g_points[i].pi = '\0';
        g_points[i].in_heap = 1;
        g_points[i].index = i;

        g_heap.item_list[i] = &g_points[i];
    }
    g_heap.item_list[0]->key = 0;
    g_heap.heap_size = number_of_vertices;

    for(i = 0; i < number_of_edges; i++)
    {
        char src, dest;
        int  weight;
        scanf(" %c %c %d", &src, &dest, &weight);
        struct route **iter = &(g_points[src- 'a'].edges);
        struct route *parent = NULL;
        while(*iter)
        {
            parent = *iter;
            iter = &(*iter)->next;
        }
        
        struct route *p =(struct route *)malloc(sizeof(struct route));
        *iter = p;
        p->dest = dest;
        p->weight = weight;
        p->next = NULL;
        if(parent)
        {
            parent->next = p;
        }

        iter = &(g_points[dest - 'a'].edges);
        parent = NULL;
        while(*iter)
        {
            parent = *iter;
            iter = &(*iter)->next;
        }

        p = (struct route *)malloc(sizeof(struct route));
        *iter = p;
        p->dest = src;
        p->weight = weight;
        p->next = NULL;
        if(parent)
        {
            parent->next = p;
        }
    }

    build_min_heap(&g_heap);
    while( g_heap.heap_size > 0 )
    {
        struct point* p = NULL;
        extract_min(&g_heap, &p);
        if(p->pi != '\0')
        {
            printf("%c -->%c: weight: %d\n", p->pi, p->src, p->key );
        }
        struct route *iter = g_points[p->src - 'a'].edges;
        
         while(iter)
         {
             struct point *pt = &g_points[iter->dest - 'a'];
             if(pt->in_heap && pt->key > iter->weight)
             {
                //pt.key = iter->weight;
                decrease_key(&g_heap, pt->index, iter->weight);
                pt->pi = p->src;
             }

             iter = iter->next;
         }
    }
    return 0;
}

测试输入文件　input.txt:

9 14
a b c d e f g h i
a b 4
b c 8
c d 7
d e 9
e f 10
g f 2
h g 1
a h 8
h i 7
c i 2
c f 4
d f 14
b h 11
i g 6

 

输出：

a -->b: weight: 4
a -->h: weight: 8
h -->g: weight: 1
g -->f: weight: 2
f -->c: weight: 4
c -->i: weight: 2
c -->d: weight: 7
d -->e: weight: 9