prim算法

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

1   struct:   DIR_LINE    MINI_GENERATE_TREE

2    insert_line_into_queue(DIR_LINE** ppLine, int start, int end, int weight)  

   delete_line_from_queue(DIR_LINE** ppLine, DIR_LINE* pLine) 

3  get_mini_tree_from_graph(GRAPH* pGraph) 

        get_dir_line_from_graph(GRAPH* pGraph, MINI_GENERATE_TREE* pMiniTree, DIR_LINE* pDirLine)

                 delete_unvalid_line_from_list(DIR_LINE** ppHead, MINI_GENERATE_TREE* pMiniTree) 

                        check_valid_for_line(DIR_LINE* pDirLine, MINI_GENERATE_TREE* pMiniTree) 

                 sort_for_line_list(DIR_LINE** ppNode)  

                         insert_for_sort_operation(DIR_LINE** ppNode, DIR_LINE* pNode) 

        insert_line_into_queue(&pMiniTree->pLine, pDirLine.start, pDirLine.end, pDirLine.weight);

        insert_node_into_mini_tree(&pDirLine, pMiniTree)

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

前面我们讨论了图的创建、添加、删除和保存等问题。今天我们将继续讨论图的一些其他问题，比如说如何在图的环境下构建最小生成树。为什么要构建最小生成树呢？其实原理很简单。打个比方，现在某一个乡镇有n个村，那么这n个村肯定是联通的。现在我们打算在各个村之间搭建网线，实现村村通的工程。那么有什么办法可以实现村村互通，同时又使得最后的总距离最小呢？要达到这个目的，就必须在已有的图中构建最小生成树。

    生成最小生成树的方法很多，prim方法就是其中的一种。那么生成最小生成树的基本步骤是什么呢？很简单，听我慢慢道来：

    1）以某一个点开始，寻找当前该点可以访问的所有的边；

    2）在已经寻找的边中发现最小边，这个边必须有一个点还没有访问过，将还没有访问的点加入我们的集合，记录添加的边；

    3）寻找当前集合可以访问的所有边，重复2的过程，直到没有新的点可以加入；

    4）此时由所有边构成的树即为最小生成树。

   

     那么，代码应该怎么编写呢？朋友们可以自己好好思考一下。

     a）首先，我们定义基本的数据结构。

[cpp]  view plain copy

1. typedef struct _DIR_LINE  
2. {  
3.     int start;  
4.     int end;  
5.     int weight;  
6.     struct _DIR_LINE* next;  
7. }DIR_LINE;  
8.   
9. typedef struct _MINI_GENERATE_TREE  
10. {  
11.     int node_num;  
12.     int line_num;  
13.     int* pNode;  
14.     DIR_LINE* pLine;  
15. }MINI_GENERATE_TREE;  

     b）DIR_LINE的基本操作

[cpp]  view plain copy

1. STATUS insert_line_into_queue(DIR_LINE** ppLine, int start, int end, int weight)  
2. {  
3.     DIR_LINE* pLine;  
4.   
5.     if(NULL == ppLine)  
6.         return FALSE;  
7.   
8.     if(NULL == *ppLine){  
9.         *ppLine = create_new_dir_line(start, end, weight);  
10.         return TRUE;  
11.     }  
12.   
13.     pLine = create_new_dir_line(start, end, weight);  
14.     pLine->next = *ppLine;  
15.     *ppLine = pLine;  
16.     return TRUE;  
17. }  
18.   
19. STATUS delete_line_from_queue(DIR_LINE** ppLine, DIR_LINE* pLine)  
20. {  
21.     DIR_LINE* prev;  
22.   
23.     if(NULL == ppLine || NULL == *ppLine || NULL == pLine)  
24.         return FALSE;  
25.   
26.     if(pLine == *ppLine){  
27.         *ppLine = pLine->next;  
28.         goto final;  
29.     }  
30.   
31.     prev = *ppLine;  
32.     while(pLine != prev->next)  
33.         prev = prev->next;  
34.     prev->next = pLine->next;  
35.   
36. final:  
37.     free(pLine);  
38.     return TRUE;  

    C）编写最小生成树，涉及创建、挑选和添加过程

[cpp]  view plain copy

1. MINI_GENERATE_TREE* get_mini_tree_from_graph(GRAPH* pGraph)  
2. {  
3.     MINI_GENERATE_TREE* pMiniTree;  
4.     DIR_LINE pDirLine;  
5.   
6.     if(NULL == pGraph || NULL == pGraph->head)  
7.         return NULL;  
8.   
9.     pMiniTree = (MINI_GENERATE_TREE*)malloc(sizeof(MINI_GENERATE_TREE));  
10.     assert(NULL != pMiniTree);  
11.     memset(pMiniTree, 0, sizeof(MINI_GENERATE_TREE));  
12.   
13.     pMiniTree->node_num = 1;  
14.     pMiniTree->pNode = (int*)malloc(sizeof(int) * pGraph->count);  
15.     memset(pMiniTree->pNode, 0, sizeof(int) * pGraph->count);  
16.     pMiniTree->pNode[0] = pGraph->head->start;  
17.   
18.     while(1){  
19.         memset(&pDirLine, 0, sizeof(DIR_LINE));  
20.         get_dir_line_from_graph(pGraph, pMiniTree, &pDirLine);  
21.         if(pDirLine.start == 0)  
22.             break;  
23.   
24.         pMiniTree->line_num ++;  
25.         insert_line_into_queue(&pMiniTree->pLine, pDirLine.start, pDirLine.end, pDirLine.weight);  
26.         insert_node_into_mini_tree(&pDirLine, pMiniTree);  
27.     }  
28.   
29.     return pMiniTree;  
30. }  

     d） 构建挑选函数，选择最合适的边

[cpp]  view plain copy

1. void get_dir_line_from_graph(GRAPH* pGraph, MINI_GENERATE_TREE* pMiniTree, DIR_LINE* pDirLine)  
2. {  
3.     DIR_LINE* pHead;  
4.     DIR_LINE* prev;  
5.     VECTEX* pVectex;  
6.     LINE* pLine;  
7.     int index;  
8.     int start;  
9.   
10.     pHead = NULL;  
11.     for(index = 0; index < pMiniTree->node_num; index++){  
12.         start = pMiniTree->pNode[index];  
13.         pVectex = find_vectex_in_graph(pGraph->head, start);  
14.         pLine = pVectex->neighbor;  
15.   
16.         while(pLine){  
17.             insert_line_into_queue(&pHead, start, pLine->end, pLine->weight);  
18.             pLine = pLine->next;  
19.         }  
20.     }  
21.   
22.     if(NULL == pHead)  
23.         return;  
24.   
25.     delete_unvalid_line_from_list(&pHead, pMiniTree);  
26.     if(NULL == pHead)  
27.         return;  
28.   
29.     sort_for_line_list(&pHead);  
30.     memmove(pDirLine, pHead, sizeof(DIR_LINE));  
31.   
32.     while(pHead){  
33.         prev = pHead;  
34.         pHead = pHead->next;  
35.         free(prev);  
36.     }  
37.     return;  
38. }  

     e）添加节点函数，将尚不是最小生成树的点纳入到最小生成树当中去

[cpp]  view plain copy

1. void insert_node_into_mini_tree(DIR_LINE* pLine, MINI_GENERATE_TREE* pMiniTree)  
2. {  
3.     int index;  
4.   
5.     for(index = 0; index < pMiniTree->node_num; index ++){  
6.         if(pLine->start == pMiniTree->pNode[index]){  
7.             pMiniTree->pNode[pMiniTree->node_num++] = pLine->end;  
8.             return;  
9.         }  
10.     }  
11.   
12.     pMiniTree->pNode[pMiniTree->node_num++] = pLine->start;  
13.     return;  
14. }  

注意事项：

    （1）d、e是c中调用的子函数，如果大家观察一下就明白了

    （2）最小生成树是按照自顶向下的顺序编写的，虽然c中的子函数完成了，但是d中还有两个子函数没有着落

    （3）d中的函数delete_unvalid_line_from_list、sort_for_line_list会在下一篇中继续介绍

    （4）算法只要能够按照手工计算的流程编写出来，基本上问题不大，但是一些细节还是要小心注意的

前两篇博客我们讨论了prim最小生成树的算法，熟悉了基本的流程。基本上来说，我们是按照自上而下的顺序来编写代码的。首先我们搭建一个架构，然后一步一步完成其中的每一个子功能，这样最后构成一个完成prim算法计算过程。

    f）将DIR_LINE队列中不符合的数据删除，主要是双节点都已经访问过的DIR_LINE数据。

[cpp]  view plain copy

1. void delete_unvalid_line_from_list(DIR_LINE** ppHead, MINI_GENERATE_TREE* pMiniTree)  
2. {  
3.     DIR_LINE* prev;  
4.     DIR_LINE* pcur;  
5.     STATUS result;  
6.   
7.     prev = NULL;  
8.     pcur = *ppHead;  
9.     while(pcur){  
10.         if(!check_valid_for_line(pcur, pMiniTree)){  
11.             result = delete_line_from_queue(ppHead, pcur);  
12.             assert(TRUE == result);  
13.   
14.             if(NULL == prev)  
15.                 pcur = *ppHead;  
16.             else  
17.                 pcur = prev->next;  
18.   
19.             continue;  
20.         }  
21.   
22.         prev = pcur;  
23.         pcur = pcur->next;  
24.     }  
25.   
26.     return;  
27. }  

     g） 在f）函数中使用了判定DIR_LINE合法性的函数，我们需要完善一下。

[cpp]  view plain copy

1. int check_valid_for_line(DIR_LINE* pDirLine, MINI_GENERATE_TREE* pMiniTree)  
2. {  
3.     int index;  
4.     int flag_start;  
5.     int flag_end;  
6.   
7.     flag_start = 0;  
8.     flag_end = 0;  
9.   
10.     for(index = 0; index < pMiniTree->node_num; index ++){  
11.         if(pDirLine->start == pMiniTree->pNode[index]){  
12.             flag_start = 1;  
13.             break;  
14.         }  
15.     }  
16.   
17.     for(index = 0; index < pMiniTree->node_num; index ++){  
18.         if(pDirLine->end == pMiniTree->pNode[index]){  
19.             flag_end = 1;  
20.             break;  
21.         }  
22.     }  
23.   
24.     return (1 == flag_start && 1 == flag_end) ? 0 : 1;  
25. }  

     h） 最后就是对当前已经入队的DIR_LINE数据排序，其实就是 链表排序 。  

[cpp]  view plain copy

1. void insert_for_sort_operation(DIR_LINE** ppNode, DIR_LINE* pNode)    
2. {    
3.     DIR_LINE* prev;    
4.     DIR_LINE* cur;    
5.       
6.     /* 在第一个数据之前插入pNode */    
7.     if(pNode->weight < (*ppNode)->weight){    
8.         pNode->next = *ppNode;    
9.         *ppNode = pNode;    
10.         return;    
11.     }    
12.       
13.     cur = *ppNode;    
14.     while(cur){    
15.         if(pNode->weight < cur->weight)    
16.             break;    
17.           
18.         prev = cur;    
19.         cur = cur->next;    
20.     }    
21.       
22.     pNode->next = prev->next;    
23.     prev->next = pNode;    
24.     return;    
25. }   
26.   
27. void sort_for_line_list(DIR_LINE** ppNode)  
28. {  
29.     DIR_LINE* prev;  
30.     DIR_LINE* curr;  
31.       
32.     if(NULL == ppNode || NULL == *ppNode)  
33.         return;  
34.       
35.     curr = (*ppNode) ->next;  
36.     (*ppNode) ->next = NULL;  
37.       
38.     while(curr){  
39.         prev = curr;  
40.         curr = curr->next;  
41.         insert_for_sort_operation(ppNode, prev);  
42.     }  
43. }     

算法总结：

    1）算法本身还有改进的空间，比如是不是内存分配上每一次都要重建DIR_LINE队列有待商榷

    2）算法编写不是一部就位的，中间有反复更有删改，写四五次是很正常的事情

    3）编写代码的时候最好做到边修改、边测试，这样可以一方面增加代码的健壮度，一方面还能提高自己的信心

    4）如果存在可能，可以复用以前写过的、稳定的算法代码，比如说排序、查找、堆栈、二叉树之类的代码