Skip to content

Commit 880149f

Browse files
author
tiberius
committed
forward-tree working now (++)
1 parent b483dc5 commit 880149f

File tree

3 files changed

+67
-120
lines changed

3 files changed

+67
-120
lines changed

‎cpp4j/testTemplates.cpp

Lines changed: 10 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -101,6 +101,14 @@ int testTemplates(void)
101101
cout << "empty tree: ";
102102
assert(printAndCount(t) == 0);
103103

104+
/* */t.insert(50);
105+
/* */t.insert(25);/* */t.insert(75);
106+
/**/t.insert(20);/* */t.insert(30);/* */t.insert(70);/* */t.insert(80);
107+
t.insert(17);t.insert(23);/**/t.insert(27);t.insert(33);/**/t.insert(67);t.insert(73);/**/t.insert(77);t.insert(83);
108+
cout << "tree 50-25-75-20-30-70-80-17-23-27-33-67-73-77-83: ";
109+
assert(printAndCount(t) == 15);
110+
t.clear();
111+
104112
// insert elements in a certain order
105113
t.insert(4);
106114
t.insert(3);
@@ -144,6 +152,8 @@ int testTemplates(void)
144152
cout << "10-element tree: ";
145153
assert(printAndCount(t) == 10);
146154

155+
#if 0 // move this line down while your implementation proceeds...
156+
147157
// now we contruct a tree with a "reverse" order
148158
//typedef Tree< float, Greater<float> > RevFloatTree; // had to replace this line by the following
149159
typedef Tree< float, Greater > RevFloatTree;
@@ -160,8 +170,6 @@ int testTemplates(void)
160170
cout << "listing backwards: ";
161171
assert(printAndCountBackwards(ft) == 4);
162172

163-
#if 0 // move this line down while your implementation proceeds...
164-
165173
/////////////////////////////////////////
166174
// TEST MAP
167175

‎cpp4j/tree.h

Lines changed: 27 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -9,38 +9,50 @@ template <class T, template<class> class Order = Less > class Tree {
99

1010
public:
1111

12-
Tree():m_root(NULL),m_last(NULL) {}
12+
Tree():m_root(NULL) {}
1313

1414
typedef TreeIterator<T,Order> iterator;
1515
typedef TreeNode<T,Order> node;
1616

1717
iterator insert(const T& value) {
1818

19-
if (m_root == NULL && m_last == NULL) {
19+
if (m_root == NULL) {
2020
m_root = new node(value);
21-
reset_last();
22-
return iterator(m_root, this, iterator::begin);
23-
21+
return begin();
2422
} else {
25-
const iterator i (m_root, this, iterator::begin);
26-
iterator result = insert_internal (i, value);
27-
reset_last();
28-
return result;
29-
23+
return insert_internal (iterator (m_root, this), value);
3024
}
3125
}
3226

3327
void clear() {
3428
// leaky-leaky
35-
m_last = m_root = NULL;
29+
m_root = NULL;
3630
}
3731

32+
// lowest key
3833
const iterator begin() const {
39-
return iterator (m_root, this, m_root == NULL ? iterator::end : iterator::begin);
34+
TreeNode<T, Order> * node = m_root;
35+
while (node != NULL) {
36+
if (node->m_left != NULL)
37+
node = node->m_left;
38+
else
39+
break;
40+
}
41+
42+
return iterator (node, this, node == NULL);
4043
}
4144

45+
// highest key
4246
const iterator end() const {
43-
return iterator (m_last, this, iterator::end);
47+
TreeNode<T, Order> * node = m_root;
48+
while (node != NULL) {
49+
if (node->m_right != NULL)
50+
node = node->m_right;
51+
else
52+
break;
53+
}
54+
55+
return iterator (node, this, true);
4456
}
4557

4658
/*iterator first();
@@ -50,32 +62,12 @@ template <class T, template<class> class Order = Less > class Tree {
5062

5163
protected:
5264
TreeNode<T, Order> * m_root;
53-
TreeNode<T, Order> * m_last;
54-
55-
void reset_last(void) {
56-
TreeNode<T, Order> * t = m_root;
57-
while (t != NULL) {
58-
59-
if (t->m_right == NULL) {
60-
if (t->m_left == NULL) {
61-
break;
62-
63-
} else {
64-
t = t->m_left;
65-
}
66-
67-
} else {
68-
t = t->m_right;
69-
}
70-
}
71-
m_last = t;
72-
}
7365

7466
iterator insert_internal(iterator i, const T& value) {
7567
Order<T> order;
7668

7769
if (order(value, i.m_node->m_value)) { // links
78-
iterator prev = iterator (i.m_node->m_left, this, iterator::middle);
70+
iterator prev = iterator (i.m_node->m_left, this);
7971
if (prev.m_node == NULL) {
8072
prev.m_node = new node(value);
8173
prev.m_node->m_up = i.m_node;
@@ -87,7 +79,7 @@ template <class T, template<class> class Order = Less > class Tree {
8779

8880

8981
} else if (order(i.m_node->m_value, value)) { // rechts
90-
iterator next = iterator (i.m_node->m_right, this, iterator::middle);
82+
iterator next = iterator (i.m_node->m_right, this);
9183
if (next.m_node == NULL) {
9284
next.m_node = new node(value);
9385
next.m_node->m_up = i.m_node;

‎cpp4j/treeiterator.h

Lines changed: 30 additions & 83 deletions
Original file line numberDiff line numberDiff line change
@@ -21,128 +21,75 @@ template <class T, template<typename> class Order > class TreeIterator {
2121

2222
// zum nächsten Element
2323
TreeIterator<T, Order>& operator++() {
24-
if (m_node == NULL || m_mode == end) {
24+
if (m_node == NULL || m_end)
2525
return *this;
26-
}
27-
28-
m_mode = middle;
29-
30-
//
31-
// Was kann sonst sein?
32-
//
3326

34-
// versuche, nach links zu gehen
35-
if (m_node->m_left != NULL) {
36-
m_node = m_node->m_left;
37-
return *this;
38-
}
39-
40-
// wenn links nicht moeglich, versuche nach rechts zu gehen
4127
if (m_node->m_right != NULL) {
4228
m_node = m_node->m_right;
29+
while (m_node->m_left != NULL)
30+
m_node = m_node->m_left;
31+
4332
return *this;
4433
}
4534

46-
// wenn rechts nicht moeglich, versuche so weit nach oben zu gehen, dass du einen neuen rechten Weg hast
47-
TreeNode<T, Order> * child = m_node;
48-
TreeNode<T, Order> * parent = child->m_up;
35+
if (m_node->m_up != NULL) {
36+
if (m_node->m_up->m_left == m_node) {
37+
// wir kamen von links
38+
m_node = m_node->m_up;
39+
return *this;
40+
}
4941

50-
while (parent != NULL) {
42+
TreeNode<T, Order> * node = m_node;
5143

52-
// sind wir das linke Kind des Elter?
53-
if (child == parent->m_left) {
44+
// wir kamen von rechts, also so lange nach oben, bis wir einen neuen rechten Pfad haben
45+
while (node->m_up->m_right == node) {
5446

55-
// haben wir Geschwister?
56-
if (parent->m_right != NULL) {
47+
node = node->m_up;
5748

58-
// naechster gefunden
59-
m_node = parent->m_right;
49+
if (node->m_up == NULL) { // reached root, nothing else to do
50+
m_end = true;
6051
return *this;
6152
}
62-
}
6353

64-
// wir sind nicht das linke Kind (sondern das rechte)
65-
child = parent;
66-
parent = parent->m_up;
67-
}
54+
}
6855

69-
// wenn nichts moeglich ist, sind wir bereits am Ende
70-
m_mode = end;
71-
return *this;
72-
}
56+
m_node = node->m_up;
7357

74-
// zum vorherigen Element
75-
TreeIterator<T, Order>& operator--() {
76-
if (m_node == NULL || m_mode == begin) {
7758
return *this;
78-
}
79-
80-
m_mode = middle;
81-
82-
//
83-
// Was kann sonst sein?
84-
//
8559

86-
// wenn rechts nicht moeglich, versuche so weit nach oben zu gehen, dass du einen neuen rechten Weg hast
87-
TreeNode<T, Order> * child = m_node;
88-
TreeNode<T, Order> * parent = child->m_up;
89-
90-
while (parent != NULL) {
91-
92-
// sind wir das linke Kind des Elter?
93-
if (child == parent->m_right) {
94-
95-
// haben wir Geschwister?
96-
if (parent->m_left != NULL) {
97-
98-
// naechster gefunden
99-
m_node = parent->m_left;
100-
return *this;
101-
}
102-
}
103-
104-
// wir sind nicht das linke Kind (sondern das rechte)
105-
child = parent;
106-
parent = parent->m_up;
10760
}
10861

109-
// wenn links nicht moeglich, versuche nach rechts zu gehen
110-
if (m_node->m_left != NULL) {
111-
m_node = m_node->m_left;
112-
return *this;
113-
}
62+
m_end = true;
63+
return *this;
11464

115-
// versuche, nach links zu gehen
116-
if (m_node->m_right != NULL) {
117-
m_node = m_node->m_right;
118-
return *this;
119-
}
65+
}
12066

121-
// wenn nichts moeglich ist, sind wir bereits am Ende
122-
m_mode = begin;
67+
// zum vorherigen Element
68+
TreeIterator<T, Order>& operator--() {
12369
return *this;
12470
}
12571

12672
bool operator==(const TreeIterator<T, Order> &rhs) const {
127-
return this->m_node == rhs.m_node && this->m_tree == rhs.m_tree && this->m_mode == rhs.m_mode;
73+
return this->m_node == rhs.m_node && this->m_tree == rhs.m_tree && this->m_end == rhs.m_end;
12874
}
12975

13076
bool operator!=(const TreeIterator<T, Order> &rhs) const {
131-
return !(this->m_node == rhs.m_node && this->m_tree == rhs.m_tree && this->m_mode == rhs.m_mode);
77+
return !(*this == rhs);
13278
}
13379

13480
protected:
13581

136-
enum iterator_mode { begin, middle, end };
137-
iterator_mode m_mode;
82+
TreeIterator(TreeNode<T, Order> * node, const Tree<T, Order> * tree)
83+
: m_node(node), m_tree(tree), m_end(false) {}
13884

139-
TreeIterator(TreeNode<T, Order> * node, const Tree<T, Order> * tree, const iterator_mode mode)
140-
: m_node(node), m_tree(tree), m_mode(mode) {}
85+
TreeIterator(TreeNode<T, Order> * node, const Tree<T, Order> * tree, const bool end)
86+
: m_node(node), m_tree(tree), m_end(end) {}
14187

14288
private:
14389

14490
TreeNode<T, Order> * m_node;
14591
const Tree<T, Order> * m_tree;
92+
bool m_end;
14693

14794
};
14895

0 commit comments

Comments
 (0)