指向 C++ 中结构的指针

Question

I am trying to solve the Problem Populate Inorder Successor for all nodes in a BST on GFG. Some Code is given (not able to paste here as it shows so much code in here)

and I need to code the populateNext(node* p) where p is the root node of tree. I coded the function as below but it is not working and giving output as 3->-1 instead of 3->8 8->10 10->12 12->-1

void populateNext(struct node* p)
{
    static node* x=NULL;
    if(p==NULL) return;
    populateNext(p->right);
    p->next=x;
    x=p;\
    populateNext(p->left);
}

I think the x node created is never modified so the pointer in main function ptr in not moving forward. Then I looked for more solutions and found a similar one with a double pointer. I don't know why is mine one not working but the below one is working.

void find(struct node* root,struct node **nextr)
{
    if(root)
    {
        find(root->right,nextr);
        
        root->next = *nextr;
        
        *nextr = root;
        
        find(root->left,nextr);
    }
}
void populateNext(struct node* p)
{
   struct node* next = NULL;
   find(p,&next);
}

I know that pointer x is storing the address of struct variable and with every function call, I am assigning my pointer a new node pointer so it should work. I tried declaring the node x as global too but still the same answer 3->-1 .

I tried searching about pointer to pointer for structs but everywhere only how to do it is given. I want to ask why code is not working for single pointer and why it worked for pointer to pointer and what is the use of pointer to pointers ie why we use is? What are the limitations of single pointer?

Answer 1

Better name, than double pointer, is pointer to pointer . It means, that you are allocating 4 bytes (in 32-bit systems) to hold address of something. It is up to the programmer what it is. If you use pointer to pointer, you are holding address of other address, which may hold the other address of something (like this struct). Any combinations may be done.

In the first attempt, each recursive call has it's own x variable - this is wrong. The algorithm need the common nextr variable, which is allocated only once, and used on every recursion level. This is why your program starts to work.

The second attempt allocated next address on the stack, initialized with NULL . This address was passed to the recursive find function ( &next ), which in turn know were it is, and write to it ( *nextr = root ). This write made on the stack-allocated next variable from populateNext , like on the every find call.