Fix bug in Eulerian path algorithm (#314)

* Fix choice of starting node in eulerian path algorithm

* Add test of eulerian path for undirected graph

* Rewrite choice of next node in eulerian path algorithm

Author: sbaldu

include/Edge/Edge.hpp

@@ -46,6 +46,7 @@ class Edge {
   virtual ~Edge() = default;
   const unsigned long long &getId() const;
   const std::pair<const Node<T> *, const Node<T> *> &getNodePair() const;
+  const Node<T> *getOtherNode(const Node<T> *node) const;
   virtual const std::optional<bool> isDirected() const;
   virtual const std::optional<bool> isWeighted() const;
   // operator
@@ -83,6 +84,15 @@ const std::pair<const Node<T> *, const Node<T> *> &Edge<T>::getNodePair()
   return nodePair;
 }
 
+template <typename T>
+const Node<T> *Edge<T>::getOtherNode(const Node<T> *node) const {
+  if (this->getNodePair().first == node) {
+    return this->getNodePair().second;
+  } else {
+    return this->getNodePair().first;
+  }
+}
+
 template <typename T>
 const std::optional<bool> Edge<T>::isDirected() const {
   return std::nullopt;
@@ -112,4 +122,4 @@ std::ostream &operator<<(std::ostream &os, const Edge<T> &edge) {
 }
 }  // namespace CXXGraph
 
-#endif  // __CXXGRAPH_EDGE_H__
+#endif  // __CXXGRAPH_EDGE_H__

include/Edge/UndirectedEdge.hpp

@@ -99,4 +99,4 @@ std::ostream &operator<<(std::ostream &os, const UndirectedEdge<T> &edge) {
 }
 }  // namespace CXXGraph
 
-#endif  // __CXXGRAPH_UNDIRECTEDEDGE_H__
+#endif  // __CXXGRAPH_UNDIRECTEDEDGE_H__

include/Graph/Graph.hpp

@@ -1150,18 +1150,32 @@ template <typename T>
 std::shared_ptr<std::vector<Node<T>>> Graph<T>::eulerianPath() const {
   const auto nodeSet = Graph<T>::getNodeSet();
   const auto adj = Graph<T>::getAdjMatrix();
+
   std::shared_ptr<std::vector<Node<T>>> eulerPath =
       std::make_shared<std::vector<Node<T>>>();
+
+  bool undirected = this->isUndirectedGraph();
+
   std::vector<const Node<T> *> currentPath;
-  auto currentNode = *(nodeSet.begin());
+  // The starting node is the only node which has more outgoing than ingoing
+  // links
+  auto firstNodeIt =
+      std::max_element(nodeSet.begin(), nodeSet.end(), [adj](auto n1, auto n2) {
+        return adj->at(n1).size() < adj->at(n2).size();
+      });
+  auto currentNode = *(firstNodeIt);
   currentPath.push_back(currentNode);
+
   while (currentPath.size() > 0) {
     auto &edges = adj->at(currentNode);
     // we keep removing the edges that
     // have been traversed from the adjacency list
     if (edges.size()) {
       auto firstEdge = edges.back().second;
-      auto nextNodeId = firstEdge->getNodePair().second;
+
+      const Node<T> *nextNodeId;
+      nextNodeId = firstEdge->getOtherNode(currentNode);
+
       currentPath.push_back(nextNodeId);
       currentNode = nextNodeId;
       edges.pop_back();

test/EulerPathTest.cpp

@@ -104,4 +104,41 @@ TEST(EulerPathTest, test_3) {
 
     ASSERT_FALSE(check);
   }
-}
+}
+
+TEST(EulerPathTest, test_4) {
+  CXXGraph::Node<int> node_a("a", 0);
+  CXXGraph::Node<int> node_b("b", 1);
+  CXXGraph::Node<int> node_c("c", 2);
+  CXXGraph::Node<int> node_d("d", 3);
+  CXXGraph::Node<int> node_e("e", 4);
+  CXXGraph::Node<int> node_f("f", 5);
+
+  CXXGraph::UndirectedEdge<int> edge1(1, node_a, node_b);
+  CXXGraph::UndirectedEdge<int> edge2(2, node_b, node_e);
+  CXXGraph::UndirectedEdge<int> edge3(3, node_e, node_f);
+  CXXGraph::UndirectedEdge<int> edge4(4, node_f, node_a);
+  CXXGraph::UndirectedEdge<int> edge5(5, node_b, node_c);
+  CXXGraph::UndirectedEdge<int> edge6(6, node_b, node_d);
+  CXXGraph::UndirectedEdge<int> edge7(7, node_c, node_d);
+
+  CXXGraph::T_EdgeSet<int> edgeSet;
+  edgeSet.insert(&edge1);
+  edgeSet.insert(&edge2);
+  edgeSet.insert(&edge3);
+  edgeSet.insert(&edge4);
+  edgeSet.insert(&edge5);
+  edgeSet.insert(&edge6);
+  edgeSet.insert(&edge7);
+
+  CXXGraph::Graph<int> graph(edgeSet);
+  auto res = graph.eulerianPath();
+  auto nodeSet = graph.getNodeSet();
+  for (const auto& node : nodeSet) {
+    auto check = std::find_if(res->begin(), res->end(), [node](auto it) {
+                   return (node->getUserId() == it.getUserId());
+                 }) == res->end();
+
+    ASSERT_FALSE(check);
+  }
+}