Thread: binary tree

I am working on a binary tree. And was wondering what is the best way to traverse it(I want to print it) also does anyone see anything wrong with this. It looks fine to me(besides checking the return value of fgets and ssanf?

Code:

struct info{
        int x;
        struct info *less;
        struct info *more;
};

void add_number(void){
        static struct info *head;
        int x;
        char buffer[BUFSIZ];
        if(!head){
                head=malloc(sizeof(struct info));
                if(!head){
                        printf("Out of Memory\n");
                        exit(1);
                }
                printf("Enter a number\n");
                fgets(buffer,sizeof buffer,stdin);
                sscanf(buffer,"%d",&x);
                head->x=x;
        }
        else{
                printf("Enter a number\n");
                fgets(buffer,sizeof buffer,stdin);
                sscanf(buffer,"%d",&x);
                if(x>head->x){
                        head->more=malloc(sizeof(struct info));
                        if(!head->more){
                                printf("Out of Memory\n");
                                exit(1);
                        }
                        head->more->x=x;
                        head=head->more; /*is this a good idea*/
                }
                else if(x<head->x){
                        head->less=malloc(sizeof(struct info));
                        if(!head->less){
                                printf("Out of Memory\n");
                                exit(1);
                        }
                        head->less->x=x;
                        head=head->less;  /*same here*/
                }
                else
                        printf("Equal number as before disregaurding\n");
        }
}

Well, you could always read this FAQ entry. Just a thought.

Quzah.

Well, technically that is a binary search tree by definition. But realistically it isn't very useful. The problem is here:

>head=head->more; /*is this a good idea*/

and here:

>head=head->less; /*same here*/

Tell me, since you don't use a stack, or recursion, or save variables, or parent pointers, how do you get back to the original head? You don't, really. It's lost the instant you reseat the pointer without saving its current state. That's why most binary search tree insertion functions are recursive:

Code:

struct node *insert ( struct node *root, int value )
{
  if ( root == NULL ) {
    root = malloc ( sizeof *root );

    if ( root == NULL )
      complain();

    root->data = value;
    root->left = root->right = NULL;
  }
  else if ( value < root->data )
    root->left = insert ( root->left, value );
  else
    root->right = insert ( root->right, value );

  return root;
}

It's an easy and concise way to save the state of your tree without losing it when you work on subtrees.