added prim algo for graph

AVL tree needs change to shared_ptr in order to generate the iterator. Every data structure need to be converted to smart pointers.

.vscode/settings.json

@@ -58,6 +58,14 @@
     "stack": "cpp",
     "unordered_set": "cpp",
     "__errc": "cpp",
-    "__mutex_base": "cpp"
+    "__mutex_base": "cpp",
+    "__tree": "cpp",
+    "fstream": "cpp",
+    "future": "cpp",
+    "iomanip": "cpp",
+    "map": "cpp",
+    "regex": "cpp",
+    "set": "cpp",
+    "thread": "cpp"
   }
 }

examples/tree/avl.cc

@@ -25,4 +25,8 @@ int main() {
     std::cout << x << " ";
   }
   std::cout << '\n';
+
+  avl_tree<int> b1({5, 9, -5, 3});
+  std::cout << "iterators for avl trees" << '\n';
+  std::cout << b << '\n';
 }

src/classes/graph/graph.h

@@ -244,6 +244,8 @@ template <typename T> class weighted_graph {
 
   std::vector<T> topological_sort();
 
+  int64_t prim(T start);
+
 private:
   std::unordered_map<T, std::vector<std::pair<T, int64_t>>> adj;
   std::string __type;
@@ -260,7 +262,7 @@ template <typename T> int64_t weighted_graph<T>::shortest_path(T start, T end) {
     return -1;
   }
 
-  if (!cycle()) {
+  if (!cycle() && __type == "directed") {
     std::vector<T> top_sort = topological_sort();
     std::reverse(top_sort.begin(), top_sort.end());
     std::stack<T> s;
@@ -447,4 +449,30 @@ template <typename T> std::vector<T> weighted_graph<T>::topological_sort() {
 
   return top_sort;
 }
+
+template <typename T> int64_t weighted_graph<T>::prim(T __temp) {
+  std::priority_queue<std::pair<T, int64_t>, std::vector<std::pair<T, int64_t>>,
+                      std::greater<std::pair<T, int64_t>>>
+      q;
+  std::unordered_map<T, bool> visited;
+  int64_t cost = 0;
+  q.push(std::make_pair(0, __temp));
+  while (!q.empty()) {
+    std::pair<T, int64_t> current = q.top();
+    q.pop();
+    __temp = current.first;
+    if (visited.find(__temp) != visited.end()) {
+      continue;
+    }
+    cost += current.second;
+    visited[__temp] = true;
+    for (std::pair<T, int64_t> &x : adj[current.first]) {
+      if (visited.find(x.first) == visited.end()) {
+        q.push(x);
+      }
+    }
+  }
+  return cost;
+}
+
 #endif

src/classes/tree/avl_tree.h

@@ -1,4 +1,5 @@
 #ifdef __cplusplus
+#include "../../plotting/iterator/avl_tree_iterator.h"
 #include <functional>
 #include <vector>
 #endif
@@ -14,6 +15,10 @@ template <typename T> class avl_tree {
   }
   ~avl_tree() noexcept {}
 
+  avl_iter<T> begin() { return avl_iter<T>(root); }
+
+  avl_iter<T> end() { return avl_iter<T>(nullptr); }
+
   void insert(T key) { root = __insert(root, key); }
 
   void remove(T key) { root = __remove(root, key); }
@@ -39,6 +44,17 @@ template <typename T> class avl_tree {
     return path;
   }
 
+  friend std::ostream &operator<<(std::ostream &out, avl_tree<T> &t1) {
+    out << '{';
+    avl_iter<T> it = t1.begin();
+    it++;
+    for (; it != t1.end(); it++) {
+      out << *it << ' ';
+    }
+    out << '}' << '\n';
+    return out;
+  }
+
 private:
   typedef struct node {
     T info;

src/plotting/iterator/avl_tree_iterator.h

@@ -0,0 +1,55 @@
+#ifdef __cplusplus
+#include <iostream>
+#include <vector>
+#endif
+
+template <typename T> class avl_iter {
+public:
+  avl_iter() noexcept {
+    __elements = _get_inorder(root);
+    index = 0;
+  }
+  avl_iter(const node *p) noexcept : root(p) {}
+  ~avl_iter();
+
+  avl_iter &operator++() {
+    if (index >= 0 && index < __elements.size()) {
+      index++;
+    }
+    return *this;
+  }
+
+  avl_iter operator++(int) {
+    avl_iter it = *this;
+    ++*this;
+    return it;
+  }
+
+  bool operator!=(const avl_iter &it) { return root != it.root; }
+  T operator*() { return __elements[index]; }
+
+private:
+  typedef struct node {
+    T info;
+    int64_t height;
+    struct node *left;
+    struct node *right;
+  } node;
+  node *root;
+  std::vector<T> __elements;
+  int64_t index;
+
+  std::vector<T> __get_inorder(node *root) {
+    std::vector<T> p;
+    __inorder(root, p);
+    return p;
+  }
+
+  void __inorder(node *root, std::vector<T> &p) {
+    if (root) {
+      __inorder(root->left, p);
+      p.push_back(root->info);
+      __inorder(root->right, p);
+    }
+  }
+};

tests/graph/weighted_graph.cc

@@ -60,4 +60,14 @@ TEST_CASE("testing shortest path in DAG") {
   g3.add_edge(1, 6, 1);
   g3.add_edge(3, 2, 4);
   REQUIRE(g3.shortest_path(0, 6) == 1);
+}
+
+TEST_CASE("testing mst with prim's algo") {
+  weighted_graph<int> g("directed");
+  g.add_edge(1, 2, 2);
+  g.add_edge(0, 1, 0);
+  g.add_edge(2, 6, 3);
+  g.add_edge(1, 6, 1);
+  g.add_edge(3, 2, 4);
+  REQUIRE(g.prim(0) == 3);
 }