Add iterative version of binary tree traversal and enum to switch algo

libs/dope/bintree.hpp

@@ -1,6 +1,12 @@
 #pragma once
 
 #include <queue>
+#include <stack>
+
+typedef enum AlgoVariant_E{
+  Recursive,
+  Iter,
+}AlgoVariant;
 
 template <class T>
 class DopeBinTreeNode{
@@ -23,6 +29,9 @@ class DopeBinTree{
   T* RecPreOrderTraversal(DopeBinTreeNode<T>* node, T* out);
   T* RecInOrderTraversal(DopeBinTreeNode<T>* node, T* out);
   T* RecPostOrderTraversal(DopeBinTreeNode<T>* node, T* out);
+  void IterPreOrderTraversal(DopeBinTreeNode<T>* node, T* out);
+  void IterInOrderTraversal(DopeBinTreeNode<T>* node, T* out);
+  void IterPostOrderTraversal(DopeBinTreeNode<T>* node, T* out);
 public:
   DopeBinTree(T data);
   DopeBinTree();
@@ -30,9 +39,9 @@ public:
   void insert(T data);
   bool isEmpty();
   DopeBinTreeNode<T>* getRoot(){return root;}
-  void RecPreOrderTraversalArray(T* array);
-  void RecInOrderTraversalArray(T* array);
-  void RecPostOrderTraversalArray(T* array);
+  void PreOrderTraversal2Array(T* array, AlgoVariant variant);
+  void InOrderTraversal2Array(T* array, AlgoVariant variant);
+  void PostOrderTraversal2Array(T* array, AlgoVariant variant);
 };
 
 // Implementations ___________________________________________________
@@ -147,26 +156,145 @@ T* DopeBinTree<T>::RecPostOrderTraversal(DopeBinTreeNode<T>* node, T* out){
 }
 
 template <class T>
-void DopeBinTree<T>::RecPreOrderTraversalArray(T* array){
-  int index = 0;
-  DopeBinTreeNode<T>* node = root;
+void DopeBinTree<T>::IterPreOrderTraversal(DopeBinTreeNode<T>* node, T* out){
+  std::stack<DopeBinTreeNode<T>*> s = {};
+  s.push(node);
 
-  RecPreOrderTraversal(node, &array[index]);
+  while(s.empty() == false){
+    node = s.top();
+    s.pop();
+    *out = node->GetData();
+    out++;
+    if(node->GetRight()){
+      s.push(node->GetRight());
+    }
+    if(node->GetLeft()){
+      s.push(node->GetLeft());
+    }
+  }
+}
+
+template <class T>
+void DopeBinTree<T>::IterInOrderTraversal(DopeBinTreeNode<T>* node, T* out){
+  std::stack<DopeBinTreeNode<T>*> s = {};
+
+  while (!s.empty() || node){
+    while(node != nullptr){
+      s.push(node);
+      node = node->GetLeft();
+    }
+    node = s.top();
+    s.pop();
+    *out = node->GetData();
+    out++;
+    node = node->GetRight();
+  }
 
 }
 
 template <class T>
-void DopeBinTree<T>::RecInOrderTraversalArray(T* array){
-  int index = 0;
-  DopeBinTreeNode<T>* node = root;
+void DopeBinTree<T>::IterPostOrderTraversal(DopeBinTreeNode<T>* node, T* out){
+  std::stack<DopeBinTreeNode<T>*> s_tmp = {};
+  std::stack<DopeBinTreeNode<T>*> s_fin = {};
 
-  RecInOrderTraversal(node, &array[index]);
+  s_tmp.push(node);
+  while(!s_tmp.empty()){
+    node = s_tmp.top();
+    s_tmp.pop();
+    s_fin.push(node);
+
+    if(node->GetLeft()){
+      s_tmp.push(node->GetLeft());
+    }
+    if(node->GetRight()){
+      s_tmp.push(node->GetRight());
+    }
+  }
+
+  while(!s_fin.empty()){
+    node = s_fin.top();
+    s_fin.pop();
+    *out = node->GetData();
+    out++;
+  }
 }
 
+/**
+ *  \brief PreOrderTraversal2Array
+ *
+ *  Binary tree traversal that visits the root node, then the left
+ *  sub-tree, and then the right-subtree.
+ *
+ *  \param The output array
+ *  \param The algorithm variant
+ *  \return return type
+ */
 template <class T>
-void DopeBinTree<T>::RecPostOrderTraversalArray(T* array){
+void DopeBinTree<T>::PreOrderTraversal2Array(T* array, AlgoVariant variant){
+  int index = 0;
+  DopeBinTreeNode<T>* node = root;
+  switch(variant){
+  case AlgoVariant::Recursive:
+    RecPreOrderTraversal(node, &array[index]);
+    return;
+  case AlgoVariant::Iter:
+    IterPreOrderTraversal(node, &array[index]);
+    return;
+  default:
+    return;
+  }
+}
+
+/**
+ *  \brief InOrderTraversal2Array
+ *
+ *  Binary tree traversal that traverses the left sub-tree, then
+ *  visits the root node, then the right-subtree.
+ *
+ *  \param The output array
+ *  \param The algorithm variant
+ *  \return return type
+ */
+template <class T>
+void DopeBinTree<T>::InOrderTraversal2Array(T* array, AlgoVariant variant){
+  int index = 0;
+  DopeBinTreeNode<T>* node = root;
+  switch(variant){
+  case AlgoVariant::Recursive:
+    RecInOrderTraversal(node, &array[index]);
+    return;
+  case AlgoVariant::Iter:
+    IterInOrderTraversal(node, &array[index]);
+    return;
+  default:
+    return;
+  }
+}
+
+
+/**
+ *  \brief PostOrderTraversal2Array
+ *
+ *  Binary tree traversal that visits left-subtree, right subtree, and
+ *  then the root node.
+ *
+ *  \param The output array
+ *  \param The algorithm variant
+ *  \return return type
+ */
+template <class T>
+void DopeBinTree<T>::PostOrderTraversal2Array(T* array, AlgoVariant variant){
   int index = 0;
   DopeBinTreeNode<T>* node = root;
 
-  RecPostOrderTraversal(node, &array[index]);
+  switch(variant){
+  case AlgoVariant::Recursive:
+    RecPostOrderTraversal(node, &array[index]);
+    return;
+  case AlgoVariant::Iter:
+    IterPostOrderTraversal(node, &array[index]);
+    return;
+  default:
+    return;
+  }
 }