图的存储与遍历

- 

图的存储结构主要有邻接矩阵和邻接表存储两种存储方式

在遍历方式上有广度遍历和深度遍历

广度遍历就是按层次遍历，可以借助队列实现

深度遍历可以理解为一种递归遍历

在练习程序中选择用邻接表结构存储图，图的结构如图所示

如果邻接矩阵结构存储图的话，当图的节点较多，但边数较时浪费了存储空间。

邻接表结构的话可以先用头节点链表存储所有的图的节点，每一个头节点又是以该头节点为起始节点的边的链表的起始点。

每个链接表的节点结构为

该节点在头节点链表中的位置，和其下一节点。

我觉得做图的相关存储时的关键点：

 图的头节点链表的结构和边链表的结构

头节点中要包含该节点的值和边链表的链表指针，在C#中用类的示例来表示

示例代码为：

 

 

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Text;
  4 
  5 namespace LinkGraph
  6 {
  7     /// <summary>
  8     /// 采用邻接表方式存储图
  9     /// </summary>
 10     /// <typeparam name="T">图的节点的数据类型</typeparam>
 11  public class GraphLink<T>
 12     {
 13          /*图的节点*/
 14 
 15      public GraphLink() 
 16      {
 17          NodeList = new List<GraphLink<T>.HeadNode>();
 18          nodeCount = 0;
 19          borderCount = 0;
 20      }
 21      public class HeadNode
 22      {
 23        public  T data;
 24        public   bool isVisited;
 25        public   SubNode<HeadNode> Next;
 26      }
 27 
 28      public class SubNode<vType>
 29      {
 30          /// <summary>
 31          /// 该子节点在节点链表中的位置
 32          /// </summary>
 33        public   vType adjex;//指向头节点链表中的前一个节点
 34          /// <summary>
 35          /// 以该节点为目的节点的边的权值
 36          /// </summary>
 37        public   T weight;  //以该节点为目的节点的边的权值
 38         /// <summary>
 39         /// 子节点的下一个子节点
 40         /// </summary>
 41  
 42        public   SubNode<vType> next;
 43 
 44        public SubNode(vType value) 
 45        {
 46            adjex = value;
 47        }  
 48      }
 49      /// <summary>
 50      /// 存放图的所有节点的链表
 51      /// </summary>
 52      public List<HeadNode> NodeList;
 53      /// <summary>
 54      /// 图中节点数
 55      /// </summary>
 56      public int nodeCount;
 57      /// <summary>
 58      /// 图中边的数目
 59      /// </summary>
 60      public int borderCount;
 61      /// <summary>
 62      /// 在图中增加一个节点
 63      /// </summary>
 64      /// <param name="NewNodeValue">节点的值</param>
 65      public void AddNode(T NewNodeValue) 
 66      {
 67          if (NodeList == null) NodeList = new List<GraphLink<T>.HeadNode>();
 68          foreach (HeadNode h in NodeList) 
 69          {
 70              /*
 71               * 判断图中时有已存在的节点
 72               */
 73              if (h.data.Equals(NewNodeValue) == true) 
 74              {
 75                  Console.WriteLine("图中已经存在该节点");
 76                  return;
 77              }
 78 
 79          }
 80          HeadNode t = new GraphLink<T>.HeadNode();
 81          t.data = NewNodeValue;
 82          t.isVisited = false;
 83          t.Next = null;
 84          /*
 85             图的节点链表加入该子节点
 86           */
 87          NodeList.Add(t);
 88          nodeCount = NodeList.Count;
 89      }
 90 
 91      /// <summary>
 92      /// 在图中添加一条边
 93      /// </summary>
 94      /// <param name="FromValue">起始节点的值</param>
 95      /// <param name="ToValue">目的节点的值</param>
 96      /// <param name="BorderWeight"></param>
 97      public void AddBorder(T FromValue, T ToValue, T BorderWeight) 
 98      {
 99 
          DirectAddBorder(FromValue,ToValue,BorderWeight);
          DirectAddBorder(ToValue, FromValue, BorderWeight);        
          borderCount++;
         
      }
 
      void DirectAddBorder(T FromValue, T ToValue, T w)
      {
          HeadNode FromNode;
          HeadNode ToNode;
          FromNode = Find(FromValue);
          if (FromNode == null)
          {
              ErrorShow("图中找不到起始节点");
              return;
          }
          ToNode = Find(ToValue);
          if (ToNode == null)
          {
              ErrorShow("图中找不到目的节点");
              return;
          }
 
 
 
          SubNode<HeadNode> t = new GraphLink<T>.SubNode<GraphLink<T>.HeadNode>(ToNode);
          t.weight = w;
 
          if (FromNode.Next == null)   //头节点没有子节点的情况
          {
              FromNode.Next = t;
          }
          else
          {
 
              SubNode<HeadNode> p = FromNode.Next;
              SubNode<HeadNode> pr = p;
 
              while (p != null)
              {
                  /*
                    判断时有已有存在的边
                   * 如果有的话则提示并且返回
                   */
                  if (p.adjex.data.Equals(ToValue) == true)
                  {
                      ErrorShow("这条边已经存在");
                      return;
                  }
                  pr = p;
                  p = p.next;
 
              }
              pr.next = t;
          }
          
 
      }
      /// <summary>
      /// 递归方式 深度优先遍历图  
      /// </summary>
      /// <param name="StartNodeValue">起始节点的值</param>
      public void DFSTraverse(T StartNodeValue) 
      {
          HeadNode h = Find(StartNodeValue);
          if (h == null) 
          {
              ErrorShow("图中不存在该起始节点");
          }
          DFS(h);
 
      }
 
      void DFS(HeadNode n) 
      {
          VistNode(n);
 
          if (n.Next != null) 
          {
              /*
                访问已访问节点的子节点 
               */
              SubNode<HeadNode> p = n.Next;
          
              while (p != null) 
              {
                  /*如果已访问节点n的子节点中有未访问的节点
                   * 则递归访问该节点
                   */
                  if (p.adjex.isVisited == false) 
                  {
                      DFS(p.adjex); //递归遍历未访问过的头节点
                  }  
 
                  p = p.next;
              }
          }
      }
      /// <summary>
      /// 广度优先遍历图
      /// </summary>
      /// <param name="StartNodeValue">起始节点的值</param>
      public void BFSTraverse(T StartNodeValue) 
      {
          HeadNode h = Find(StartNodeValue);
          if (h == null)
          {
              ErrorShow("图中不存在该起始节点");
          }
          BFS(h);
      }
 
      void BFS(HeadNode n) 
      {
          /*借助先入先出的队列来按层次访问图*/
          Queue<HeadNode> NodeQueue = new Queue<GraphLink<T>.HeadNode>();
 
          NodeQueue.Enqueue(n);
          while (NodeQueue.Count>0) 
          {
              HeadNode h= NodeQueue.Dequeue();
              /*如果该节点还未被访问则访问该节点*/
              if (h.isVisited == false)
              {
                  VistNode(h);
              }
 
              if (h.Next != null) 
              {
                  SubNode<HeadNode> p = h.Next;
                  while (p != null) 
                  {
                      /*如果该节点还未被访问则访问该节点*/
                      if (p.adjex.isVisited == false)
                      {
                          VistNode(p.adjex);
                          NodeQueue.Enqueue(p.adjex);
                      }
                      p = p.next;
 
                  }
              }
          }
      }
 
      void VistNode(HeadNode n) 
      {
          Console.WriteLine(n.data.ToString());
          /*设置已访问标志*/
          n.isVisited = true;  
          
      }
 
      void ErrorShow(string txt) 
      {
          Console.WriteLine(txt);
      }
      /// <summary>
      /// 在节点链表中查找节点
      /// </summary>
      /// <param name="keyValue">待查找节点的数据域的值</param>
      /// <returns></returns>
       HeadNode Find(T keyValue) 
      {
          foreach (HeadNode t in NodeList) 
          {
          
            if(t.data.Equals(keyValue)==true)
            {
              return t;
            }
          }
          return null;
      }
      /// <summary>
      /// 显示所有节点的值
      /// </summary>
       public void ShowAllNodes() 
       {
           foreach (HeadNode t in NodeList) 
           {
               Console.WriteLine(t.data);
           }
       }
 
 
     }
 
  
 }