Knotted should work now. I really was over-complicating it. I have commented the code and removed unused includes from the file.

Project-2-input-example-1.txt

@@ -0,0 +1,20 @@
+% A line starting with a % is a comment, and blank lines are skipped
+
+% First list the number of processes and resources using the keywords num_processes and num_resources.
+%The value which corresponds to each keyword must be an integer.
+%The keyword and its corresponding value must be separated by an equal sign (=) as demonstrated below:
+num_processes=3
+num_resources=3
+
+% Next, list the number of units of each resource in a single row, separated by commas (,)
+2,1,1
+
+% Then list the adjacency matrix. All processes will be listed first, followed by all of the resources.
+% The order of resources in this list must be the same as the ordering of resources in the list above which specified the numer of units of each resource.
+% Each row is listed on a separate line. Columns within a row are separated by a comma (,)
+1,0,0,0,1,0
+0,1,0,1,0,1
+0,0,1,0,0,0
+1,0,1,1,0,0
+0,1,0,0,1,0
+0,0,1,0,0,1

inc/graph.hpp

@@ -2,7 +2,8 @@
 #ifndef PROJECT2_INC_GRAPH_HPP
 #define PROJECT2_INC_GRAPH_HPP
 
-#include <string> // string
+#include <set>		// set<int>.find()
+#include <string> 	// string -- not used?
 #include <vector> 	// vector<int>, vector<vector<int>
 
 typedef std::vector<std::vector<int>> matrix;
@@ -27,9 +28,12 @@ class graph {
    bool reducible (); // ?
    bool knotted ();   // ?
    
+
    // miscellaneous functions:
    //   print the graph
    void print ();
+	bool DFS( int node, std::set<int>&visited, int parent );
+	bool detectKnot();
 	
   private:
    int num_processes = 0;

src/knotted.cpp

@@ -5,90 +5,34 @@
    +--------------------------+--------------------------+  */
 
 #include <cstdlib>
-#include <string>
+#include <set>		// why set? because it supports find and it makes it easier.
-#include <vector>
 #include "graph.hpp"
 
 
-
+// depth-first-search is needed to detect the knot in the graph
-// goal is to create an group of objects that point to each other the same way the graph does and then detect loops
+bool graph::DFS ( int node, std::set<int>&visited, int parent ) {
-/*
+	visited.insert(node); // once we come across this node, mark it as visited in the set
-enum class resourcetype { P, R };
+	// note: node in this function is called using the iterator from the calling function.
-
+	for ( int ii = 0; ii < (num_processes+num_resources); ii++ ) { // for every process and resource...
-struct PR {
+		if ( m[node][ii] ) { // m is the matrix part of graph class; if the valu
-    int value;
+			if ( ii == parent ) continue; // if index is parent, skip
-	resourcetype type; // {P,R}
+			if ( visited.find(ii) != visited.end() ) return true; // case index is visited, already visited
-	resourcenum index;
+			if ( DFS( ii, visited, node ) ) return true; // if search results is true
-    vector<struct PR*> in;
+		}//\if
-	vector<struct PR*> out;
+	}//\for
-	bool visited;
-};
-
-void insertPR( struct PR** head,) {
-	struct PR* new_node = new PR; // neclare a new resource
-	new_node->value = new_data; 
-    new_node->in.push_back(); 
-	new_node->out.push_back(); 
-	new_node->visited  = false;
-}
-
-void checkKnots () {
-
-	//
-	// convert graph to a list where each item is a resource and has a list of connected resources
-	// ex:  	0 (P1)	:	0 (P1), 4 (R2)
-	// 		 	1 (P2)	:	1 (P2), 3 (R1), 5 (R3)
-	//
-	
-}*/
-
-
-/* convert adjaceny matrix to adjaceny list */
-std::vector<std::vector<int>> convert(std::vector<std::vector<int>> x) {
-	std::vector<std::vector<int>> adjacencyList(x.size());
-	for ( int ii = 0; ii < x.size(); ii++ )
-		for ( int jj = 0; jj < x[ii].size(); jj++ )
-			if (x[ii][jj] == 1)
-				adjacencyList[ii].push_back(jj);
-    return adjacencyList;
-}
-
-
-
-/* linked list data structure */
-struct Vertex {
-    int data; // contents of node
-    struct Vertex* next; // point to next node
-	struct Vertex* prev; // point to prev node
-	bool visited; // flag used to signal visited
-};
- 
-void pushLL(struct Vertex** list_head, int new_data) {
-    struct Vertex* new_node = new Vertex; // declare a new vertex
-    new_node->data = new_data; // populate the data for the new node
-    new_node->next = (*list_head); // link back to the old list from the new node
-	new_node->prev = (*list_head); // link back to the old list from the new node
-	new_node->visited  = false;
-    (*list_head) = new_node; // point list head to the new node
-}
-
-bool checkKnot(struct Vertex* v) {
-	
-	//vector<vector<int>> a;
-	//vector<vector<int>> AdjacencyList = convert(m);
-	
-    std::vector<Vertex*> visited; // set to store the visited nodes
-    while ( v != NULL ) { // loop over the nodes in the linked list if the linked list is not empty
-		/* detect if node has been visited; if has, then there is a knot (and a loop) */
-        if ( v->visited ) // find if this node is visited
-            return true; // immediate return
-        /* if node not visited, visit it and then continue */
-        v->visited = true; // mark node as visited
-        v = v->next; // increment linked list position
-    }
 	return false;
 }
 
+// this runs a DFS search on an undirected graph to detect a knot
+bool graph::detectKnot() {
+	std::set<int> visited; // define a set to keep track of visited nodes; a cycle will revisit visited nodes
+	for ( int ii = 0; ii < (num_processes+num_resources); ii++ ) { // for every process and resource...
+		if ( visited.find(ii) != visited.end() ) continue; // if this node is already found in visited, skip
+		if ( DFS(ii,visited,-1) ) return true; // start DFS with -1 for parent node, then it continues recursively
+		continue; // if neither above is true, continue searching until DFS is complete
+	}//\for
+	return false; // if no knot is found, return false
+}
 
 /* knotted:
 	Perform the knot detection algorithm on the adjacency matrix to detect deadlocks
@@ -100,21 +44,5 @@ bool checkKnot(struct Vertex* v) {
 			false if graph is not knotted (no deadlock)
 */
 bool graph::knotted() {
-	/* Matrix sequel (copy) to preserve original */
+	return (detectKnot()) ? true : false;
-	matrix revolutions = m;
-	struct Vertex* neo = NULL; // neo is the head of the linked list
-	
-	for ( int matrix_row = 0; matrix_row < num_processes + num_resources; matrix_row++ ) {
-		for ( int matrix_col = 0; matrix_col < num_processes + num_resources; matrix_col++ ) {
-			if ( matrix_row == matrix_col ) continue; // do not connect processes and resources to themselves
-			if ( m[matrix_row][matrix_col] == 1 ) {
-				pushLL(&neo,matrix_row);
-			}
-			else {
-				continue;
-			}
-		}
-	}
-	
-	return false;
 }

src/main.cpp

@@ -25,7 +25,7 @@ int main (int argc, char **argv) {
    g.print ();
    // Graph reduction
    printf ("Graph is %s\n", g.reducible () ? "not reducible! Deadlock!" : "reducible! No deadlock!");
-   // TODO: Knot detection
+   // Knot detection
-   // printf ("Graph is %s\n", g.knotted () ? "knotted! Deadlock!" : "not! No deadlock!");
+   printf ("Graph is %s\n", g.knotted () ? "knotted! Deadlock!" : "not! No deadlock!");
    return 0;
 }