further development and bug fixing on the tree

Author: tiberius

cpp4j/cpp4j.pro

@@ -1,24 +1,27 @@
+######################################################################
+# Automatically generated by qmake (2.01a) Tue Jun 12 15:45:01 2012
+######################################################################
+
 TEMPLATE = app
-CONFIG += console
-CONFIG -= qt
+TARGET = 
+DEPENDPATH += .
+INCLUDEPATH += .
 
+# Input
+HEADERS += greater.h \
+           less.h \
+           maptofirst.h \
+           pair.h \
+           rationalnumber.h \
+           rationalnumberarray.h \
+           tree.h \
+           treeiterator.h \
+           treenode.h
 SOURCES += rationalnumber.cpp \
-    rationalnumberarray.cpp \
+           rationalnumberarray.cpp \
+           testMain.cpp \
+    testTemplates.cpp \
     testRNA.cpp \
-    testCPP_RN.cpp \
     testRN.cpp \
-    testMain.cpp \
     testCPP_RNA.cpp \
-    testTemplates.cpp
-
-HEADERS += \
-    rationalnumber.h \
-    rationalnumberarray.h \
-    pair.h \
-    less.h \
-    greater.h \
-    maptofirst.h \
-    tree.h \
-    treenode.h \
-    treeiterator.h
-
+    testCPP_RN.cpp

cpp4j/testTemplates.cpp

@@ -113,9 +113,6 @@ int testTemplates(void)
     cout << "tree 4-3-2-1-5: ";
     assert(printAndCount(t) == 5);
 
-
-#if 0 // move this line down while your implementation proceeds...
-
     // test clear()
     t.clear();
     cout << "after clear(): ";
@@ -141,6 +138,8 @@ int testTemplates(void)
     cout << "6-element tree: ";
     assert(printAndCount(t) == 6);
 
+#if 0 // move this line down while your implementation proceeds...
+
     // now we contruct a tree with a "reverse" order
     typedef Tree< float, Greater<float> > RevFloatTree;
     RevFloatTree ft;

cpp4j/tree.h

@@ -26,19 +26,16 @@ template <class T, template<typename> class Order = Less > class Tree {
         }
     }
 
-    //void clear();
-    iterator begin() {
-        if (m_root == NULL)
-            return iterator(NULL, this);
+    void clear() {
+        m_root = NULL;
+    }
 
-        return iterator (m_root->findFirst(), this);
+    iterator begin() {
+        return iterator (m_root, this);
     }
 
     iterator end() {
-        if (m_root == NULL)
-            return iterator(NULL, this);
-
-        return iterator (m_root->findLast(), this);
+        return iterator (NULL, this);
     }
 
     /*iterator first();
@@ -69,7 +66,7 @@ template <class T, template<typename> class Order = Less > class Tree {
             if (next.m_node == NULL) {
                 next.m_node = new node(value);
                 next.m_node->m_up = i.m_node;
-                i.m_node->m_left = next.m_node;
+                i.m_node->m_right = next.m_node;
                 return next;
 
             } else

cpp4j/treeiterator.h

@@ -19,61 +19,35 @@ template <class T, template<typename> class Order > class TreeIterator {
         return m_node->value();
     }
 
-    // zum naechsten Element
+    // zum vorherigen Element
     TreeIterator<T, Order>& operator++() {
-        // erst rechts prüfen, ob vorhanden
-        // ansonsten solange nach oben, bis größerer gefunden
-        if (m_node->m_right != NULL) {
-            m_node = m_node->m_right;
+        if (m_node == NULL)
             return *this;
-        }
-
-        TreeNode<T, Order> * parent = m_node;
-
-        Order<T> functor;
-        do {
-
-            parent = parent->m_up;
-
-            // keep position
-            if (parent == NULL)
-                return *this;
 
+        if (m_node->m_left == NULL) {
+            TreeNode<T, Order> * parent = m_node;
+            while (parent != NULL && parent->m_right == NULL)
+                parent = parent->m_up;
 
-        } while (functor(m_node->m_value, parent->m_value));
+            if (m_node == parent->m_right || m_node->m_up == parent->m_right)
+                m_node = NULL;
+            else
+                m_node = parent->m_right;
+            return *this;
+        }
 
-        m_node = parent;
+        m_node = m_node->m_left;
         return *this;
     }
 
-    // zum vorherigen Element
+    // zum naechsten Element
     TreeIterator<T, Order>& operator--() {
-        if (m_node->m_left != NULL) {
-            TreeNode<T, Order> node = m_node.m_left;
-            while (node->m_right != NULL)
-                node = node->m_right;
-
-            m_node = node;
-        } else if (m_node->m_up != NULL) {
-            TreeNode<T, Order> * parent = m_node;
-
-            Order<T> functor;
-            do {
-                parent = parent->m_up;
-                // keep position
-                if (parent == NULL)
-                    return *this;
-
-            } while (functor(m_node->m_value, parent->m_value));
+    }
 
-            m_node=parent;
-        }
 
-        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;
     }
 
     bool operator!=(const TreeIterator<T, Order> &rhs) const {