Initial commit for working on weighted-graph implementation

cpp/algorithms/graphs/weighted/lib-graph.cpp

@@ -0,0 +1,189 @@
+/*##############################################################################
+## Author: Shaun Reed                                                         ##
+## Legal: All Content (c) 2021 Shaun Reed, all rights reserved                ##
+## About: Driver program to test object graph implementation                  ##
+##                                                                            ##
+## Contact: shaunrd0@gmail.com  | URL: www.shaunreed.com | GitHub: shaunrd0   ##
+################################################################################
+*/
+
+#include "lib-graph.hpp"
+
+
+InfoBFS Graph::BFS(const Node& startNode) const
+{
+  // Create local object to track the information gathered during traversal
+  InfoBFS searchInfo;
+
+  // Create a queue to visit discovered nodes in FIFO order
+  std::queue<const Node *> visitQueue;
+
+  // Mark the startNode as in progress until we finish checking adjacent nodes
+  searchInfo[startNode.number].discovered = Gray;
+
+  // Visit the startNode
+  visitQueue.push(&startNode);
+
+  // Continue to visit nodes until there are none left in the graph
+  while (!visitQueue.empty()) {
+    // Remove thisNode from the visitQueue, storing its vertex locally
+    const Node * thisNode = visitQueue.front();
+    visitQueue.pop();
+    std::cout << "Visiting node " << thisNode->number << std::endl;
+
+    // Check if we have already discovered all the adjacentNodes to thisNode
+    for (const auto &adjacent : thisNode->adjacent) {
+      if (searchInfo[adjacent.GetNumber()].discovered == White) {
+        std::cout << "Found undiscovered adjacentNode: " << adjacent.GetNumber()
+                  << "\n";
+        // Mark the adjacent node as in progress
+        searchInfo[adjacent.GetNumber()].discovered = Gray;
+        searchInfo[adjacent.GetNumber()].distance =
+            searchInfo[thisNode->number].distance + 1;
+        searchInfo[adjacent.GetNumber()].predecessor =
+            &GetNode(thisNode->number);
+
+        // Add the discovered node the the visitQueue
+        visitQueue.push(&GetNode(adjacent.GetNumber()));
+      }
+    }
+    // We are finished with this node and the adjacent nodes; Mark it discovered
+    searchInfo[thisNode->number].discovered = Black;
+  }
+
+  // Return the information gathered from this search, JIC caller needs it
+  return searchInfo;
+}
+
+std::deque<Node> Graph::PathBFS(const Node &start, const Node &finish) const
+{
+  // Store the path as copies of each node
+  // + If the caller modifies these, it will not impact the graph's data
+  std::deque<Node> path;
+
+  InfoBFS searchInfo = BFS(start);
+  const Node * next = searchInfo[finish.number].predecessor;
+  bool isValid = false;
+  do {
+    // If we have reached the start node, we have found a valid path
+    if (*next == Node(start)) isValid = true;
+
+    // Add the node to the path as we check each node
+    // + Use emplace_front to call the Node copy constructor
+    path.emplace_front(*next);
+
+    // Move to the next node
+    next = searchInfo[next->number].predecessor;
+  } while (next != nullptr);
+  // Use emplace_back to call Node copy constructor
+  path.emplace_back(finish);
+
+  // If we never found a valid path, erase all contents of the path
+  if (!isValid) path.erase(path.begin(), path.end());
+
+  // Return the path, the caller should handle empty paths accordingly
+  return path;
+}
+
+InfoDFS Graph::DFS() const
+{
+  // Track the nodes we have discovered
+  InfoDFS searchInfo;
+  int time = 0;
+
+  // Visit each node in the graph
+  for (const auto& node : nodes_) {
+    std::cout << "Visiting node " << node.number << std::endl;
+    // If the node is undiscovered, visit it
+    if (searchInfo[node.number].discovered == White) {
+      std::cout << "Found undiscovered node: " << node.number << std::endl;
+      // Visiting the undiscovered node will check it's adjacent nodes
+      DFSVisit(time, node, searchInfo);
+    }
+  }
+
+  return searchInfo;
+}
+
+InfoDFS Graph::DFS(const Node &startNode) const
+{
+  // Track the nodes we have discovered
+  InfoDFS searchInfo;
+  int time = 0;
+
+  auto startIter = std::find(nodes_.begin(), nodes_.end(),
+                             Node(startNode.number, {})
+  );
+
+  // beginning at startNode, visit each node in the graph until we reach the end
+  while (startIter != nodes_.end()) {
+    std::cout << "Visiting node " << startIter->number << std::endl;
+    // If the startIter is undiscovered, visit it
+    if (searchInfo[startIter->number].discovered == White) {
+      std::cout << "Found undiscovered node: " << startIter->number << std::endl;
+      // Visiting the undiscovered node will check it's adjacent nodes
+      DFSVisit(time, *startIter, searchInfo);
+    }
+    startIter++;
+  }
+
+  // Once we reach the last node, check the beginning for unchecked nodes
+  startIter = nodes_.begin();
+
+  // Once we reach the initial startNode, we have checked all nodes
+  while (*startIter != startNode) {
+    std::cout << "Visiting node " << startIter->number << std::endl;
+    // If the startIter is undiscovered, visit it
+    if (searchInfo[startIter->number].discovered == White) {
+      std::cout << "Found undiscovered node: " << startIter->number << std::endl;
+      // Visiting the undiscovered node will check it's adjacent nodes
+      DFSVisit(time, *startIter, searchInfo);
+    }
+    startIter++;
+  }
+
+  return searchInfo;
+}
+
+void Graph::DFSVisit(int &time, const Node& startNode, InfoDFS &searchInfo) const
+{
+  searchInfo[startNode.number].discovered = Gray;
+  time++;
+  searchInfo[startNode.number].discoveryFinish.first = time;
+
+  // Check the adjacent nodes of the startNode
+  for (const auto &adjacent : startNode.adjacent) {
+    auto iter = std::find(nodes_.begin(), nodes_.end(),
+                          Node(adjacent.GetNumber(), {}));
+    // If the adjacentNode is undiscovered, visit it
+    // + Offset by 1 to account for 0 index of discovered vector
+    if (searchInfo[iter->number].discovered == White) {
+      std::cout << "Found undiscovered adjacentNode: "
+                << GetNode(adjacent.GetNumber()).number << std::endl;
+      // Visiting the undiscovered node will check it's adjacent nodes
+      DFSVisit(time, *iter, searchInfo);
+    }
+  }
+  searchInfo[startNode.number].discovered = Black;
+  time++;
+  searchInfo[startNode.number].discoveryFinish.second = time;
+}
+
+std::vector<Node> Graph::TopologicalSort(const Node &startNode) const
+{
+  InfoDFS topological = DFS(GetNode(startNode.number));
+
+  std::vector<Node> order(nodes_);
+
+  auto comp = [&topological](const Node &a, const Node &b) {
+    return (topological[a.number].discoveryFinish.second <
+      topological[b.number].discoveryFinish.second);
+  };
+
+  std::sort(order.begin(), order.end(), comp);
+
+  // The topologicalOrder is read right-to-left in the final result
+  // + Output is handled in main as FILO, similar to a stack
+  return order;
+}
+