use dfs to count Component inn graph finished

Author: Zu3zz

graph-theory/03-basic-structure-on-graph-problem/main

@@ -0,0 +1,62 @@
+#include <iostream>
+#include <cassert>
+
+using namespace std;
+
+// 求无权图的联通分量
+template <typename Graph>
+class Component{
+private:
+  Graph &G;  // 图的引用
+  bool *visited; // 记录dfs的过程中节点是否被访问
+  int ccount; // 记录联通分量的个数
+  int *id; // 每个节点所对应的联通分量值
+  
+  // 图的深度优先遍历
+  void dfs(int v){
+    visited[v] = true;
+    id[v] = ccount;
+    typename Graph::adjIterator adj(G,v);
+    for(int i = adj.begin(); !adj.end();i = adj.next())
+    {
+      if(!visited[i]){
+        dfs(i);
+      }
+    }
+  }
+public:
+  Component(Graph &graph): G(graph){
+    // 初始化数组
+    visited = new bool[G.V()];
+    id = new int[G.V()];
+    ccount = 0;
+    for(int i = 0; i < G.V(); i++)
+    {
+      visited[i] = false;
+      id[i] = -1;
+    }
+    // 求联通分量的个数
+    for(int i = 0; i < G.V(); i++)
+    {
+      if(!visited[i]){
+        dfs(i);
+        ccount++;
+      }
+    }
+  }
+  // 析构函数
+  ~Component(){
+    delete[] visited;
+    delete[] id;
+  }
+  // 返回图的联通分量个数
+  int count(){
+    return ccount;
+  }
+  int isConnected(int v,int w){
+    assert( v >= 0 && v < G.V());
+    assert( w >= 0 && w < G.V());
+    return id[v] == id[w];
+  }
+  
+};

graph-theory/04-DFS-in-graph/Components

@@ -0,0 +1,86 @@
+#include <iostream>
+#include <cassert>
+#include <vector>
+
+using namespace std;
+
+class DenseGraph{
+private:
+  int n, m;               // 节点数和边数
+  bool directed;          // 是否为有向图
+  vector<vector<bool> > g; // 图的具体数据
+
+public:
+  // 构造函数
+  DenseGraph(int n, bool directed){
+    assert(n >= 0);
+    this->n = n;
+    this->m = 0;
+    this->directed = directed;
+    for(int i = 0; i < n; i++)
+    {
+      g.push_back(vector<bool>(n, false));
+    }
+  }
+  ~DenseGraph(){}
+
+  int V(){return n;}
+  int E(){return m;}
+
+  void addEdge(int v, int w){
+    assert(v >= 0 && v < n);
+    assert(w >= 0 && w < n);
+    if(hasEdge(v,w)){
+      return;
+    }
+    g[v][w] = true;
+    if(!directed){
+      g[w][v] = true;
+    }
+    m++;
+  }
+  
+  bool hasEdge(int v, int w){
+    assert(v >= 0 && v <n);
+    assert(w >= 0 && w < n);
+    return g[v][w];
+  }
+  // 打印邻接矩阵
+  void show(){
+    for(int i = 0; i< n;i++){
+      for(int j = 0;j<n;j++){
+        cout<<g[i][j]<<"\t";
+      }
+      cout<<endl;
+    }
+  }
+
+  class adjIterator{
+  private:
+    DenseGraph &G;
+    int v;
+    int index;
+  public:
+    adjIterator(DenseGraph &graph, int v): G(graph){
+      assert( v>=0 && v< G.n);
+      this->v = v;
+      this->index = -1;
+    }
+    ~adjIterator(){}
+    // 返回图G中与顶点v相连接的第一个顶点
+    int begin(){
+      // 索引从-1开始, 因为每次遍历都需要调用一次next()
+      index = -1;
+      return next();
+    }
+    int next(){
+      for(index +=1;index < G.V();index++)
+        if(G.g[v][index])
+          return index;
+        return -1;
+    }
+    bool end(){
+      return index >= G.V();
+    }
+  };
+};

graph-theory/04-DFS-in-graph/Components.h

@@ -0,0 +1,38 @@
+#include <iostream>
+#include <string>
+#include <fstream>
+#include <cassert>
+#include <sstream>
+
+using namespace std;
+
+template <typename Graph>
+
+class ReadGraph{
+
+public:
+  ReadGraph(Graph &graph, const string &filename){
+    ifstream file(filename);
+    string line;
+    int V,E;
+
+    assert( file.is_open());
+    assert(getline(file, line));
+
+    stringstream ss(line);
+    ss>>V>>E;
+
+    assert(V == graph.V());
+    for(int i = 0; i < E; i++)
+    {
+      assert(getline(file,line));
+      stringstream ss(line);
+
+      int a,b;
+      ss>>a>>b;
+      assert(a >= 0 && a< V);
+      assert(b >= 0 && b < V);
+      graph.addEdge(a,b);
+    }
+  }
+};

graph-theory/04-DFS-in-graph/DenseGraph.h

@@ -0,0 +1,102 @@
+#include <iostream>
+#include <cassert>
+#include <vector>
+
+using namespace std;
+
+class SparseGraph
+{
+private:
+  int n, m;              // 节点数和边数
+  bool directed;         // 是否为有向图
+  vector<vector<int> > g; // 图的具体连接情况
+
+public:
+  // 构造函数
+  SparseGraph(int n, int directed)
+  {
+    this->n = n;
+    this->m = 0;
+    this->directed = directed;
+    for (int i = 0; i < n; i++)
+    {
+      g.push_back(vector<int>());
+    }
+  }
+  ~SparseGraph() {}
+
+  int V() { return n; }
+  int W() { return m; }
+
+  void addEdge(int v, int w)
+  {
+    assert(v >= 0 && v < n);
+    assert(w >= 0 && w < n);
+    g[v].push_back(w);
+    // 考虑自环边
+    if (v != w && !directed)
+    {
+      g[w].push_back(v);
+    }
+    m++;
+  }
+  // 需要遍历 O(n)
+  bool hasEdge(int v, int w)
+  {
+    assert(v >= 0 && v < n);
+    assert(w >= 0 && w < n);
+    for (int i = 0; i < g[v].size(); i++)
+      if (g[v][i] == w)
+        return true;
+    return false;
+  }
+  // 显示图的连接情况
+  void show(){
+    for(int i = 0; i < n; i++)
+    {
+      cout<<"vertx "<<i<<":\t";
+      for(int j = 0; j < g[i].size(); j++)
+      {
+        cout<<g[i][j]<<"\t";
+      }
+      cout<<endl;
+    }
+  }
+
+  class adjIterator
+  {
+  private:
+    SparseGraph &G;
+    int v;
+    int index;
+
+  public:
+    adjIterator(SparseGraph &graph, int v) : G(graph)
+    {
+      this->v = v;
+      this->index = 0;
+    }
+    int begin()
+    {
+      index = 0;
+      if (G.g[v].size())
+      {
+        return G.g[v][index];
+      }
+      return -1;
+    }
+    int next()
+    {
+      index++;
+      if (index < G.g[v].size())
+      {
+        return G.g[v][index];
+      }
+      return -1;
+    }
+    bool end()
+    {
+      return index >= G.g[v].size();
+    }
+  };
+};

graph-theory/04-DFS-in-graph/ReadGraph.h

@@ -0,0 +1,38 @@
+#include <iostream>
+#include "SparseGraph.h"
+#include "DenseGraph.h"
+#include "ReadGraph.h"
+#include "Components.h"
+
+using namespace std;
+
+// 测试图的联通分量算法
+int main() {
+  // TestG1.txt : G1 and G2
+  string filename1 = "testG1.txt";
+  SparseGraph g1 = SparseGraph(13, false);
+  ReadGraph<SparseGraph> readGraph1(g1, filename1);
+  Component<SparseGraph> component1(g1);
+  cout<<"TestG1.txt, Using Sparse Graph, Component Count: "<<component1.count()<<endl;
+
+  DenseGraph g2 = DenseGraph(13, false);
+  ReadGraph<DenseGraph> readGraph2(g2, filename1);
+  Component<DenseGraph> component2(g2);
+  cout<<"TestG1.txt, Using Dense Graph, Component Count: "<<component2.count()<<endl;
+
+  cout<<endl;
+
+  // TestG2.txt : G3 and G4
+  string filename2 = "testG2.txt";
+  SparseGraph g3 = SparseGraph(7, false);
+  ReadGraph<SparseGraph> readGraph3(g3, filename2);
+  Component<SparseGraph> component3(g3);
+  cout<<"TestG2.txt, Using Sparse Graph, Component Count: "<<component3.count()<<endl;
+
+  DenseGraph g4 = DenseGraph(7, false);
+  ReadGraph<DenseGraph> readGraph4(g4, filename2);
+  Component<DenseGraph> component4(g4);
+  cout<<"TestG2.txt, Using Dense Graph, Component Count: "<<component4.count()<<endl;
+
+  return 0;
+}

graph-theory/04-DFS-in-graph/SparseGraph.h

@@ -0,0 +1,14 @@
+13 13
+0 5
+4 3
+0 1
+9 12
+6 4
+5 4
+0 2
+11 12
+9 10
+0 6
+7 8
+9 11
+5 3

graph-theory/04-DFS-in-graph/main.cpp

@@ -0,0 +1,9 @@
+7 8
+0 1
+0 2
+0 5
+0 6
+3 4
+3 5
+4 5
+4 6