暑期修炼第一天：英语50单词+线代行列式+深度广度优先

本文链接：https://blog.csdn.net/Bruski/article/details/81073142

从今天起到2018/8/31，是属于我最后一段考研学习与编程修炼的时期！

今天没做好规划，效率不是很高，早上背了50个单词，数学从线代部分开始，看完行列式部分，并完成了例题。

晚上是属于编程的训练时间，可以学和写任何想写的代码：今天学习的是图论的深度优先和广度优先算法。两个算法都是基于邻接链表来实现的，语言是C++；

邻接链表数据结构：

const int MaxSize = 10;

// 邻接表（链式存储）
struct adjNode           //边表信息
{
   int end_node;       //邻接的顶点信息
   int weight;           //边的权重
   adjNode *next;       //指针，指向下一条边
};

struct VNode
{
   int name;           //顶点信息
   adjNode *next;       //指针，指向第一条边
};

// 邻接链表类
class GraphLinkedTable
{
public:
   VNode vertex[MaxSize];       //顶点链表
   int n;                       //顶点数
   int e;                       //边数
public:
   GraphLinkedTable();
   ~GraphLinkedTable();
   void insertEdge(int v1, int v2, int w);
   void buildGraph();
   void print();
};

深度优先算法：

主要用到递归来实现往深处走的逻辑，与二叉树的先序遍历相似。

/*
* 深度优先算法
*/
void DFS(GraphLinkedTable G, int v)
{
   Visit(v);   //访问初始点，并标记

   adjNode *p;
   p = G.vertex[v].next;   //找下一个点
   while (p != NULL)
   {
       if (visited[p->end_node] == 0)   //若结点未访问
           DFS(G, p->end_node);       //递归调用DFS，往深处走
       p = p->next;               //回溯的时候，推动算法的进程
   }
}

广度优先算法

主要用到队列来记录结点访问顺序，利用邻接链表的特性，实现层次遍历。

/*
* 广度优先算法
*/
void BFS(GraphLinkedTable G, int v)
{
   adjNode *p;
   int que[MaxSize], front = 0, rear = 0;   //用到队列，用于记录结点访问顺序
   int out;

   Visit(v);   //访问初始点
   rear = (rear + 1) % MaxSize;
   que[rear] = v;   //将初始点加入队列

   while (front != rear)
   {
       front = (front + 1) % MaxSize;
       out = que[front];   //出队操作
       p = G.vertex[out].next;   //取到出队点的下一个点

       while (p != NULL)
       {
           if (visited[p->end_node] == 0)           //若结点未访问
           {
               Visit(p->end_node);                   //访问该节点
               rear = (rear + 1) % MaxSize;
               que[rear] = p->end_node;           //将该节点加入队列
           }
           p = p->next;                       //根据邻接链表的特点，指针往下走就是在执行广度优先
       }
   }

}