数据结构和算法总结（四）

图的应用

图论是在不同领域中分析和解决问题的手段，例如计算机网络设计、城市计划、找到最短路径和分子生物学。

 

1.最短路径问题可以通过应用Dijkstra算法来解决。

Dijkstra算法基于贪婪法。

Dijkstra算法需要设置两个数组

            FINAL用于存储已经求出最短路径的顶点

            DISTANCE[i]用于存储从从源点到顶点i的距离

Dijkstra算法的步骤如下：

1.初始化DISTANCE数组（源点到其他各顶点的直接距离）。

2.在DISTANCE数组中选择一个最小的距离，并且其对应的顶点v不在FINAL中。

3.添加v到FINAL。

 4.对于不在FINAL中的每个顶点w重复：

       a.如果从源点到v的距离加上从v到w的距离之和比之前记录的从v到w的距离要短（即(DISTANCE[v] + weight of edge(v,w)) < DISTANCE[w])，则设置DISTANCE[w]=DISTANCE[v] + weight of edge(v,w)。

5.如果FINAL没有包含所有顶点，跳转到步骤2。

       public void findShortestPath()//找图的最短路径
        {
            int[] Distance = new int[10];
            bool[] Final = new bool[10];
            string source;
            int src;

            if (n == 0)
            {
                Console.WriteLine("\n图不存在，你需要先插入一些顶点和边。");
                return;
            }

            while (true)
            {
                Console.WriteLine("\n输入起始顶点：");
                source = Console.ReadLine();
                src = getIndex(source);
                if (src == -1)
                    Console.WriteLine("\n该起始顶点不存在。");
                else
                    break;
            }

            for (int i = 0; i < n; i++)
                Distance[i] = cost[src, i];

            Final[src] = true;

            for (int i = 0; i < n; i++)
            {
                int v = 0;
                for (int j = 0; j < n; j++)
                {
                    if (Final[j] == false)
                    {
                        v = j;
                        break;
                    }
                }

                for (int j = 0; j < n; j++)
                {
                    if ((Final[j] == false) && (Distance[j] < Distance[v]))
                        v = j;
                }

                Final[v] = true;

                for (int w = 0; w < n; w++)
                {
                    if (Final[w] == false)
                    {
                        if (Distance[v] + cost[v, w] < Distance[w])
                            Distance[w] = Distance[v] + cost[v, w];
                    }
                }
            }

            Console.WriteLine("\n从顶点" + source + "到其他所有顶点的最短路径分别是： ");

            for (int j = 0; j < n; j++)
            {
                if (Distance[j] == infinity)
                    Console.WriteLine(source + "->" + vertices[j].vname + " =No path");
                else
                    Console.WriteLine(source + "->" + vertices[j].vname + " = " + Distance[j]);
            }
        }

2.最小生成树

对于一个有n个顶点的网络，可以有不同的生成树，每一棵生成树都可以构成通信网络。我们希望能够根据各条边上的权值，选择一棵总造价最小的生成树，这就是构造网络的最小(代价)生成树(Minimum-cost Spanning Tree)问题。

构造最小生成树的常用方法

   Prim算法

   Kruskal算法

方法一：Prim算法

算法思想：

1.设N=(V,T)是连通无向带权图，U是N上最小生成树中边的集合，TE是N上最小生成树中边的集合

2.初始令U={u0},(u0V), TE=

3.重复4、5两步直至U=V为止

4.在所有与U中顶点相关并且其邻接点不在U中的边中，找一条代价最小的边

5.将该边并入集合TE，同时该边的邻接点并入U

      public void findMinspantree()//采用Prime算法实现最小生成树
        {
            int[] lowcost = new int[n];//存放权值最小的值
            int i, j, k, min;
            for (i = 0; i < n; i++)
            {
                lowcost[i] = cost[2, i];//V2起始的所有边的权
            }
            Console.Write("最小生成图：" + vertices[2].vname);
            for (i = 0; i < n - 1; i++)
            {
                min = infinity;
                for (j = 0; j < n; j++)
                {
                    if ((lowcost[j] < min) && (lowcost[j] != 0))
                    {
                        min = lowcost[j];
                        k = j;
                        Console.Write(" --" + lowcost[k] + "-- " + vertices[k].vname);
                        for (j = 0; j < n; j++)
                        {
                            if (cost[k, j] < lowcost[j])
                            {
                                lowcost[j] = cost[k, j];
                            }
                        }

                    }
                }
            }
            Console.WriteLine();
        }

方法二：Kruskal算法

算法思想：

1.设连通无向带权图N=(V,TE)，令最小生成树初始状态为只有n个顶点而无边的非连通图T=(V,)；

2.重复第3步，直到边数为n-1为止；

3.在图中选取代价最小的边，若该边添加到最小生成树中不会形成回路，则将此边加入到TE中；否则，舍去此边，选取下一条代价最小的边；

 

3.拓扑排序数据

拓扑排序——把有向图中各顶点按照它们相互之间的优先关系排列成一个线性序列的过程叫拓扑排序。

拓扑排序的方法：

1.在有向图中选一个没有前驱的顶点且输出

2.从图中删除该顶点和所有以它为尾的弧

3.重复上述两步，直至全部顶点均已输出（拓扑排序成功），或者当图中不存在无前驱的顶点（图中有回路）为止。

                             

                                                 

                                                         By Crayon

数据结构与算法（一）： http://blog.csdn.net/crayon_chen/article/details/7700665

数据结构与算法（二）： http://blog.csdn.net/crayon_chen/article/details/7700675
数据结构与算法（三）： http://blog.csdn.net/crayon_chen/article/details/7700681