wie kann ich den iterator bis zum letzten element laufen lassen?
tree::treeiterator it = t.begin(); it != t.end(); it = it.next()
wenn it == i.end ist wird die schleife ja nicht mehr ausgeführt...

class tree 
{ 
private: 
    class node *root; 

public: 
    class treeiterator 
    { 
    private: 
        std::stack<class node*> stack; 
        class node *now; 
        class node *end; 
        class tree *ptree; 
        bool left; 
        bool right; 

    public: 
        treeiterator(class tree *tree_): now(NULL), left(false), right(false) 
        { 
            ptree = tree_; 
        } 

        void start_at_beginning() 
        { 
            now = ptree->get_root_node(); 
            stack.push(now); 
        } 

        void start_at_end() 
        { 
            now = ptree->get_root_node(); 
            std::stack<class node*> stack_tmp; 

            while(true) 
            { 
                if(now->left) 
                { 
                    stack_tmp.push(now->right); 
                } 
                if(now->right) 
                { 
                    stack_tmp.push(now->left); 
                } 

                if (!stack_tmp.empty()) 
                { 
                    now = stack_tmp.top(); 
                    stack_tmp.pop(); 
                } 
                else 
                { 
                    break; 
                } 
            } 
        } 

        class node *get_node() 
        { 
            return now; 
        } 

        treeiterator &next() // next iterator for Depth first Search 
        { 
            if (now->left) 
            { 
                stack.push(now->right); 
            } 
            if (now->right) 
            { 
                stack.push(now->left); 
            } 
            if (!stack.empty()) 
            { 
                now = stack.top(); 
                stack.pop(); 
            } 
            else 
            { 
                now = NULL; 
            } 

            return *this; 
        } 

        bool operator== (treeiterator &it) 
        { 
            return this->get_node() == it.get_node(); 
        } 

        bool operator!= (treeiterator &it) 
        { 
            return this->get_node() != it.get_node(); 
        } 

        node operator*() 
        { 
            return *get_node(); 
        } 
    }; 

public: 
    tree(): root(NULL) {} 

    class node *get_root_node() 
    { 
        return root; 
    } 

    class treeiterator begin() 
    { 
        class treeiterator it(this); 
        it.start_at_beginning(); 
        return it; 
    } 

    class treeiterator end() 
    { 
        class treeiterator it(this); 
        it.start_at_end(); 
        return it; 
    } 
};

wie mach ich das nun hier?

Vielleicht sowas in der Art:

void start_at_end()
        {
            now = NULL;
        }

class node
{
public:
	class node *parent;
	class node *left;
	class node *right;

	bool visited_left;
	bool visited_right;
	int value;

	node(): parent(NULL), left(NULL), right(NULL), value(0), visited_left(false), visited_right(false) {}
};

		treeiterator &next() // next iterator for Depth first Search
		{
			if(!now->visited_left)
			{
				if(now->left)
				{
					now->visited_left = true;
					now = now->left;

					return *this;
				}
			}
			if(!now->visited_right)
			{
				if(now->right)
				{
					now->visited_right = true;
					now = now->right;

					return *this;
				}
			}
			if(now->visited_left && now->visited_right && now == ptree->get_root_node())
			{	
				now = NULL;
			}
			else
			{
				now = now->parent;
				return next();
			}

			return *this;
		}

Ein traversiertechnischer Nachfolger für die inorder-Reihenfolge müsste sich so bestimmen lassen. Pseudo-Code:

node* leftmost_node(node* tree)
{
  assert(tree!=0);
  while (tree->left) tree = tree->left;
  return tree;
}

node* closest_right_ancestor(node* from)
{
  assert(from!=0);
  for (node* p; (p=from->parent)!=0; from=p)
    if (p->left==from) return p;
  return 0; // does not exist
}

node* next_inorder(node* current)
{
  assert(current!=0);
  if (current->right) return leftmost_node(current->right);
  return closest_right_ancestor(current);
}

wobei du hier leftmost_node gleich noch für den begin-Iterator wiederverwenden kannst.

Die anderen Traversierungen (next_preorder und next_postorder) sollten jetzt auch nicht komplizierter sein ...

Alle Angaben ohne Gewähr, da Code ungetestet.

if (current->right) return leftmost_node(current->right);

bist du dir sicher das funktioniert so?

Ziemlich.

iter schrieb:

warum das hier?

if (current->right) return leftmost_node(current->right);

Wenn "current" der aktuelle Knoten in der inorder-Traversierung ist, dann haben wir den linken Teilbaum schon komplett abgegrast (falls es den überhaupt gibt). Als nächstes wäre also der rechte Teilbaum dran. Und was ist der "erste" Knoten eines Baumes im inorder-Sinne? Das ist doch der Knoten, der am "weitesten links steht". Den erreiche ich über leftmost_node(wurzel). Die Wurzel des rechten Teilbaums ist ja current->right.

if (current->right) return leftmost_node(current->right);

treeiterator &next() // next iterator for Depth first Search
		{
			if (now->right) 
			{
				stack.push(now->right);
			}
			if (now->left) 
			{
				stack.push(now->left);
			}

			if (!stack.empty()) 
			{ 
				now = stack.top(); 
				stack.pop();
			}
			else
			{
				now = NULL;
			}

                        return *this;
}

Für einen Suchbaum ist diese Reihenfolge nicht praktisch, da der Nutzer keine sortierte Sequenz sehen würde. Deswegen bin ich von inorder ausgegangen. Aber das ist ja deine Sache mit der Reihenfolge.

Jetzt nachdem du die inorder-Variante gesehen hast, die im übrigen funktioniert (habe sie jetzt getestet), sollte es für dich kein Problem sein, darauf zu kommen, wie die preorder-Variante aussieht. Meine Hilfe zum Tarif "kostenlos" hast Du zu diesem Thema jetzt ausgereizt.

class node* closest_right_ancestor1(class node* from)
		{
		  assert(from!=0); 
		  for (node* p = from; p != 0; p = p->parent)
		  {
			if (p->left == from) return p->right; 
			from = p;
		  }
		  return 0; // does not exist 
		}

		treeiterator &next() // next iterator for Depth first Search
		{
			assert(now!=0); 
			if (now->left)
			{
				now = now->left;
				return *this;
			}
			if (now->right) 
			{
				now = now->right; 
				return *this;
			}
			now = closest_right_ancestor(now);
		}

kann man breath first search auch ohne zusätzlichen speicher implementieren?

[2]
     /   \
  [1]     [3]

die Endlosschleife: 2,1,2,1,2,1,2,1,...

Außerdem fehlt da noch ein return am Ende.

Und lass das class bei class node* weg.

closest_right_ancestor hast du auch verschlimmbessert. Aber die brauchst du hier eh nicht, die Funktion.