wie kann ich folgenden algorithmus optimieren? Es sollen alle nodes welche sich in höhe h1 des binären baums befinden in eine liste gespeichert werden...

typedef struct node_info {
		node_info(node *n1, int h): n(n1), height(h) {}
		node *n;
		int height;
	}node_info;

	void add_to_list(std::vector<std::list<node_info>> &l, node *n, int height) {
	  std::vector<std::list<node_info>>::iterator it;
	  std::list<node_info>::iterator it2;
	  bool found = false;

	  for(it = l.begin(); it != l.end(); it++) {
		it2 = (*it).begin();

		if(it2->height == height) {
		  node_info t(n, height);
		  it->push_back(t);
		  found = true;
		  break;
		}
	  }

	  if(!found) {
		node_info t(n, height);
		std::list<node_info> l2;
		l2.push_back(t);
		l.push_back(l2);
	  }  
	}

    bool get_nodes_in_height(int h1, std::list<node_info> &out) {
	  typedef struct n_info {
		n_info(node *nn, int h): n(nn), height(h) {}
		node *n;
		int height;	 
	  }n_info;

	  node *n = get_root();
	  std::vector<std::list<node_info>> l;
	  std::queue<n_info> s;
	  int height = 0;

	  s.push(n_info(n, height));

	  while(!s.empty()) {
		n_info nf = s.front();

		height = nf.height;
		node *t = nf.n;

		add_to_list(l, t, height);

		s.pop();

		if(t->right) {
		  s.push(n_info(t->right, height+1));
		}
		if(t->left) {
		  s.push(n_info(t->left, height+1));
		}
	  }

	  std::list<node_info>::iterator it2 = l[h1].begin();
	  if(it2->height == h1) {
		  out = l[h1];
		  return true;
	  }

	  return false;
	}

#include <iostream>
#include <stack>
#include <queue>
#include <list>
#include <vector>
#include <algorithm>
using namespace std;

typedef struct node {
    struct node *left;
        struct node *right;
        struct node *parent;
        int value;
}node;

class tree {
private:
        node *root;

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

        node *get_root() {
                return root;

        }

        node *create_node(int data) {
                node *n = new node;
                n->left = NULL;
                n->right = NULL;
                n->parent = NULL;
                n->value = data;
                return n;
        }

        int search_index(int  in_order[], int start, int end, int value) {
                for(int i = start; i <= end; i++) {
                        if(in_order[i] == value) {
                                return i;
                        }
                }

                return -1;
        }

        node *create_tree_pre_in_order(int pre_order[], int in_order[], int start, int end) {
                static int pre_index = 0;

                if(start > end) {
                        return NULL;
                }

                /* Pick current node from Preorder traversal using preIndex
                and increment preIndex */
                int root_val = pre_order[pre_index++];
                node *n = create_node(root_val);
                if(pre_index == 1) {
                        root = n;
                }

                /* If this node has no children then return */
                if(start == end) {
                        return n;
                }

                /* Else find the index of this node in Inorder traversal */
                int index = search_index(in_order, start, end, root_val);
                if(index == -1) {
                        return NULL;
                }

                /* Using index in Inorder traversal, construct left and
                right subtress */
                n->left = create_tree_pre_in_order(pre_order, in_order, start, index-1);
                n->right = create_tree_pre_in_order(pre_order, in_order, index+1, end);

                return n;
        }

        void insert(int value) {
                struct node *curr = root;
                struct node *prev = NULL;
                struct node *tmp = create_node(value);

                if(root == NULL) {
                        root = tmp;
                }
                else {
                        while(curr) {
                                if(value < curr->value) {
                                        prev = curr;
                                        curr = curr->left;
                                }
                                else {
                                        prev = curr;
                                        curr = curr->right;
                                }
                        }

                        curr = prev;

                        if(value < curr->value) {
                                curr->left = tmp;       
                        }
                        else {
                                curr->right = tmp;
                        }

                        tmp->parent = prev;
                }
        }

        typedef struct node_info {
                node_info(node *n1, int h): n(n1), height(h) {}
                node *n;
                int height;
        }node_info;

        void add_to_list(std::vector<std::list<node_info> > &l, node *n, int height) {
          std::vector<std::list<node_info> >::iterator it;
          std::list<node_info>::iterator it2;
          bool found = false;

          for(it = l.begin(); it != l.end(); it++) {
                it2 = (*it).begin();

                if(it2->height == height) {
                  node_info t(n, height);
                  it->push_back(t);
                  found = true;
                  break;
                }
          }

          if(!found) {
                node_info t(n, height);
                std::list<node_info> l2;
                l2.push_back(t);
                l.push_back(l2);
          }  
        }

    bool get_list_nodes_of_height(std::list<node_info> &out, int h1) {
          node *n = get_root();
          std::vector<std::list<node_info> > l;
          std::queue<node_info> s;
          int height = 0;

          s.push(node_info(n, height));

          while(!s.empty()) {
                node_info nf = s.front();

                height = nf.height;
                node *t = nf.n;

                add_to_list(l, t, height);

                s.pop();

                if(t->right) {
                  s.push(node_info(t->right, height+1));
                }
                if(t->left) {
                  s.push(node_info(t->left, height+1));
                }
          }

          std::list<node_info>::iterator it2 = l[h1].begin();
          if(it2->height == h1) {
                  out = l[h1];
                  return true;
          }

          return false;
        }
};

int main() {
   int in_order_traversal[] = {15,30,35,40,45,50,60,70,72,75,77,80};
   int pre_order_traversal[] = {50,30,15,40,35,45,70,60,80,75,72,77};

   tree tt;
   tt.create_tree_pre_in_order(pre_order_traversal, in_order_traversal, 0, sizeof(in_order_traversal)/sizeof(int)-1);

   std::list<tree::node_info> t;
   tt.get_list_nodes_of_height(t, 1);

   for(std::list<tree::node_info>::iterator it = t.begin(); it != t.end(); it++) {
           cout << (*it).n->value << endl; 
   }
}

wie kann ich folgenden algorithmus optimieren?

Optimieren kann man immer, wenn man etwas weglassen kann, was nicht zwingend notwendig ist. In Deinem Fall von get_list_nodes_of_height ist das einiges. Zunächst würde ich den std::vector<std::list<node_info> > einfach weglassen. Den braucht man nicht, weil es wird ja letztlich nur ein Element diese vector s benötigt. Damit fällt dann auch die Funktion add_to_list weg, und mit hier das Suchen nach dem Eintrag mit der Höhe ' height '. Und dann kann man noch das Einfügen von node_info -Objekte in die Queue weglassen, die bereits eine höhere Wert von height haben, als der gesuchte ' h1 '.
Der Member node_info::height als Ausgabeparameter von get_list_nodes_of_height ist auch nicht notwendig - zumindest nicht in der Demo - und die Information von height ist redundant - habe doch alle Werte den Wert von ' h1 ' (Parameter von get_list_nodes_of_height).

Das ganze stelle ich mir so vor:

void get_list_nodes_of_height( std::list< node* >& out, int h1 ) {
        if( !get_root() ) // auch leere Bäume dürfen nicht zum Absturz der SW führen
            return;
        std::queue< node_info > q;
        for( q.push( node_info( get_root(), 0 ) ); !q.empty(); q.pop() ) // for geht bei mir vor while
        {
            const node_info& top = q.front();
            if( top.height == h1 )
                out.push_back( top.n ); // <-- Ausgabe
            else
            {   // falls schon top.height == h1 ist, so machen die Kindknoten keinen Sinn mehr
                if( top.n->left )
                    q.push( node_info( top.n->left, top.height + 1 ) );
                if( top.n->right )
                    q.push( node_info( top.n->right, top.height + 1 ) );
            }
        }    
    } // return-Wert ist auch unnötig, falls keine Elemente in der Ebene 'h1' vorhanden sind, bleibt out unverändert

add_to_list() entfällt völlig und der Code im main - ab Zeile 187 - ändert sich zu:

std::list< node* > t;
   tt.get_list_nodes_of_height(t, 1);

   for(std::list<node*>::iterator it = t.begin(); it != t.end(); ++it) {
           cout << (*it)->value << endl;
   }

Tipp: statt einem konkreten Container von Knoten-Pointern würde ich das als Template mit einem Iterator als Ausgabeparameter implementieren. Wenn Du dann in einen sequentiellen Container hinein schreiben möchtest, so geht das mit dem std:inserter. So gewinnst Du Flexibilität.

Gruß
Werner

#include <iostream>
#include <stack>
#include <queue>
#include <list>
#include <vector>
#include <algorithm>
using namespace std;

typedef struct node {
    struct node *left;
        struct node *right;
        struct node *parent;
        int value;
}node;

class tree {
private:
        node *root;

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

        node *get_root() {
                return root;

        }

        node *create_node(int data) {
                node *n = new node;
                n->left = NULL;
                n->right = NULL;
                n->parent = NULL;
                n->value = data;
                return n;
        }

        int search_index(int  in_order[], int start, int end, int value) {
                for(int i = start; i <= end; i++) {
                        if(in_order[i] == value) {
                                return i;
                        }
                }

                return -1;
        }

        node *create_tree_pre_in_order(int pre_order[], int in_order[], int start, int end) {
                static int pre_index = 0;

                if(start > end) {
                        return NULL;
                }

                /* Pick current node from Preorder traversal using preIndex
                and increment preIndex */
                int root_val = pre_order[pre_index++];
                node *n = create_node(root_val);
                if(pre_index == 1) {
                        root = n;
                }

                /* If this node has no children then return */
                if(start == end) {
                        return n;
                }

                /* Else find the index of this node in Inorder traversal */
                int index = search_index(in_order, start, end, root_val);
                if(index == -1) {
                        return NULL;
                }

                /* Using index in Inorder traversal, construct left and
                right subtress */
                n->left = create_tree_pre_in_order(pre_order, in_order, start, index-1);
                n->right = create_tree_pre_in_order(pre_order, in_order, index+1, end);

                return n;
        }

        void insert(int value) {
                struct node *curr = root;
                struct node *prev = NULL;
                struct node *tmp = create_node(value);

                if(root == NULL) {
                        root = tmp;
                }
                else {
                        while(curr) {
                                if(value < curr->value) {
                                        prev = curr;
                                        curr = curr->left;
                                }
                                else {
                                        prev = curr;
                                        curr = curr->right;
                                }
                        }

                        curr = prev;

                        if(value < curr->value) {
                                curr->left = tmp;
                        }
                        else {
                                curr->right = tmp;
                        }

                        tmp->parent = prev;
                }
        }

        typedef struct node_info {
                node_info(node *n1, int h): n(n1), height(h) {}
                node *n;
                int height;
        }node_info;

/*        void add_to_list(std::vector<std::list<node_info> > &l, node *n, int height) {
          std::vector<std::list<node_info> >::iterator it;
          std::list<node_info>::iterator it2;
          bool found = false;

          for(it = l.begin(); it != l.end(); it++) {
                it2 = (*it).begin();

                if(it2->height == height) {
                  node_info t(n, height);
                  it->push_back(t);
                  found = true;
                  break;
                }
          }

          if(!found) {
                node_info t(n, height);
                std::list<node_info> l2;
                l2.push_back(t);
                l.push_back(l2);
          }
        }*/

    bool get_list_nodes_of_height(std::list<node_info> &out, int h1) {//nodeinfo? komischer typ für rückgabe
        out.clear();
          std::stack<node_info> s;//stack oder queue, fast egal. stack vermutlich minimal schneller.

          s.push(node_info(get_root(), 0));//fehler wenn leer, siehe werner

          while(!s.empty()) {
                node_info nf=s.top();
                s.pop();
//                std::cout<<"inspect "<<nf.n->value<<'\n';
                if(nf.height<h1){//umdehen, dann kan eine abfrage weg, siehe werner
                    if(nf.n->right) {
                      s.push(node_info(nf.n->right, nf.height+1));
                    }
                    if(nf.n->left) {
                      s.push(node_info(nf.n->left, nf.height+1));
                    }
                }
                else if(nf.height==h1){
//                    std::cout<<"push "<<nf.n->value<<'\n';
                    out.push_back(nf);
                }
          }
          return !out.empty();
        }
};

int main() {
   int in_order_traversal[] = {15,30,35,40,45,50,60,70,72,75,77,80};
   int pre_order_traversal[] = {50,30,15,40,35,45,70,60,80,75,72,77};

   tree tt;
   tt.create_tree_pre_in_order(pre_order_traversal, in_order_traversal, 0, sizeof(in_order_traversal)/sizeof(int)-1);

   std::list<tree::node_info> t;
   tt.get_list_nodes_of_height(t, 1);

   for(std::list<tree::node_info>::iterator it = t.begin(); it != t.end(); it++) {
           cout << (*it).n->value << endl;
   }
}

for( q.push( node_info( get_root(), 0 ) ); !q.empty(); q.pop() ) // for geht vor while

Nö, nicht immer.
Hier geht for nicht vor, würde ich sagen.
for impliziert bei mir, daß die Anzahl irgendwie schon vorher feststeht.
Das ist hier nicht gegeben, sondern es wird immer nachgelegt und selber produziert.

for impliziert bei mir, daß die Anzahl irgendwie schon vorher feststeht.

... das hat 'for' bei mir noch nie impliziert - auch zu C-Zeiten nicht. Das würde ja bedeuten, dass Du auch eine Iteration über eine einfach verlinkte Liste nicht mit for lösen würdest - also eher:

Node* p = start;
    while( p ) {
        // body
        p = p->next;
    }

statt:

for( Node* p = start; p; p = p->next ) {
        // body
    }

Ich vertrete vielmehr die Ansicht, dass die Kontrolle der Schleife im wesentlichen innerhalb des for-Statements stehen soll - das ist in obigem Beispiel eher der Fall, als mit der while-Lösung.
Aber das ist letztlich Geschmackssache - ich habe das oben mal abgeschwächt.

Gruß
Werner

volkard schrieb:

for impliziert bei mir, daß die Anzahl irgendwie schon vorher feststeht.

... das hat 'for' bei mir noch nie impliziert - auch zu C-Zeiten nicht. Das würde ja bedeuten, dass Du auch eine Iteration über eine einfach verlinkte Liste nicht mit for lösen würdest

Doch, da steht die Anzahl irgendwie fest. Ich ändere beim Durchlaufen den Container nicht. Ich laufe ungern auf etwas, was ich verändere.
for impliziert bei mir zum Beispiel auch, daß ich die Laufvariable außer im Weiterschaltungsausdruck nicht verändere. Möchte ich das tun, wird while draus.

Werner Salomon schrieb:

Ich vertrete vielmehr die Ansicht, dass die Kontrolle der Schleife im wesentlichen innerhalb des for-Statements stehen soll - das ist in obigem Beispiel eher der Fall, als mit der while-Lösung.

Hmm. Ich kann mit stack eine Tiefensuche machen und mit queue eine Breitensuche.
Das

node_info nf=s.top();
               s.pop();

ist eine Einheit und wäre in anderen Sprachen ein

node_info nf=s.pop();

Du hast Dich auf die queue festgelegt, indem Du das pop auseinandergerissen hast, um for benutzen zu können.

Aber das ist letztlich Geschmackssache - ich habe das oben mal abgeschwächt.

Jo, wollte es trotzdem mal erwähnt haben. Vielleicht hilft's ja mal.

typedef struct node_info {
		node_info(node *n1, int h): n(n1), height(h) {}
		node *n;
		int height;
	}node_info;

	void add_to_list(std::vector<std::list<node_info>> &l, node *n, int height) {
	  std::vector<std::list<node_info>>::iterator it;
	  std::list<node_info>::iterator it2;
	  bool found = false;

	  for(it = l.begin(); it != l.end(); it++) {
		it2 = (*it).begin();

		if(it2->height == height) {
		  node_info t(n, height);
		  it->push_back(t);
		  found = true;
		  break;
		}
	  }

	  if(!found) {
		node_info t(n, height);
		std::list<node_info> l2;
		l2.push_back(t);
		l.push_back(l2);
	  }  
	}

    bool get_nodes_in_height(int h1, std::list<node_info> &out) {
	  typedef struct n_info {
		n_info(node *nn, int h): n(nn), height(h) {}
		node *n;
		int height;	 
	  }n_info;

	  node *n = get_root();
	  std::vector<std::list<node_info>> l;
	  std::queue<n_info> s;
	  int height = 0;

	  s.push(n_info(n, height));

	  while(!s.empty()) {
		n_info nf = s.front();

		height = nf.height;
		node *t = nf.n;

		add_to_list(l, t, height);

		s.pop();

		if(t->right) {
		  s.push(n_info(t->right, height+1));
		}
		if(t->left) {
		  s.push(n_info(t->left, height+1));
		}
	  }

	  if(it2->height == h1) {
		  out = l[h1];
		  return true;
	  }
const node_info& top = q.front();
            if( top.height == h1 )
                out.push_back( top.n ); // <-

	  return false;
	}

jetzt?

Hallo geri1,

was willst Du uns jetzt damit sagen?
Das Listing ist fast identisch mit Deiner ersten Version - bis auf die Einfügung ab Zeile 67. ' q ' ist aber gar nicht definiert - sollte also nicht kompilieren, wenn ich mich nicht geirrt habe.

Helfen Dir Volkards und meine Antwort oder hast Du noch Fragen?

Gruß
Werner

PS.:

volkard schrieb:

Jo, wollte es trotzdem mal erwähnt haben. Vielleicht hilft's ja mal.

wobei?

Zum Testen hab ich einen binären Baum mit 10.000.000 Einträgen erstellt. Beim Suchen aller Elemente der Höhe 20 benötigt mein Algorithmus 50 ms, während deiner 4500ms benötigt. Die Anzahl der gefundenen Knoten stimmt überein, von daher gehe ich davon aus, dass mein Algorihtmus korrekt ist.

Weil 50ms eigentlich viel zu schnell ist, hab ich nochmal mit 50M Elementen und Höhe 30 getestet. Dein Algorithmus benötigte hier 102 Sekunden, meiner 22 Sekunden. Der größte Designfehler bei deinem Algorithmus ist, dass du den kompletten Baum durchgehst (daher der große Unterschied beim ersten Test).

Hier nur der neue Code (inkl. geänderter Main):

void get_list_nodes_of_height_fast(std::list<node_info> &out, int h1) {
    	 std::vector<node_info> stack; // Knoten, dessen rechte Seite noch analysiert werden muss
    	 node* n = get_root(); // aktueller Knoten
    	 int h_akt = 0; // aktuelle Höhe

    	 while (true) {
    		 if (n == NULL) {
    			 // aktueller Ast vollständig ausgewertet: Nächstes Element aus dem Stack nehmen
    			 if (stack.empty())
    				 break;
    			 n = stack.back().n;
    			 h_akt = stack.back().height;
				 stack.pop_back();
    		 }
			 if (h_akt == h1) {
				 // Knoten der gesuchten Höhe
				 out.push_back(node_info(n, h_akt));
				 n = NULL;
			 } else {
				 node* left = n->left;
				 node* right = n->right;
				 if (left && right)
					 // Linker und Rechter Ast existiert => Rechten zum Stack hinzufügen (und später analyieren
					 stack.push_back(node_info(right, h_akt+1));
				 if (left) {
					 // Linken Ast analysieren
					 n = left;
					 h_akt++;
				 } else if (right) {
					 // Rechten Ast analysieren, falls Linker nicht vorhanden war
					 n = right;
					 h_akt++;
				 } else {
					 // Ast ist komplett analysiert
					 n = NULL;
				 }
			 }
    	 }
     }
}; 

int main() {
	srand(time(0));
	tree tt;
	for (int i = 0; i < 50000000; i++) {
		if (i % 1000000 == 0) cout << i / 1000000 << "," << flush;
		tt.insert(rand() * RAND_MAX + rand());
	}
	cout << '\n';

	{
		std::list<tree::node_info> t;
		long long t0 = clock();
		tt.get_list_nodes_of_height(t, 30);
		cout << "TIME: " << (clock() - t0) << endl;
		cout << "size: " << t.size() << endl;

//		for(std::list<tree::node_info>::iterator it = t.begin(); it != t.end(); it++) {
//				cout << (*it).n->value << endl;
//		}
	}

	{
		std::list<tree::node_info> t;
		long long t0 = clock();
		tt.get_list_nodes_of_height_fast(t, 30);
		cout << "TIME: " << (clock() - t0) << endl;
		cout << "size: " << t.size() << endl;

//		for(std::list<tree::node_info>::iterator it = t.begin(); it != t.end(); it++) {
//				cout << (*it).n->value << endl;
//		}
	}
}