数据结构：图（2）

一、最小生成树

1.普利姆算法：稠密图

图的存贮结构采用邻接矩阵.此方法是按各个顶点连通的步骤进行,需要用一个顶点集合,开始为空集,以后将以连通的顶点陆续加入到集合中,全部顶点加入集合后就得到所需的最小生成树。

算法理解：

Prim

2.克鲁斯卡尔算法：稀疏图

图的存贮结构采用边集数组,且权值相等的边在数组中排列次序可以是任意的.该方法对于边相对比较多的不是很实用,浪费时间

算法理解：

Kruskal

二、最短路径

1.Dijkstra 算法

算法解决的是有向图中单个源点到其他顶点的最短路径问题。举例来说，如果图中的顶点表示城市，而边上的权重表示城市间开车行经的距离，Dijkstra 算法可以用来找到两个城市之间的最短路径。

算法理解：

Dijkstra

2.Floyd算法

是解决任意两点间的最短路径的一种算法，可以正確處理有向圖或负权的最短路径問題，同时也被用于计算有向图的传递闭包。

算法理解：

Floyd

代码示例：

///Name:Tree
///Author:JA
///Date:2015-3-11



/*
* 最短路径，迪杰斯特拉算法和弗洛伊德算法（采用邻接矩阵存储）
*
*/

#include<stdio.h>  

#define MAX_VERTEX_NUM 20  
#define INFINITE 10000  //当做无穷大  
//图的定义  
typedef struct
{
    int vertexNum;
    char vertex[MAX_VERTEX_NUM];
    int arc[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
}Graph, *PGraph;

//辅助数组中的元素定义  
typedef struct
{
    int distance;
    int path[MAX_VERTEX_NUM];
}ArrayNode;


//构造有向网  
void createdGraph(PGraph g)
{
    int i, j;
    g->vertexNum = 6;
    for (i = 0; i<g->vertexNum; i++)
        g->vertex[i] = 'A' + i;
    for (i = 0; i<g->vertexNum; i++)
    for (j = 0; j<g->vertexNum; j++)
        g->arc[i][j] = 0;
    g->arc[0][2] = 10;
    g->arc[0][4] = 30;
    g->arc[0][5] = 100;
    g->arc[1][2] = 5;
    g->arc[2][3] = 50;
    g->arc[3][5] = 10;
    g->arc[4][3] = 20;
    g->arc[4][5] = 60;
}

//迪杰斯特拉算法  
void Dijkstra(PGraph g, int from, int to)
{
    int i, j, index = -1;
    int n = 1;//记录已经求出的两个点之间的最短距离的个数  
    ArrayNode shortestPath[MAX_VERTEX_NUM];
    int flag[MAX_VERTEX_NUM] = { 0 };//标记，为1表示到这个顶点的最短距离已求出  

    //1.求from到各个顶点的直接距离，即初始化shortestPath数组  
    for (i = 0; i<g->vertexNum; i++){
        if (from == i){
            shortestPath[i].distance = 0;
            shortestPath[i].path[0] = i;
            flag[from] = 1;
        }
        else if (g->arc[from][i]>0){
            shortestPath[i].path[0] = from;
            shortestPath[i].path[1] = i;
            shortestPath[i].distance = g->arc[from][i];
        }
        else
            shortestPath[i].distance = INFINITE;
    }
    //2.每次求一个最短路径  
    while (n<g->vertexNum){
        //选择shortestPath中距离最小的，求出from到这个顶点的最短路径  
        index = -1;
        for (i = 0; i<g->vertexNum; i++){
            if (i == from)
                continue;
            if (flag[i] == 0 && index == -1 && shortestPath[i].distance != INFINITE)
                index = i;
            if (flag[i] == 0 && index != -1 && shortestPath[i].distance<shortestPath[index].distance)
                index = i;
        }
        flag[index] = 1;
        //修改到各个顶点的最短路径  
        for (i = 0; i<g->vertexNum; i++){
            if (i == from)
                continue;
            if (g->arc[index][i]>0 && g->arc[index][i] + shortestPath[index].distance<shortestPath[i].distance){
                shortestPath[i].distance = g->arc[index][i] + shortestPath[index].distance;
                //修改路径  
                j = 0;
                while (1){
                    shortestPath[i].path[j] = shortestPath[index].path[j];
                    if (shortestPath[index].path[j] == index)
                        break;
                    j++;
                }
                shortestPath[i].path[j + 1] = i;
            }
        }
        n++;
    }
    //输出from到to的最短路径及长度  
    if (shortestPath[to].distance == INFINITE){
        printf("%c到%c没有路径
", from + 'A', to + 'A');
        return;
    }
    printf("%c到%c的最短路径长度是：%d
", from + 'A', to + 'A', shortestPath[to].distance);
    printf("经过的顶点：  ");
    i = 0;
    while (1){
        printf("%-3c", shortestPath[to].path[i] + 'A');
        if (shortestPath[to].path[i] == to)
            break;
        i++;
    }
    printf("
");
}

//弗洛伊德算法  
void Floyd(PGraph g, int from, int to)
{
    int i, j, k;
    int shortestPath[MAX_VERTEX_NUM][MAX_VERTEX_NUM];//存储最短路径的数组  
    //初始化shortestPath  
    for (i = 0; i<g->vertexNum; i++)
    for (j = 0; j<g->vertexNum; j++){
        if (i == j){
            shortestPath[i][j] = 0;
            continue;
        }
        if (g->arc[i][j]>0)
            shortestPath[i][j] = g->arc[i][j];
        else
            shortestPath[i][j] = INFINITE;
    }
    //将各个顶点顺次加入，并修改最短路径  
    for (k = 0; k<g->vertexNum; k++){
        //在i，j之间加入k  
        for (i = 0; i<g->vertexNum; i++){
            for (j = 0; j<g->vertexNum; j++){
                if (shortestPath[i][k] + shortestPath[k][j]<shortestPath[i][j])
                    shortestPath[i][j] = shortestPath[i][k] + shortestPath[k][j];
            }
        }
    }
    //输出最短路径  
    if (shortestPath[from][to] == INFINITE){
        printf("%c到%c没有路径
", from + 'A', to + 'A');
        return;
    }
    printf("%c到%c的最短路径长度是：%d
", from + 'A', to + 'A', shortestPath[from][to]);
    printf("
");
}

void main()
{
    Graph graph;
    char from, to;
    createdGraph(&graph);
    printf("请输入起点终点(如AF，中间不要有空格)
");
    scanf("%c%c", &from, &to);
    printf("
迪杰斯特拉算法:
");
    Dijkstra(&graph, from - 'A', to - 'A');
    printf("
弗洛伊德算法:
");
    Floyd(&graph, from - 'A', to - 'A');
}

---

3/12/2015 2:12:53 PM