shaunrd0
/
klips
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Add example of simple graph algorithms 

+ Using pseudocode examples from MIT Intro to Algorithms
This commit is contained in:
Shaun Reed 2021-06-19 16:08:15 -04:00
parent 8f211b1603
commit 1fc34d2dd4
6 changed files with 310 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
cpp/algorithms/CMakeLists.txt
View File

@ -15,5 +15,6 @@ project (
LANGUAGES CXX
)
add_subdirectory(graphs)
add_subdirectory(sorting)
add_subdirectory(trees)

18
cpp/algorithms/graphs/CMakeLists.txt Normal file
View File

@ -0,0 +1,18 @@
###############################################################################
## Author: Shaun Reed ##
## Legal: All Content (c) 2021 Shaun Reed, all rights reserved ##
## About: A root project for practicing graph algorithms in C++ ##
## ##
## Contact: shaunrd0@gmail.com | URL: www.shaunreed.com | GitHub: shaunrd0 ##
##############################################################################
#
cmake_minimum_required(VERSION 3.15)
project (
#[[NAME]] Graphs
VERSION 1.0
DESCRIPTION "A project for practicing algorithms using graphs in C++"
LANGUAGES CXX
)
add_subdirectory(simple)

22
cpp/algorithms/graphs/simple/CMakeLists.txt Normal file
View File

@ -0,0 +1,22 @@
###############################################################################
## Author: Shaun Reed ##
## Legal: All Content (c) 2021 Shaun Reed, all rights reserved ##
## About: A CMakeLists configuration to test a simple graph implementation ##
## ##
## Contact: shaunrd0@gmail.com | URL: www.shaunreed.com | GitHub: shaunrd0 ##
##############################################################################
#
cmake_minimum_required(VERSION 3.15)
project(
#[[NAME]] SimpleGraph
VERSION 1.0
DESCRIPTION "Practice implementing and using simple graphs in C++"
LANGUAGES CXX
)
add_library(lib-graph-simple "lib-graph.cpp")
add_executable(graph-test-simple "graph.cpp")
target_link_libraries(graph-test-simple lib-graph-simple)

96
cpp/algorithms/graphs/simple/graph.cpp Normal file
View File

@ -0,0 +1,96 @@
/*#############################################################################
## Author: Shaun Reed ##
## Legal: All Content (c) 2021 Shaun Reed, all rights reserved ##
## About: Driver program to test a simple graph implementation ##
## ##
## Contact: shaunrd0@gmail.com | URL: www.shaunreed.com | GitHub: shaunrd0 ##
###############################################################################
*/
#include "lib-graph.hpp"
int main (const int argc, const char * argv[])
{
// We could initialize the graph with some localNodes...
std::map<int, std::set<int>> localNodes{
{1, {2, 5}}, // Node 1
{2, {1, 6}}, // Node 2
{3, {4, 6, 7}},
{4, {3, 7, 8}},
{5, {1}},
{6, {2, 3, 7}},
{7, {3, 4, 6, 8}},
{8, {4, 6}},
};
// Graph bfsGraph(localNodes);
std::cout << "\n\n##### Breadth First Search #####\n";
// Or we could use an initializer list...
// Initialize a example graph for Breadth First Search
Graph bfsGraph (
{
{1, {2, 5}}, // Node 1
{2, {1, 6}}, // Node 2...
{3, {4, 6, 7}},
{4, {3, 7, 8}},
{5, {1}},
{6, {2, 3, 7}},
{7, {3, 4, 6, 8}},
{8, {4, 6}},
}
);
// The graph traversed in this example is seen in MIT Intro to Algorithms
// + Chapter 22, Figure 22.3 on BFS
bfsGraph.BFS(2);
std::cout << "\n\n##### Depth First Search #####\n";
// Initialize an example graph for Depth First Search
Graph dfsGraph (
{
{1, {2, 4}},
{2, {5}},
{3, {5, 6}},
{4, {2}},
{5, {4}},
{6, {6}},
}
);
// The graph traversed in this example is seen in MIT Intro to Algorithms
// + Chapter 22, Figure 22.4 on DFS
dfsGraph.DFS();
std::cout << "\n\n##### Topological Sort #####\n";
// Initialize an example graph for Topological Sort
Graph topologicalGraph (
{
{1, {4, 5}},
{2, {5}},
{3, {}},
{4, {5, 7}},
{5, {}},
{6, {7, 8}},
{7, {9}},
{8, {9}},
{9, {}},
}
);
// The graph traversed in this example is seen in MIT Intro to Algorithms
// + Chapter 22, Figure 22.7 on Topological Sort
// + Each node was replaced with a value from left-to-right, top-to-bottom
// + Undershorts = 1, Socks = 2, Watch = 3, Pants = 4, etc...
std::vector<int> order = topologicalGraph.TopologicalSort();
// Because this is a simple graph with no objects to store finishing time
// + The result is only one example of valid topological order
// + There are other valid orders; Final result differs from one in the book
std::cout << "\n\nTopological order: ";
while (!order.empty()) {
std::cout << order.back() << " ";
order.pop_back();
}
std::cout << std::endl;
}

137
cpp/algorithms/graphs/simple/lib-graph.cpp Normal file
View File

@ -0,0 +1,137 @@
/*##############################################################################
## Author: Shaun Reed ##
## Legal: All Content (c) 2021 Shaun Reed, all rights reserved ##
## About: An example of a simple graph implementation ##
## Algorithms in this example are found in MIT Intro to Algorithms ##
## ##
## Contact: shaunrd0@gmail.com | URL: www.shaunreed.com | GitHub: shaunrd0 ##
################################################################################
*/
#include "lib-graph.hpp"
void Graph::BFS(int startNode)
{
// Track the nodes we have discovered
std::vector<bool> discovered(nodes_.size());
for (bool node : discovered) node = false; // Initialize all nodes to false
// Create a queue to visit discovered nodes in FIFO order
std::queue<int> visitQueue;
// Visit the startNode
discovered[startNode] = true;
visitQueue.push(startNode);
// Continue to visit nodes until there are none left in the graph
while (!visitQueue.empty()) {
std::cout << "Visiting node " << visitQueue.front() << std::endl;
// Remove thisNode from the visitQueue, storing its vertex locally
int thisNode = visitQueue.front();
visitQueue.pop();
// Check if we have already discovered all the adjacentNodes to thisNode
for (const auto &adjacent : nodes_[thisNode]) {
if (!discovered[adjacent]) {
std::cout << "Found undiscovered adjacentNode: " << adjacent << "\n";
// Mark the adjacent node as discovered
// + If this were done out of the for loop we could discover nodes twice
// + This would result in visiting the node twice, since it appears
// In the visitQueue twice
discovered[adjacent] = true;
// Add the discovered node the the visitQueue
visitQueue.push(adjacent);
}
}
}
}
void Graph::DFS()
{
// Track the nodes we have discovered
std::vector<bool> discovered(nodes_.size());
for (auto node : discovered) node = false; // Initialize nodes to false
// Visit each node in the graph
for (const auto &node : nodes_) {
std::cout << "Visiting node " << node.first << std::endl;
// If the node is undiscovered, visit it
if (!discovered[node.first]) {
std::cout << "Found undiscovered node: " << node.first << std::endl;
// Mark the node as visited so we don't visit it twice
discovered[node.first] = true;
// Visiting the undiscovered node will check it's adjacent nodes
DFSVisit(node.first, discovered);
}
}
}
void Graph::DFSVisit(int startNode, std::vector<bool> &discovered)
{
// Check the adjacent nodes of the startNode
for (auto &adjacent : nodes_[startNode]) {
// If the adjacentNode is undiscovered, visit it
if (!discovered[adjacent]) {
std::cout << "Found undiscovered adjacentNode: " << adjacent << std::endl;
// Mark the node as visited so we don't visit it twice
discovered[adjacent] = true;
// Visiting the undiscovered node will check it's adjacent nodes
DFSVisit(adjacent, discovered);
}
}
}
std::vector<int> Graph::TopologicalSort()
{
std::vector<int> topologicalOrder;
// Track the nodes we have discovered
std::vector<bool> discovered(nodes_.size());
for (auto node : discovered) node = false; // Initialize nodes to false
// Visit each node in the graph
for (const auto &node : nodes_) {
std::cout << "Visiting node " << node.first << std::endl;
// If the node is undiscovered, visit it
// + Offset by 1 to account for 0 index of discovered vector
if (!discovered[node.first - 1]) {
std::cout << "Found undiscovered node: " << node.first << std::endl;
// Visiting the undiscovered node will check it's adjacent nodes
TopologicalVisit(node.first, discovered, topologicalOrder);
}
}
// The topologicalOrder is read right-to-left in the final result
// + Output is handled in main as FILO, similar to a stack
return topologicalOrder;
}
void Graph::TopologicalVisit(
int startNode, std::vector<bool> &discovered, std::vector<int> &order
)
{
// Mark the node as visited so we don't visit it twice
discovered[startNode - 1] = true;
// Check the adjacent nodes of the startNode
for (auto &adjacent : nodes_[startNode]) {
// If the adjacentNode is undiscovered, visit it
if (!discovered[adjacent - 1]) {
std::cout << "Found undiscovered adjacentNode: " << adjacent << std::endl;
// Visiting the undiscovered node will check it's adjacent nodes
TopologicalVisit(adjacent, discovered, order);
}
}
// Add startNode to the topologicalOrder
order.push_back(startNode);
}

36
cpp/algorithms/graphs/simple/lib-graph.hpp Normal file
View File

@ -0,0 +1,36 @@
/*#############################################################################
## Author: Shaun Reed ##
## Legal: All Content (c) 2021 Shaun Reed, all rights reserved ##
## About: An example of a simple graph implementation ##
## Algorithms in this example are found in MIT Intro to Algorithms ##
## ##
## Contact: shaunrd0@gmail.com | URL: www.shaunreed.com | GitHub: shaunrd0 ##
###############################################################################
*/
#ifndef LIB_GRAPH_HPP
#define LIB_GRAPH_HPP
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
class Graph {
public:
explicit Graph(std::map<int, std::set<int>> nodes) : nodes_(std::move(nodes)) {}
std::map<int, std::set<int>> nodes_;
void BFS(int startNode);
void DFS();
void DFSVisit(int startNode, std::vector<bool> &discovered);
std::vector<int> TopologicalSort();
void TopologicalVisit(
int startNode, std::vector<bool> &discovered, std::vector<int> &order
);
};
#endif // LIB_GRAPH_HPP