statusEnum insertNode( treeType *root, keyType key )
{
    treeType *newNode, *current, *parent = NULL;

    current = root;

    // search for insertion point
    while current != to NULL
	if key == current->key
            return duplicate_key
	move parent instep with current
        compare if key < current->key
		current = current->left
        else current = current->right
    end while

    // Allocate new node
    newNode = new treeType()
    newNode->parent = parent
    newNode->left = NULL
    newNode->right = NULL
    newNode->key = key

    // Insert node in tree
    if parent
        if newNode->key < parent->key
            parent->left = newNode
        else parent->right = newNode
    else root = newNode

    return status_ok
} // end

typedef struct TREE{
TREE *right;
TREE *left;
TREE *back;
int info;
};







int add_node(TREE *t, int info) {


TREE * ptr = t;
     
     ptr->back = NULL;    ///...redundant but innocuous...will always be top node...
     
     while (ptr)   //...could just as well be "while(1)"
       {
        if(ptr->info == info)
         return -1;

        if (info < ptr->info)
         {
           if(ptr->right != NULL)
             ptr = ptr->right;
           else
             break;
          }
        
         else
          {
            if(ptr->left != NULL)
              ptr = ptr->left;
            else
              break;
          }
        }



  TREE * p = new TREE;

  p->info = info;
  
  p->left = NULL; 

  p->right = NULL;

  p->back = ptr;

  if (t == NULL) t = p; 

  if ( p->info < ptr->info)
    ptr->right = p;
 
  else
    ptr->left = p;

return 0;
}









void build_tree(int *size, int data[], TREE *t)
{ 

int ct;
int duplicate;

for (ct = 0; ct < *size; ++ct)
 { 

  duplicate = add_node( t, data[ct]);

  if(duplicate) *size--;


 }

}







int main(int argc, char *argv[])
{
 TREE tree;
 tree.left = 0;
 tree.right = 0;
 tree.back = 0;
 tree.info = 0;

 int i;
 int size = 10;
 int array[ size ];

 for(i = 1; i <= size; i++)
 array[i - 1] = i;              //...edited...//


 build_tree( &size, array, &tree);



  return 0;
}

#include <stdio.h>


FILE *fp;

typedef struct TREE{
TREE *right;
TREE *left;
TREE *back;
int info;
};




int add_node(TREE *t, int info) {


TREE * ptr = t;
     
     ptr->back = NULL;    ///...redundant but innocuous...will always be top node...
     
     fprintf(fp,"\n\nStarting from the top, again...\n");

     while (ptr)   //...could just as well be "while(1)"
       {
        if(ptr->info == info)
         { fprintf(fp,"Duplicate !\n");  return -1; }

        if (info < ptr->info)
         {
           if(ptr->right != NULL)
             { fprintf(fp,"Taking a right!\n");  ptr = ptr->right; }
           else
             break;
          }
        
         else
          {
            if(ptr->left != NULL)
             { fprintf(fp,"Taking a left!\n"); ptr = ptr->left; }
            else
              break;
          }
        }



  TREE * p = new TREE;

  p->info = info;
  
  p->left = NULL; 

  p->right = NULL;

  p->back = ptr;

  if (t == NULL) t = p; 

  if ( p->info < ptr->info)
    { fprintf(fp,"Attaching to right side!\n");  ptr->right = p; }
 
  else
    { fprintf(fp,"Attaching to left side!\n");  ptr->left = p; }

return 0;
}








void build_tree(int *size, int data[], TREE *t)
{ 
 fp = fopen("DEBUG.txt", "w");

 if(!fp) return;

int ct;
int duplicate;

for (ct = 0; ct < *size; ++ct)
 { 

  duplicate = add_node( t, data[ct]);

  if(duplicate) *size--;
 }

 fclose(fp);
}







int main(int argc, char *argv[])
{
 TREE tree;
 tree.left = 0;
 tree.right = 0;
 tree.back = 0;
 tree.info = 0;

 int i;
 int size = 10;
 int array[ size ];

 for(i = 1; i <= size; i++)
 array[i-1] = i;

 build_tree( &size, array, &tree);







  return 0;
}

  current = root;


Next, we must search for the insertion point, this continues until
current points to NULL.  If the tree is empty, the root is NULL
Else keep moving current until it points to a NULL child pointer

    // search for insertion point
    while current   // while the root or current are not NULL

Usually we don't want duplicate keys, so you need a means to deal with them
	if key == current->key
                        return duplicate_key // an enum


    // Update your pointers
	parent = current   // move parent instep with current
    
    // compare 
    if key < current->key
        current = current->left
    else
        current = current->right
    end while


    you don't need a newNode->parent pointer, or what you refer
to as a back pointer.



// Insert node in tree, when current points at a NULL child
pointer, parent is pointing to the NULL child pointer's parent
    if parent  
        if newNode->key < parent->key
            parent->left = newNode
        else parent->right = newNode
    else root = newNode