Question

I had an interview and I could not answer this question. You have an binary tree and you are putting all the nodes into an array using in_order and you return the value for the size of the array. I was told that I could not use a helper function and add int i=0 for an array counter.

The recursive function heading I had to use was.

      In_order(Struct_Node * node, int *array){

      }

Because it was In_order I wrote.

      if(node){
      In_order(node->left, array);

//this line is where I am supposed to add the elements and return the value,
but I do not understand how to do this. This is my week point and I need to understand
the reasoning of how this code works more than what is the code.

      in_order(node->right,array); 
      }

I didn’t actually write what I wrote in between the two In_order statements but what I wrote was wrong.

Answer 1

Guessing all the missing details I think you would do something like:

int In_order(Struct_Node * node, int *array){

   int count = 0;
   if (node->left) {
     count += In_order(node->left, array);
   }
   array[count++] = node->data; // whatever it is you're storing
   if (node->right) {
     count += In_order(node->right, array+count);
   }
   return count;
}

The key point is you pass an updated pointer to the RHS recursive call and your return value is 1 + LHS return + RHS return

If you can’t use an int as a counter (which is silly really because it’s by far the clearest way of expressing it) you can do:

int In_order(Struct_Node * node, const int *array){
   int *tptr = array;

   if (node->left) {
     tptr += In_order(node->left, array);
   }
   *tptr++ = node->data; // whatever it is you're storing
   if (node->right) {
     tptr += In_order(node->right, tptr);
   }

   return tptr-array;
}

If you wanted to go “a little” crazy and avoid any locals other than the function arguments you could change the return type to be a pointer to the current working end of the array (which is in effect the size of the array also) and do:

int *In_order(const Struct_Node * const node, int * const result) {
  return !node ? result :
          In_order(node->right, &(*In_order(node->left, result) = node->value)+1);
}

Although to be quite honest that’s terrible code (I’m not even 100% sure that it is well defined!) and I really hope they weren’t looking for a solution like that!