Bin schon seit 2 Tagen an einem Projekt, einen binären Suchbaum
zu programmieren. Habe mir eigentlich vorgenommen, dass komplett
alleine durchzukauen, aber bei diesem Problem fehlt bei mir einfach
das logische Verständnis.

Was ich vorher so hatte:

//-------------------------Suche Einfuege-Position-----------------------
void Tree::search_position(int pos)
{
       do                                       //  mache...
       {
         if (pos < root->data)                  // ist wert kleiner
         {                                      // als wurzeldaten?

              if (root->left_son != NULL)       // hat linker Sohn nachfolger?
              {
                 root = root->left_son;         // NachfolgerL wird neue Wurzel
              }
         }
         else
         {
              if (root->right_son != NULL)      // hat rechter Sohn nachfolger?
              {
                 root = root->right_son;        // NachfolgerR wird neue Wurzel
              }
         }
       }while((isempty()));                     // ... bis Wurzel leer ist
};
//-----------------------------Neuen Wert hinzufuegen--------------------
bool Tree::newleaf(int wert)
{
  treestructure *tmp;
  if (tmp = new treestructure)                  // Abfrage1: Konnte neues Blatt
  {                                             // erstellt werden?

     if (isempty())                             //  Abfrage2: Ist Wurzel leer?
     {
        root->data = wert;                      //   dann besetze Wurzel
     }                                          //   mit dem neuen Wert
     else
     {
       Tree::search_position(wert);             //   führe Positionssuche durch

       if (wert < root->data)
       {
          root->left_son = tmp;                // linker Sohn wird tmp
       }
       else
       {
          root->right_son = tmp;               // rechter Sohn wird tmp
       }

       tmp->data = wert;                    // tmp mit neuem Wert versehen
       tmp->parent = root;                  // papa von tmp ist Wurzel
       tmp->left_son = NULL;                // Setze beide Soehne
       tmp->right_son = NULL;               // auf NULL
       root = tmp;                          // tmp wird neue Wurzel
       jumptofirst();                       // Springe an den Urpsrung
     }
     return true;
  }
  else
  {
     return false;
  }
};

Soll nun rekursiv erfolgen. Alles kein Problem, wenn ich das Post-Order-Verfahren machen würde. Aber unser Professor meinte wir sollten das mal mit Pre-Order-Verfahren durchführen.

Habt ihr ne Ahnung ?

void postorder_anfuegen(treestructure *tree, int wert)
{
  if (wert < tree->data)
  {
    if (tree->left != NULL)
    {
      postorder_anfuegen(tree->left, int wert);
    }
  }
  else 
  {
    if (tree->right != NULL)
    {
      postorder_anfuegen(tree->right, int wert);
    }
  }
  ja und hier eben dann eben element anfuegen je nachdem ob größer oder kleiner
}

aber wie soll ich das in preorder umwandeln ?