【数据结构】图论算法笔记整理

图的遍历

• 有两种存储方式：邻接矩阵和邻接表
• 在一些顶点数目比较大（一般顶点个数在1000以上）的情况下，使用邻接表而不是邻接矩阵来存储图。如果是稀疏图，用邻接表，如果是稠密图，用邻接矩阵。

深度优先搜索dfs遍历图

• 按深度优先的方式访问所有未被访问的结点，在结点被访问过后标记为已访问

• dfs(u) {
    vis[u] = true;
    for(从u除法道能到达的所有顶点v)
      if(vis[v] == false)
        dfs(v);
  }
  dfsTrave(G) {
    for(G的所有结点u)
      if(vis[u] == false)
        dfs(u);
  }
  

• //邻接矩阵
  void dfs(int u, int depth) {
    vis[u] = true;
    for(int v = 0; v < n; v++) {
      if(vis[v] == false && G[u][v] != INF)
        dfs(v, depth + 1);
    }
  }
  
  void dfsTrave() {
    for(int u = 0; u < n; u++)
    	if(vis[u] == false)
      	dfs(u, 1);
  }
  

• //邻接表
  void dfs(int u, int depth) {
    vis[u] = true;
    for(int u = 0; u < arr[u].size(); u++)
      dfs(v, depth + 1);
  }
  
  void dfsTrave() {
    for(int u = 0; u < n; u++) {
      if(vis[u] == false)
        dfs(u, 1);
    }
  }
  

广度优先搜索bfs遍历图

• 建立一个队列，把初始定点加入队列，然后每次都取出队首元素进行访问，并把该定点除法可以到达的未曾加入过队列（而不是未访问）的定点全部加入队列，直到队列为空

• bfs(u) {
    queue q;
    将u入队
    inq[u] = true;
    while(q非空) {
      for(从u除法道可到达的所有定点v) {
        if(inq[v] == false)
          将v入队
          inq[v] = true;
      }
    }
  }
  bfsTrave(G) {
    for(G的所有顶点u) {
      if(inq[u] == false)
        bfs(u);
    }
  }
  

• void bfs(int u) {
    queue<int> q;
    q.push(u);
    inq[u] = true;
    while(!q.empty()) {
      int u = q.front();
      q.pop();
      for(int v = 0; v < n; v++) {
        if(inq[u] == false && G[u][v] != INF) {
          q.push(v);
          inq[v] = true;
        }
      }
    }
  }
  /*邻接表：
  for(int i = 0; i < arr[u].size(); i++) {
    int v= arr[u][i];
    if(inq[u] == false) {
      q.push(v);
      inq[v] = true;
    }
  }
  */
  
  void bfsTrave() {
    for(int u = 0; u < n; u++) {
      if(inq[u] == false)
        bfs(q);
    }
  }