incomplete tree implementation

Author: tiberius

cpp4j/cpp4j.pro

@@ -17,5 +17,8 @@ HEADERS += \
     pair.h \
     less.h \
     greater.h \
-    maptofirst.h
+    maptofirst.h \
+    tree.h \
+    treenode.h \
+    treeiterator.h
 

cpp4j/greater.h

@@ -10,7 +10,7 @@ public :
     bool operator ()(const T &left, const T &right){
         Less<T> less;
         bool lesser = less(left, right);
-        bool equal = !less(left, right) && !less(right,left);
+        bool equal = !less(left, right) && !less(right, left);
         return !lesser && !equal;
     }
 

cpp4j/testTemplates.cpp

@@ -18,7 +18,7 @@ using namespace std;
 #include "greater.h"
 #include "maptofirst.h"
 //#include "order.h"
-//#include "tree.h"
+#include "tree.h"
 //#include "map.h"
 
 // you should define your own namespace for
@@ -32,8 +32,6 @@ using namespace std;
 //template class Map<int, string>;
 
 // list and count all nodes in a set using an iterator
-/*
-
 template<class Container>
 int printAndCount(Container & c) {
 
@@ -60,8 +58,6 @@ int printAndCountBackwards(Container & c) {
     return n;
 }
 
-*/
-
 int testTemplates(void)
 {
 

cpp4j/tree.h

@@ -0,0 +1,12 @@
+#ifndef TREE_H
+#define TREE_H
+
+#include "less.h"
+
+template <class T, template<typename> class Order = Less > class Tree {
+
+    TreeNode<T, Order> m_root;
+
+};
+
+#endif // TREE_H

cpp4j/treeiterator.h

@@ -0,0 +1,55 @@
+#ifndef TREEITERATOR_H
+#define TREEITERATOR_H
+
+#include "treenode.h"
+
+template <class T, template<typename> class Order > class TreeIterator {
+
+    friend class TreeNode<T, Order>;
+
+public:
+
+    TreeIterator(TreeNode<T, Order> node) : m_node(node) {}
+
+    T& operator*() {
+        return m_node->m_value;
+    }
+
+    T* operator->() {
+        return (T*)(m_node->m_value&);
+    }
+
+    TreeIterator<T, Order>& operator++() {
+        // erst rechts prüfen, ob vorhanden
+        // ansonsten solange nach oben, bis größerer gefunden
+        if (m_node->m_right != NULL)
+            return TreeIterator(m_right);
+
+        TreeNode<T, Order> parent = m_node->m_up;
+
+        Order<T> functor;
+        while (functor(m_node->m_value, parent->value)) {
+            parent = parent->m_up;
+        }
+
+        m_node = parent;
+        return *this;
+    }
+
+    TreeIterator<T, Order>& operator--() {
+
+    }
+
+    bool operator==(const TreeIterator<T, Order> &rhs);
+    bool operator!=(const TreeIterator<T, Order> &rhs);
+
+
+private:
+
+    TreeNode<T, O> m_node;
+
+};
+
+
+
+#endif // TREEITERATOR_H

cpp4j/treenode.h

@@ -0,0 +1,50 @@
+#ifndef TREENODE_H
+#define TREENODE_H
+
+template <class T, template<typename> class Order > class TreeNode {
+
+public:
+
+    T& value(void) {
+        return m_value;
+    }
+
+    TreeNode<T, Order>* find(const T& value) {
+        Order<T> order; //less<int>
+        if (order(m_value, value))
+            return m_left->find(value);
+
+        if (order(value, m_value))
+            return m_right->find(value);
+
+        if (m_value == value)
+            return this;
+
+        return NULL;
+
+    }
+
+    TreeNode<T, Order>* findFirst(void) {
+        if (m_left != NULL)
+            return m_left->findFirst();
+
+        return this;
+    }
+
+    TreeNode<T, Order>* findLast(void) {
+        if (m_right != NULL)
+            return m_right->findLast();
+
+        return this;
+    }
+
+protected:
+
+    T m_value;
+    TreeNode<T, Order>* m_up;
+    TreeNode<T, Order>* m_left;
+    TreeNode<T, Order>* m_right;
+
+};
+
+#endif // TREENODE_H