still not working

tiberius · tiberius · commit b483dc5251aa · 2012-06-14T19:49:36.000+02:00
diff --git a/cpp4j/maptofirst.h b/cpp4j/maptofirst.h
@@ -4,7 +4,7 @@
 #include "pair.h"
 
 //        int       string    less
-template <class T1, class T2, template<typename> class Order > class MapToFirst {
+template <class T1, class T2, template<class> class Order > class MapToFirst {
 
 public:
 
diff --git a/cpp4j/testTemplates.cpp b/cpp4j/testTemplates.cpp
@@ -96,13 +96,10 @@ int testTemplates(void)
     /////////////////////////////////////////
     // TEST TREE
 
-
-
     // construct empty tree
     Tree<int> t;
     cout << "empty tree: ";
     assert(printAndCount(t) == 0);
-    cout.flush();
 
     // insert elements in a certain order
     t.insert(4);
@@ -138,10 +135,18 @@ int testTemplates(void)
     cout << "6-element tree: ";
     assert(printAndCount(t) == 6);
 
-#if 0 // move this line down while your implementation proceeds...
+    // and yet another insertion sequence (compined from the above)
+    t.clear();
+    t.insert(8); t.insert(4); t.insert(3); t.insert(2); t.insert(1);
+    t.insert(5); t.insert(1); t.insert(2); t.insert(3); t.insert(5);
+    t.insert(4); t.insert(45); t.insert(4); t.insert(89); t.insert(9);
+    t.insert(7); t.insert(3);
+    cout << "10-element tree: ";
+    assert(printAndCount(t) == 10);
 
     // now we contruct a tree with a "reverse" order
-    typedef Tree< float, Greater<float> > RevFloatTree;
+    //typedef Tree< float, Greater<float> > RevFloatTree; // had to replace this line by the following
+    typedef Tree< float, Greater > RevFloatTree;
     RevFloatTree ft;
     ft.insert(3.1);
     ft.insert(6.2);
@@ -155,6 +160,7 @@ int testTemplates(void)
     cout << "listing backwards: ";
     assert(printAndCountBackwards(ft) == 4);
 
+#if 0 // move this line down while your implementation proceeds...
 
     /////////////////////////////////////////
     // TEST MAP
diff --git a/cpp4j/tree.h b/cpp4j/tree.h
@@ -5,52 +5,77 @@
 #include "treeiterator.h"
 #include "treenode.h"
 
-template <class T, template<typename> class Order = Less > class Tree {
+template <class T, template<class> class Order = Less > class Tree {
 
 public:
 
-    Tree():m_root(NULL) {}
+    Tree():m_root(NULL),m_last(NULL) {}
 
     typedef TreeIterator<T,Order> iterator;
     typedef TreeNode<T,Order> node;
 
     iterator insert(const T& value) {
-        if (m_root == NULL) {
+
+        if (m_root == NULL && m_last == NULL) {
             m_root = new node(value);
-            return iterator(m_root, this);
+            reset_last();
+            return iterator(m_root, this, iterator::begin);
 
         } else {
-            iterator i (m_root, this);
-            return insert_internal (i, value);
+            const iterator i (m_root, this, iterator::begin);
+            iterator result = insert_internal (i, value);
+            reset_last();
+            return result;
 
         }
     }
 
     void clear() {
-        m_root = NULL;
+        // leaky-leaky
+        m_last = m_root = NULL;
     }
 
-    iterator begin() {
-        return iterator (m_root, this);
+    const iterator begin() const {
+        return iterator (m_root, this, m_root == NULL ? iterator::end : iterator::begin);
     }
 
-    iterator end() {
-        return iterator (NULL, this);
+    const iterator end() const {
+        return iterator (m_last, this, iterator::end);
     }
 
     /*iterator first();
     iterator last();
     iterator find(const T& value);*/
 
 
-private:
+protected:
     TreeNode<T, Order> * m_root;
+    TreeNode<T, Order> * m_last;
+
+    void reset_last(void) {
+        TreeNode<T, Order> * t = m_root;
+        while (t != NULL) {
+
+            if (t->m_right == NULL) {
+                if (t->m_left == NULL) {
+                    break;
+
+                } else {
+                    t = t->m_left;
+                }
+
+            } else {
+                t = t->m_right;
+            }
+        }
+        m_last = t;
+    }
 
     iterator insert_internal(iterator i, const T& value) {
         Order<T> order;
 
         if (order(value, i.m_node->m_value)) { // links
-            iterator prev = iterator (i.m_node->m_left, this);
+            iterator prev = iterator (i.m_node->m_left, this, iterator::middle);
             if (prev.m_node == NULL) {
                 prev.m_node = new node(value);
                 prev.m_node->m_up = i.m_node;
@@ -62,7 +87,7 @@ template <class T, template<typename> class Order = Less > class Tree {
 
 
         } else if (order(i.m_node->m_value, value)) { // rechts
-            iterator next = iterator (i.m_node->m_right, this);
+            iterator next = iterator (i.m_node->m_right, this, iterator::middle);
             if (next.m_node == NULL) {
                 next.m_node = new node(value);
                 next.m_node->m_up = i.m_node;
@@ -82,4 +107,6 @@ template <class T, template<typename> class Order = Less > class Tree {
 
 };
 
+
+
 #endif // TREE_H
diff --git a/cpp4j/treeiterator.h b/cpp4j/treeiterator.h
@@ -19,66 +19,125 @@ template <class T, template<typename> class Order > class TreeIterator {
         return m_node->value();
     }
 
-    // zum vorherigen Element
+    // zum nächsten Element
     TreeIterator<T, Order>& operator++() {
-        cout << m_node->m_value << endl;
-
-        if (m_node == NULL)
+        if (m_node == NULL || m_mode == end) {
             return *this;
+        }
 
-        if (m_node->m_left == NULL) {
-            // nach rechts oder nach oben->rechts
+        m_mode = middle;
 
-            // parent von node
-            TreeNode<T, Order> * parent = m_node->m_up;
+        //
+        // Was kann sonst sein?
+        //
 
-            // laufe nach oben, wenn du links vom oberen bist
-            //if (parent->m_left == m_node) {
+        // versuche, nach links zu gehen
+        if (m_node->m_left != NULL) {
+            m_node = m_node->m_left;
+            return *this;
+        }
 
-                // laufe nach oben, weil du links vom oberen bist
-                parent = parent->m_up; // urelter
+        // wenn links nicht moeglich, versuche nach rechts zu gehen
+        if (m_node->m_right != NULL) {
+            m_node = m_node->m_right;
+            return *this;
+        }
 
-                //
-                while (parent != NULL && parent->m_up != NULL) {
-                    parent = parent->m_up;
+        // wenn rechts nicht moeglich, versuche so weit nach oben zu gehen, dass du einen neuen rechten Weg hast
+        TreeNode<T, Order> * child = m_node;
+        TreeNode<T, Order> * parent = child->m_up;
 
-                    if (parent->m_right != NULL) {
-                        break;
-                    }
-                }
+        while (parent != NULL) {
+
+            // sind wir das linke Kind des Elter?
+            if (child == parent->m_left) {
 
-                if (parent == NULL)
-                    m_node = NULL;
-                else
+                // haben wir Geschwister?
+                if (parent->m_right != NULL) {
+
+                    // naechster gefunden
                     m_node = parent->m_right;
-            //} else if (parent->m_right == m_node &&
+                    return *this;
+                }
+            }
 
-            // beende wenn du rechts von deinem oberen bist und unter dir nichts mehr ist
-            return *this;
+            // wir sind nicht das linke Kind (sondern das rechte)
+            child = parent;
+            parent = parent->m_up;
         }
 
-        // nach unten
-        m_node = m_node->m_left;
+        // wenn nichts moeglich ist, sind wir bereits am Ende
+        m_mode = end;
         return *this;
     }
 
-    // zum naechsten Element
+    // zum vorherigen Element
     TreeIterator<T, Order>& operator--() {
-    }
+        if (m_node == NULL || m_mode == begin) {
+            return *this;
+        }
+
+        m_mode = middle;
+
+        //
+        // Was kann sonst sein?
+        //
 
+        // wenn rechts nicht moeglich, versuche so weit nach oben zu gehen, dass du einen neuen rechten Weg hast
+        TreeNode<T, Order> * child = m_node;
+        TreeNode<T, Order> * parent = child->m_up;
 
+        while (parent != NULL) {
+
+            // sind wir das linke Kind des Elter?
+            if (child == parent->m_right) {
+
+                // haben wir Geschwister?
+                if (parent->m_left != NULL) {
+
+                    // naechster gefunden
+                    m_node = parent->m_left;
+                    return *this;
+                }
+            }
+
+            // wir sind nicht das linke Kind (sondern das rechte)
+            child = parent;
+            parent = parent->m_up;
+        }
+
+        // wenn links nicht moeglich, versuche nach rechts zu gehen
+        if (m_node->m_left != NULL) {
+            m_node = m_node->m_left;
+            return *this;
+        }
+
+        // versuche, nach links zu gehen
+        if (m_node->m_right != NULL) {
+            m_node = m_node->m_right;
+            return *this;
+        }
+
+        // wenn nichts moeglich ist, sind wir bereits am Ende
+        m_mode = begin;
+        return *this;
+    }
 
     bool operator==(const TreeIterator<T, Order> &rhs) const {
-        return this->m_node == rhs.m_node && this->m_tree == rhs.m_tree;
+        return this->m_node == rhs.m_node && this->m_tree == rhs.m_tree && this->m_mode == rhs.m_mode;
     }
 
     bool operator!=(const TreeIterator<T, Order> &rhs) const {
-        return this->m_node != rhs.m_node || this->m_tree != rhs.m_tree;
+        return !(this->m_node == rhs.m_node && this->m_tree == rhs.m_tree && this->m_mode == rhs.m_mode);
     }
 
 protected:
 
-    TreeIterator(TreeNode<T, Order> * node, const Tree<T, Order> * tree) : m_node(node), m_tree(tree) {}
+    enum iterator_mode { begin, middle, end };
+    iterator_mode m_mode;
+
+    TreeIterator(TreeNode<T, Order> * node, const Tree<T, Order> * tree, const iterator_mode mode)
+        : m_node(node), m_tree(tree), m_mode(mode) {}
 
 private:
 
@@ -87,6 +146,4 @@ template <class T, template<typename> class Order > class TreeIterator {
 
 };
 
-
-
 #endif // TREEITERATOR_H
