Thread: BST pointer problem root pointer

Hi everyone

I'm new to c++ programming, I have a problem in the following Binary search tree code .

when I initialize (root = NULL) , the code compiles ,but when I run it stopped working.
if I remove the initialization it works , but I can't proceed with the binary tree as I can't initialize any pointer to NULL.

please HELP ..

Code:

  #include <iostream>

    using namespace std;

    struct node
    {
    int key;
    node *left;
    node *right;
    };

    void insert_new(node *&root, int key)
    {

        root->key = key;
        root->left = NULL;
        root->right = NULL;

    }


    int main()
    {
    node *root = new node;
    root = NULL;
    
    insert_new(root,50);
    return 0;
    }

Don't set root to the location of an allocated memory address and then back to 0 and then try to use it in a function.

You aren't "initializing" root when you set it to NULL, you're just reassigning it to 0 or NULL or in C++, nullptr which is preferred.

To initialize the root, use a constructor.

Also, why are you passing your pointer by reference? Do you need a copy of the address or are you really trying to modify the value of your root pointer?

I'm not concerned about passing the pointer reference.

what I want to do is to begin a binary search tree . in Binary search tree .
I need to be able to check if the pointer is set to NULL or not .
so that I can insert new items, but whenever I set root == NULL; the program crashes.

yeah, you are right. Elysia. It finally worked.

Code:

#include <iostream>

using namespace std;

struct node
{
    int key;
    node *left;
    node *right;
};

void insert_new(node *root, int key)
{
    if (root != NULL)
    {
      if(key > root->key)
      {
          insert_new(root->right,key);
      }
      else
    {
        if(key < root->key)
      {
          insert_new(root->left,key);
      }
    }
    }
    else
    {
        node *temp = new node;
        temp->key = key;

        root = temp;
        temp->left = NULL;
        temp->right = NULL;
}
}


int main()
{
    node *root = new node;
    root->right = NULL;
    root->left = NULL;

    insert_new(root,50);
    insert_new(root,100);
    
    return 0;
}

I always forget to delete new
finally I did it thanks to you, Elysia . Thank you very much.

Code:

#include <iostream>

using namespace std;

struct node
{
    int key;
    node *left;
    node *right;
};

void create_first_node(node *&root,int key)
{
    node *temp = new node;
    temp->key = key;
    temp->left = NULL;
    temp->right = NULL;
    root = temp;
}

void insert_new(node *&root, int key)
{

    if (root != NULL)
    {
      if(key > root->key)
      {
          insert_new(root->right,key);
      }
      else
    {
        if(key < root->key)
      {
          insert_new(root->left,key);
      }
    }
    }
    else
    {
        node *temp = new node;
        temp->key = key;

        root = temp;
        temp->left = NULL;
        temp->right = NULL;
}
}


int main()
{
    node *root = new node;
    root->right = NULL;
    root->left = NULL;

    create_first_node(root,50);
    insert_new(root,100);
    insert_new(root,20);
    insert_new(root,70);

     cout << root->key ;


    return 0;
}

Originally Posted by Aboulkomsan

I always forget to delete new
finally I did it thanks to you, Elysia . Thank you very much.

Originally Posted by Elysia

You still haven't freed the memory (i.e. delete what you new).

Don't you know? He got promoted to kernel!

Originally Posted by MutantJohn

Don't you know? He got promoted to kernel!

what does "promoted to kernel" mean?

Originally Posted by Aboulkomsan

what does "promoted to kernel" mean?

The kernel is the part of the operating system that handles memory requests made by programs. Should you fail to make a formal request for a deallocation of a block, the kernel will do it for you when the program terminates.

It's a joke about memory leaks because, I think, kernels weren't always that way.

Originally Posted by MutantJohn

The kernel is the part of the operating system that handles memory requests made by programs. Should you fail to make a formal request for a deallocation of a block, the kernel will do it for you when the program terminates.

It's a joke about memory leaks because, I think, kernels weren't always that way.

I have a lot of things to learn.