created documentation for BST.

examples/tree/avl.cc

@@ -25,7 +25,7 @@ int main() {
     std::cout << x << " ";
   }
   std::cout << '\n';
-  
+
   // you can now visualize with Algo+
   avl_tree<int> b2;
   b2.insert(10);
@@ -35,4 +35,14 @@ int main() {
   b2.insert(-8);
 
   b2.visualize();
+
+  avl_tree<int> testing_avl;
+  testing_avl.insert(10);
+  testing_avl.visualize();
+  testing_avl.insert(5);
+  testing_avl.visualize();
+  testing_avl.insert(-5);
+  testing_avl.visualize();
+  testing_avl.insert(2);
+  testing_avl.visualize();
 }

examples/unnamed.dot

@@ -0,0 +1,5 @@
+digraph Tree {
+5->-5
+-5->2
+5->10
+}

src/classes/tree/avl_tree.h

@@ -1,6 +1,7 @@
 #ifdef __cplusplus
 #include "../../visualization/tree_visual/tree_visualization.h"
 #include <functional>
+#include <queue>
 #include <string>
 #include <vector>
 #endif
@@ -30,6 +31,15 @@ template <typename T> class avl_tree {
    */
   void insert(T key) { root = __insert(root, key); }
 
+  /*
+   *clear function
+   *Erase all the nodes from the tree.
+   */
+  void clear() {
+    free(root);
+    return;
+  }
+
   /*
    *search function.
    *@param key: key to be searched.
@@ -186,6 +196,7 @@ template <typename T> class avl_tree {
     }
     return root;
   }
+
   bool __search(node *root, T key) {
     while (root) {
       if (root->info < key) {

src/classes/tree/bst.h

@@ -44,36 +44,6 @@ template <typename T> class bst {
    */
   void remove(T key) { root = __remove(root, key); }
 
-  /*
-   *level order function.
-   *Returns vector<vector<T>>, the level order of the Tree.
-   */
-  std::vector<std::vector<T>> level_order() {
-    std::vector<std::vector<T>> levels;
-    if (!root) {
-      return levels;
-    }
-    std::queue<T> q;
-    q.push(root);
-    while (!q.empty()) {
-      int64_t size = q.size();
-      std::vector<T> row;
-      for (int64_t i = 0; i < size; i++) {
-        T current = q.front();
-        row.push_back(current);
-        q.pop();
-        if (current->right) {
-          q.push(current->right);
-        }
-        if (current->left) {
-          q.push(current->left);
-        }
-      }
-      levels.push_back(row);
-    }
-    return levels;
-  }
-
   /*
    *inorder function.
    *Returns vector<T>, the elements inorder.

tests/tree/avl.cc

@@ -76,4 +76,4 @@ TEST_CASE("checking postorder") {
   a.insert(2);
   std::vector<int> __postorder = {-5, 2, 10, 5};
   REQUIRE(a.postorder() == __postorder);
-}
+}

tests/tree/bst.cc

@@ -84,4 +84,4 @@ TEST_CASE("checking postorder") {
   b.insert('w');
   std::vector<char> post = {'a', 'b', 'w', 'g'};
   REQUIRE(b.postorder() == post);
-}
+}

tutorial/bst.md

@@ -0,0 +1,128 @@
+### Mini Tutorial for the BST class
+
+    bst<T> -- creates an avl tree.
+
+avl tree contains:
+    - insert
+    - remove
+    - search
+    - inorder
+    - preorder
+    - postorder
+    - visualize
+
+### **insert**:
+```cpp
+#include <algoplus/bst>
+
+bst<int> b;
+b.insert(10);
+b.insert(5);
+b.insert(4);
+b.insert(13);
+//creates a tree with elements {4,5,10,13};
+```
+
+### **remove**:
+```cpp
+#include <algoplus/bst>
+
+bst<int> b;
+b.insert(10);
+b.insert(5);
+b.insert(4);
+b.insert(13);
+b.remove(4);
+//removes the element 4 from the tree.
+```
+
+### **remove**:
+```cpp
+#include <algoplus/bst>
+
+bst<int> b;
+b.insert(10);
+b.insert(5);
+b.insert(4);
+b.insert(13);
+b.remove(4);
+//removes the element 4 from the tree.
+```
+
+### **search**:
+```cpp
+#include <algoplus/bst>
+
+bst<int> b;
+b.insert(10);
+b.insert(5);
+b.insert(4);
+b.insert(13);
+b.remove(4);
+
+//returns true if an element is in the tree.
+if(b.search(4)){
+    std::cout<< "element 4 found in the tree" << '\n';
+}
+```
+
+### **inorder**:
+```cpp
+#include <algoplus/bst>
+
+bst<int> b;
+b.insert(10);
+b.insert(5);
+b.insert(4);
+b.insert(13);
+b.remove(4);
+
+//returns the elements in inorder fashion.
+std::vector<int> in = b.inorder();
+```
+
+### **preorder**:
+```cpp
+#include <algoplus/bst>
+
+bst<int> b;
+b.insert(10);
+b.insert(5);
+b.insert(4);
+b.insert(13);
+b.remove(4);
+
+//returns the elements in preorder fashion.
+std::vector<int> pre = b.preorder();
+```
+
+### **postorder**:
+```cpp
+#include <algoplus/bst>
+
+bst<int> b;
+b.insert(10);
+b.insert(5);
+b.insert(4);
+b.insert(13);
+b.remove(4);
+
+//returns the elements in postorder fashion.
+std::vector<int> in = a.postorder();
+```
+
+### **visualize**:
+```cpp
+#include <algoplus/bst>
+
+bst<int> b;
+b.insert(10);
+b.insert(5);
+b.insert(4);
+b.insert(13);
+b.remove(4);
+
+//returns a .dot file that can easily be previewed using
+//vscode plugin for graphviz or local command line tools.
+b.visualize();
+```