Reimplement sort using depth-first-search

Author: kgryte

lib/node_modules/@stdlib/utils/compact-adjacency-matrix/examples/index.js

@@ -49,4 +49,4 @@ console.log( adj.toAdjacencyList() );
 
 // Compute a topological ordering:
 console.log( adj.toposort() );
-// => [ 1, 0, 2, 3 ]
+// => [ [ 1, 0, 2, 3 ], null ]

lib/node_modules/@stdlib/utils/compact-adjacency-matrix/lib/main.js

@@ -28,6 +28,7 @@ var Int32Array = require( '@stdlib/array/int32' );
 var Int8Array = require( '@stdlib/array/int8' );
 var ceil = require( '@stdlib/math/base/special/ceil' );
 var floor = require( '@stdlib/math/base/special/floor' );
+var grev = require( '@stdlib/blas/ext/base/grev' );
 var fifo = require( '@stdlib/utils/fifo' );
 var setBit = require( './set_bit.js' );
 var clearBit = require( './clear_bit.js' );
@@ -579,7 +580,7 @@ setReadOnly( CompactAdjacencyMatrix.prototype, 'toAdjacencyList', function toAdj
 * var order = adj.toposort();
 * // returns [ 1, 0, 2, 3 ]
 */
-setReadOnly( CompactAdjacencyMatrix.prototype, 'toposort', function toposort() {
+setReadOnly( CompactAdjacencyMatrix.prototype, 'toposort_bfs', function toposort() {
 	var visited;
 	var degs;
 	var buf;
@@ -660,6 +661,120 @@ setReadOnly( CompactAdjacencyMatrix.prototype, 'toposort', function toposort() {
 	return out;
 });
 
+/**
+* Returns a topological ordering of the directed graph.
+*
+* ## Notes
+*
+* -   The function returns a two-element array.
+* -   If the function is able to compute a topological ordering, the first array element is the topological ordering and the second element is `null`.
+* -   If a topological ordering cannot be achieved (e.g., due to the graph not being a directed acyclic graph (DAG)), the first array element is `null` and the second element is the first encountered cycle.
+*
+* @name toposort
+* @type Function
+* @memberof CompactAdjacencyMatrix.prototype
+* @returns {Array} topological ordering
+*
+* @example
+* var adj = new CompactAdjacencyMatrix( 4 );
+* // returns <CompactAdjacencyMatrix>
+*
+* adj.addEdge( 1, 0 );
+* adj.addEdge( 1, 2 );
+* adj.addEdge( 0, 2 );
+* adj.addEdge( 2, 3 );
+*
+* var results = adj.toposort();
+* // returns <Array>
+*
+* var order = results[ 0 ];
+* // returns [ 1, 0, 2, 3 ]
+*
+* var cycle = results[ 1 ];
+* // returns null
+*/
+setReadOnly( CompactAdjacencyMatrix.prototype, 'toposort', function toposort() {
+	var marks;
+	var self;
+	var out;
+	var idx;
+	var err;
+	var N;
+	var s;
+	var i;
+
+	self = this;
+	N = this._N;
+
+	// Initialize an empty list that will contain the sorted vertices:
+	out = [];
+
+	// If the graph is empty, nothing to sort...
+	if ( this._N === 0 ) {
+		return [ out, null ];
+	}
+	// Initialize an array for keeping track of whether a vertex has been "visited":
+	marks = new Int8Array( N );
+
+	// Initialize a stack for keeping track of cycles:
+	s = [];
+
+	// Process vertices using depth-first-search...
+	idx = [ 0, 0 ];
+	for ( i = 0; i < N; i++ ) {
+		if ( marks[ i ] === 0 ) {
+			err = visit( i );
+			if ( err !== 0 ) {
+				// Found a cycle...
+				return [ null, s ];
+			}
+		}
+	}
+	grev( out.length, out, 1 );
+	return [ out, null ];
+
+	/**
+	* Visits a graph vertex and follows edges until finding a leaf vertex (if one exists).
+	*
+	* ## Notes
+	*
+	* -   If the function is able to successfully perform a depth-first-search, the functions returns `0`; otherwise, the function returns `-1` in the event of a cycle.
+	*
+	* @private
+	* @param {NonNegativeInteger} i - vertex
+	* @returns {integer} error code
+	*/
+	function visit( i ) {
+		var err;
+		var j;
+		if ( marks[ i ] === 2 ) {
+			return 0;
+		}
+		if ( marks[ i ] === 1 ) {
+			return -1;
+		}
+		marks[ i ] = 1;
+		for ( j = 0; j < N; j++ ) {
+			// Follow all edges from the current vertex:
+			idx = self._loc( i, j, idx ); // eslint-disable-line no-underscore-dangle
+			if ( isSet( self._buffer[ idx[0] ], idx[1] ) ) { // eslint-disable-line no-underscore-dangle
+				err = visit( j );
+				if ( err !== 0 ) {
+					s.push( j );
+					return err;
+				}
+			}
+		}
+		marks[ i ] = 2;
+		out.push( i );
+		return 0;
+	}
+});
+
+// TODO: add static fromAdjacencyList( adjlist ), fromEdges( N, edges ) methods
+
+// TODO: consider supporting a partial sort for toposort (i.e., first N, or last N (-N), or range M to N)
+
 
 // EXPORTS //