Inserting nodes in a Binary Tree recursively?

Question

I am trying to insert nodes in a binary tree recursively, but the code is only doing the root node and it's left and right children. I am trying to figure out how to get past that point.

I have already tried different implementations, using queues, doing level order insert. I believe the problem is due to the fact that in my main function I only call with root, and if that is the problem, how would I go about calling with the left and right childs.

Main Function:

int main() {
    treenode* root = new treenode();
    for(int a = 1; a < 15; a++) {
            insert(root, a);
    }
    cout << "Height: " << height(root) << endl;
    cout << "Printed Tree: " << endl;
    for(int a = 0; a <= height(root); a++) {
        printGivenLevel(root, a); //Print every level
        cout << endl;
    }
    return 0;
}

Here is my insert function:

void insert(treenode*& node, int val) {
    if(node == nullptr) {
        node = new treenode(val);
        return;
    }else{
        if(node->left == nullptr) {
            insert(node->left, val);
        }else{
            insert(node->right, val);
        }
    }
}

A treenode has a value, a left child and right child:

struct treenode {
    //The value of the node
    int value;
    //Pointers to the left and right children
    treenode *left, *right;
    //Constructor with values;
    treenode(int val=0, treenode *l = nullptr, treenode *r = nullptr) : value(val), left(l), right(r) {};
};

I would expect the result to be something like so:

0

1 2

3 4 5 6

7 8 9 10 11 12 13 14

But my actual output is only:

0

1 2

Thanks in advance

Answer 1

... but the code is only doing the root node and it's left and right children. I am trying to figure out how to get past that point.

I find no error in your treenode::insert, your problem might be in some other code you do not show. For example, you did not provide "height(root)" or "Printed Tree" info. I could not diagnose them.

I have provided some alternatives for various ideas. see "dump()" and "height()" and "size()".

Note: "dump()" is none of pre, in-, or post- order, because the sorted input creates unbalance tree displays (they are worst-case-unbalanced). I found this display the easiest to review.

Perhaps the following will help you diagnose your mistakes. Good luck.

Note the use of "if(false) cout << ...". These are diagnostic output which might provide some insights by enabling them, and / or adding such items to your code.

Did you try your debugger yet?

---

#include <chrono> //    short form names----vvvvvvv
typedef std::chrono::high_resolution_clock  HRClk_t; // std-chrono-hi-res-clk
typedef HRClk_t::time_point                 Time_t;  // std-chrono-hi-res-clk-time-point
typedef std::chrono::nanoseconds            NS_t;    // std-chrono-nanoseconds
using  namespace std::chrono_literals;   // suffixes like 100ms, 2s, 30us
using  std::chrono::duration_cast;

#include <iostream>
using std::cout, std::endl, std::flush;

#include <iomanip>
using std::setw;


namespace DTB
{

class treenode
{
  friend class T920_t;

  int value;               //The value of the node

  treenode *left, *right;   //Pointers to the left and right children

  //Constructor with values;
  treenode(int val=0, treenode *l = nullptr, treenode *r = nullptr)
     : value(val), left(l), right(r) { ctor('A'); };


  void ctor(char kar) {
     if (left) left->ctor(kar);
     {
        if(false) // diagnostic
           cout << "\n  ctor: " << "   " << kar
                << "  val: " << setw(3) << value << flush;
     }
     if(right) right->ctor(kar);
  }

  void insert ( treenode*& node, int val)
     {
        if(node == nullptr)
        {
           node = new treenode(val);
           if (false) node->dump(); // diagnostic
           return;
        }
        else
        {
           if(node->left == nullptr)
           {
              insert(node->left, val);
              if (false) node->dump(); // diagnostic
           }
           else
           {
              insert(node->right, val);
              if (false) node->dump(); // diaagnostic
           }
        }
     }

  int height(int lvl = 1)
      {
         static int maxHeight = 0;
         if (left)  left->height (lvl+1);
         if(right) right->height (lvl+1);
         if (lvl > maxHeight) maxHeight = lvl;
         return maxHeight;
      }

  int size()
     {
        int count = 1; // this element
        if (left) { count +=  left->size(); };
        if(right) { count += right->size(); }
        return count;
     }


  void dump(int lvl=0)
     {
        if (left)  left->dump (lvl+1);
        if(right) right->dump (lvl+1);
        {
           cout << "\n  " // << lvl
                << setw(3*lvl) << ' '
                << value << flush;
        }
     }

}; // class treenode
typedef treenode Node_t; // shorter name for user-defined-type



class T920_t
{
public:
   int operator()(int argc, char* argv[]) { return exec(argc, argv); }

private:

   int exec(int , char** )
      {
         int retVal = 0;
         Time_t start_ns = HRClk_t::now();

         Node_t* root = new Node_t();  // 1st node
         for(int v = 1; v < 21; ++v) { // 20 more
            root->insert(root, v);
         }

         cout << "\n\n  size : " << root->size()  // element count
              << " maxHeight : " << root->height()
              << endl;

         dumpAll(root);

         for(int v = 1; v < 11; ++v) { // 10 more
            root->insert(root, v);
         }

         cout << "\n\n  size : " << root->size()  // element count
              << " maxHeight : " << root->height()
              << endl;

         dumpAll(root);


         auto  duration_ns = duration_cast<NS_t>(HRClk_t::now() - start_ns).count();

         cout << "\n\n\n  T920_t::exec() duration   "
              << duration_ns << " ns  "
              << "    cpluplus vers : " <<  __cplusplus  << std::endl;

         return retVal;
      }

   void dumpAll (Node_t*& node)
      {
         cout << "\n  dumpAll(): ";
         node->dump();
         cout << endl;
      }

}; // class T920_t
} // namespace DTB

int main(int argc, char* argv[]) { return DTB::T920_t()(argc, argv); }

---

A partial output is:

  size : 21 maxHeight : 11

  dumpAll(): 
     1
        3
           5
              7
                 9
                    11
                       13
                          15
                             17
                                19
                                20
                             18
                          16
                       14
                    12
                 10
              8
           6
        4
     2
   0


  size : 31 maxHeight : 16

  dumpAll(): 
     1
        3
   ...

                 10
              8
           6
        4
     2
   0


  T920_t::exec() duration   271095 ns      cpluplus vers : 201703