更新拓扑排序算法

topological-sorting.cpp

@@ -1,72 +1,72 @@
-class Solution
+class TopologicalSort
 {
 private:
-    enum class STATUS
+	enum class STATUS
-    {
+	{
-        UN_VISITED,
+		UN_VISITED,
-        IN_SEARCHING,
+		IN_SEARCHING,
-        FINISHED
+		FINISHED
-    };
+	};
 
-    vector<vector<int>> edges;
+	vector<vector<int>> edges;
-    vector<Status> visited;
+	vector<STATUS> visited;
-    vector<int> sequence;
+	vector<int> sequence;
 
-    bool find_cycle = false;       // cycle
+	bool find_cycle = false;       // cycle
 
-    /**
+	/**
-     * @brief		deep first search
+	 * @brief		deep first search
-     * @param[in]	node index
+	 * @param[in]	node index
-     *
+	 *
-     */
+	 */
-    void deepFirstSearch(int node)
+	void deepFirstSearch(int node)
-    {
+	{
-        visited[node] = Status::SEARCHING;
+		visited[node] = STATUS::IN_SEARCHING;
-        for (int neighbor : edges[node]) {
+		for (int neighbor : edges[node]) {
-            if (visited[neighbor] == Status::UNVISITED) {
+			if (visited[neighbor] == STATUS::UN_VISITED) {
-                deepFirstSearch(neighbor);
+				deepFirstSearch(neighbor);
-                if (find_cycle) {
+				if (find_cycle) {
-                    return;  // unsolvable
+					return;  // unsolvable
-                }
+				}
-            }
+			}
-            else if (visited[neighbor] == Status::SEARCHING) {
+			else if (visited[neighbor] == STATUS::IN_SEARCHING) {
-                find_cycle = true;
+				find_cycle = true;
-                return;
+				return;
-            }
+			}
-        }
+		}
-        visited[node] = Status::FINISH;
+		visited[node] = STATUS::FINISHED;
-        sequence.push_back(node);
+		sequence.push_back(node);
-    }
+	}
 
 public:
-    /**
+	/**
-     * @brief       topological sequence
+	 * @brief       topological sequence
-     * @param[in]	number of nodes
+	 * @param[in]	number of nodes
-     * @param[in]   node connection
+	 * @param[in]   node connection
-     * @retval		sequence
+	 * @retval		sequence
-     */
+	 */
-    vector<int> findTopologicalOrder(int numNodes, vector<vector<int>>& linkage)
+	vector<int> findTopologicalOrder(int numNodes, vector<vector<int>>& linkage)
-    {
+	{
-        edges.resize(numNodes);
+		edges.resize(numNodes);
-        visited.resize(numNodes, Status::UNVISITED);
+		visited.resize(numNodes, STATUS::UN_VISITED);
 
-        // generate adjacency list
+		// generate adjacency list
-        for (const auto& info : linkage) {
+		for (const auto& info : linkage) {
-            edges[info[1]].push_back(info[0]);
+			edges[info[1]].push_back(info[0]);
-        }
+		}
 
-        //  deep first search to determine the topological sequence
+		//  deep first search to determine the topological sequence
-        for (int i = 0; i < numNodes && !find_cycle; ++i) {
+		for (int i = 0; i < numNodes && !find_cycle; ++i) {
-            if (visited[i] == Status::UNVISITED) {
+			if (visited[i] == STATUS::UN_VISITED) {
-                deepFirstSearch(i);
+				deepFirstSearch(i);
-            }
+			}
-        }
+		}
 
-        if (find_cycle) {
+		if (find_cycle) {
-            return vector<int>();   //  unsolvable for cycle
+			return vector<int>();   //  unsolvable for cycle
-        }
+		}
 
-        reverse(sequence.begin(), sequence.end());
+		reverse(sequence.begin(), sequence.end());
-        return sequence;
+		return sequence;
-    }
+	}
 };