Share on 
CXXGraph is a small library, header only, that manages the Graph and it's algorithms in C++. In other words a "Comprehensive C++ Graph Library". An alternative to Boost Graph Library (BGL).
- CXXGraph
- Introduction
- Table of Contents
- Install and Uninstall
- Classes Explanation
- Requirements
- How to use
- Example
- Unit-Test Execution
- Benchmark Execution
- Packaging
- Algorithm Explanation
- Partition Algorithm Explanation
- How to contribute
- Site
- Contact
- Support
- References
- Credits
- Hacktoberfest 2k21
- We are Looking for...
- Other Details
On Unix/Linux system you need to execute the following command to install:
$ sudo tar xjf CXXGraph-{version}.tar.bz2
to uninstall:
$ sudo rm -f /usr/include/Graph.hpp /usr/include/CXXGraph*
On Fedora/CentOS/RedHat system you need to execute the following command to install:
$ sudo rpm -ivh CXXGraph-{version}.noarch.rpm
to uninstall:
$ sudo rpm -e CXXGraph-{version}
On Debian/Ubuntu system you need to execute the following command to install:
$ sudo dpkg -i CXXGraph_{version}.deb
to uninstall:
$ sudo apt-get remove CXXGraph
You can install from source the library using CMake. After the compilation phase, you can use:
$ sudo make install
to install the library.
The Classes Explanation can be found in the Doxygen Documentation, in the Classes Section
The minimun C++ standard required is C++17 and a G++ compiler version greater than 7.3.0.
The use of the library is very simple, just put the header file where you need!
Work in Progess
The Unit-Test required the CMake version greater than 3.9 and the google test library.
git clone https://github.com/google/googletest.git
cd googletest # Main directory of the cloned repository.
mkdir -p build # Create a directory to hold the build output.
cd build
cmake .. # Generate native build scripts for GoogleTest.
make # Compile
sudo make install # Install in /usr/local/ by default
From the base directory:
mkdir -p build # Create a directory to hold the build output.
cd build # Enter the build folder
cmake .. # Generate native build scripts for GoogleTest.
make # Compile
After the compilation, you can run the executable that is under the "build" directory with the name "test_exe", with the simple command ./test_exe.
The Benchmark required the CMake version greater than 3.9 and the google test and the google benchmark library.
# Check out the library.
$ git clone https://github.com/google/benchmark.git
# Benchmark requires Google Test as a dependency. Add the source tree as a subdirectory.
$ git clone https://github.com/google/googletest.git benchmark/googletest
# Go to the library root directory
$ cd benchmark
# Make a build directory to place the build output.
$ cmake -E make_directory "build"
# Generate build system files with cmake.
$ cmake -E chdir "build" cmake -DCMAKE_BUILD_TYPE=Release ../
# or, starting with CMake 3.13, use a simpler form:
# cmake -DCMAKE_BUILD_TYPE=Release -S . -B "build"
# Build the library.
$ cmake --build "build" --config Release
# install library
$ sudo cmake --build "build" --config Release --target install
From the base directory:
mkdir -p build # Create a directory to hold the build output.
cd build # Enter the build folder
cmake -DBENCHMARK=ON .. # Generate native build scripts for GoogleTest.
make # Compile
After the compilation, you can run the executable that is under the "build" directory with the name "benchmark", with the simple command ./benchmark.
You can check benchmark result at this link
To create tarballs package you need to follow the following steps:
# Enter Packaging Directory
$ cd packaging
# execute the script to generate tarballs
$ ./tarballs.sh
To create rpm package you need to follow the following steps:
# Enter Packaging Directory
$ cd packaging/rpm
# execute the script to generate tarballs
$ ./make_rpm.sh
To create deb package you need to follow the following steps:
# Enter Packaging Directory
$ cd packaging/deb
# execute the script to generate tarballs
$ ./make_deb.sh
Graph Dijkstras Shortest Path Algorithm(Dijkstra's Shortest Path) Dijkstra's Algorithm is used to find the shortest path from a source node to all other reachable nodes in the graph. The algorithm initially assumes all the nodes are unreachable from the given source node so we mark the distances of all nodes as infinity. (infinity) from source node (INF / infinity denotes unable to reach).
Dial specialization of dijkstra’s algorithm.
When edge weights are small integers (bounded by a parameter C), specialized queues which take advantage of this fact can be used to speed up Dijkstra's algorithm. The first algorithm of this type was Dial's algorithm (Dial 1969) for graphs with positive integer edge weights, which uses a bucket queue to obtain a running time O(|E|+|V|C).(source wikipedia)
Below is complete algorithm:
- Maintains some buckets, numbered 0, 1, 2,…,wV.
- Bucket k contains all temporarily labeled nodes with distance equal to k.
- Nodes in each bucket are represented by list of vertices.
- Buckets 0, 1, 2,..wV are checked sequentially until the first non-empty bucket is found. Each node contained in the first non-empty bucket has the minimum distance label by definition.
- One by one, these nodes with minimum distance label are permanently labeled and deleted from the bucket during the scanning process.
- Thus operations involving vertex include:
- Checking if a bucket is empty
- Adding a vertex to a bucket
- Deleting a vertex from a bucket.
- The position of a temporarily labeled vertex in the buckets is updated accordingly when the distance label of a vertex changes.
- Process repeated until all vertices are permanently labeled (or distances of all vertices are finalized).
At this link you can find a step-by-step illustrations.
Prim's Algorithm Prim's Algorithm is is a greedy algorithm that finds a minimum spanning tree for a weighted undirected graph. This means it finds a subset of the edges that forms a tree that includes every vertex, where the total weight of all the edges in the tree is minimized. The algorithm operates by building this tree one vertex at a time, from an arbitrary starting vertex, at each step adding the cheapest possible connection from the tree to another vertex.
Steps:
- Initialize a tree with a single vertex, chosen arbitrarily from the graph.
- Grow the tree by one edge: of the edges that connect the tree to vertices not yet in the tree, find the minimum-weight edge, and transfer it to the tree.
- Repeat step 2 (until all vertices are in the tree).
(Breadth First Search) Breadth First Search Algorithm(Breadth First Search) Breadth First Search, also quoted as BFS, is a Graph Traversal Algorithm. Time Complexity O(|V| + |E|) where V are the number of vertices and E are the number of edges in the graph. Applications of Breadth First Search are :
- Finding shortest path between two vertices say u and v, with path length measured by number of edges (an advantage over depth first search algorithm)
- Ford-Fulkerson Method for computing the maximum flow in a flow network.
- Testing bipartiteness of a graph.
- Cheney's Algorithm, Copying garbage collection.
And there are many more...
(Depth First Search) Depth First Search Algorithm (Depth First Search) Depth First Search, also quoted as DFS, is a Graph Traversal Algorithm. Time Complexity O(|V| + |E|) where V is number of vertices and E is number of edges in graph. Application of Depth First Search are:
- Finding connected components
- Finding 2-(edge or vertex)-connected components.
- Finding 3-(edge or vertex)-connected components.
- Finding the bridges of a graph.
- Generating words in order to plot the limit set of a group.
- Finding strongly connected components.
And there are many more...
The existence of a cycle in directed and undirected graphs can be determined by whether depth-first search (DFS) finds an edge that points to an ancestor of the current vertex (it contains a back edge). All the back edges which DFS skips over are part of cycles. In an undirected graph, the edge to the parent of a node should not be counted as a back edge, but finding any other already visited vertex will indicate a back edge. In the case of undirected graphs, only O(n) time is required to find a cycle in an n-vertex graph, since at most n − 1 edges can be tree edges.
Many topological sorting algorithms will detect cycles too, since those are obstacles for topological order to exist. Also, if a directed graph has been divided into strongly connected components, cycles only exist within the components and not between them, since cycles are strongly connected.
For directed graphs, distributed message based algorithms can be used. These algorithms rely on the idea that a message sent by a vertex in a cycle will come back to itself. Distributed cycle detection algorithms are useful for processing large-scale graphs using a distributed graph processing system on a computer cluster (or supercomputer).
Applications of cycle detection include the use of wait-for graphs to detect deadlocks in concurrent systems.
Bellman-Ford Algorithm can be used to find the shortest distance between a source and a target node. Time Complexity O(|V| . |E|) where V is number of vertices and E is number of edges in graph which is higher than Dijkstra's shortest path algorithm. The time complexity of dijkstra's algorithm is O(|E| + |V| log |v| ). The advantage of bellman-ford over dijkstra is that it can handle graphs with negative edge weights. Further, if the graph contains a negative weight cycle then the algorithm can detect and report the presense of negative cycle.
This video gives a nice overview of the algorithm implementation. This MIT lecture gives a proof of Bellman-Ford's correctness & its ability to detect negative cycles. Applications:
- Distance‐vector routing protocol
- Routing Information Protocol (RIP)
- Interior Gateway Routing Protocol (IGRP)
We initialize the solution matrix same as the input graph matrix as a first step. Then we update the solution matrix by considering all vertices as an intermediate vertex. The idea is to one by one pick all vertices and updates all shortest paths which include the picked vertex as an intermediate vertex in the shortest path. When we pick vertex number k as an intermediate vertex, we already have considered vertices {0, 1, 2, .. k-1} as intermediate vertices. For every pair (i, j) of the source and destination vertices respectively, there are two possible cases.
- k is not an intermediate vertex in shortest path from i to j. We keep the value of dist[i][j] as it is.
- k is an intermediate vertex in shortest path from i to j. We update the value of dist[i][j] as dist[i][k] + dist[k][j] if dist[i][j] > dist[i][k] + dist[k][j]
Kruskal Algorithm can be used to find the minimum spanning forest of an undirected edge-weighted graph. Time Complexity O(E log E) = O(E log V) where V is number of vertices and E is number of edges in graph. The main speed limitation for this algorithm is sorting the edges.
For a quick understanding of the algorithm procedure, check this video. Some of the real life applications are:
- LAN/TV Network
- Tour Operations
- Water/gas pipe network
- Electric grid
Other algorithms to find the minimum spanning forest are Prim's algorithm or Borůvka's algorithm.
A vertex-cut partitioning divides edges of a graph into equal size partitions. The vertices that hold the endpoints of an edge are also placed in the same partition as the edge itself. However, the vertices are not unique across partitions and might have to be replicated (cut), due to the distribution of their edge across different partitions.
Replication factor quantifies how many vertexes are replicated over computers compared with the the number of vertexes of the original input graph.
This Algorithm is a simple vertex-cut in Round-Robin fashion. It takes the original graph edges and assign them to the partitions, dividing it in equal(or similar) size. This algorithm does not take care of optimization in vertex replication ( Replication Factor) but only balance the edge in the partitions.
Mathematical definition of the problem: Let G be the set of nodes in a graph and n be a given node in that set. Let C be the non-strict subset of G containing both n and all nodes reachable from n, and let C' be its complement. There's a third set M, which is the non-strict subset of C containing all nodes that are reachable from any node in C'. The problem consists of finding all nodes that belong to C but not to M.
Currently implemented Algorithm:
- Use DFS to find all nodes reachable from n. These are elements of set C.
- Initialize C' to be complement of C (i.e. all nodes - nodes that are in C)
- For all nodes in C', apply DFS and get the list of reachable nodes. This is set M.
- Finally removes nodes from C that belong to M. This is our solution.
Application:
This algorithm is used in garbage collection systems to decide which other objects need to be released, given that one object is about to be released.
E-Mail : [email protected]
To support me just add Star the project 
To get updated watch the project
We are referenced by:
Thanks to the community of TheAlgorithms for some algorithms ispiration.
Thanks to GeeksForGeeks for some algorithms inspiration.
We participate at Hacktoberfest 2021, if you want to contribute, you can take an issue and solve it, or if you want to add a functionalities just open a PR with the label hacktoberfest.
Happy Hack!
We are looking for developers and committer, also at first experience, we will guide you step by step to the open-source world! If you are interested, please contact us at [email protected] or contribute to this project. We are waiting for you!
View the Estimated Value of the Project
