为什么使用function需要返回指针？

Question

I'm trying to write a code to insert nodes in binary search tree using a function insert_elements . In my textbook the code for the function is-

struct node *root;
int main(){
    root = insert_elements(root, val); // val is the value to be inserted
    return 0;
}
struct node *insert_elements(struct node *root, int val){
    // code to insert node
    return root;
}

I don't understand why we are returning the root pointer in the function insert_elements , why we don't change the function returning value to void and return nothing! Will be grateful for any king of help.

Answer 1

Usually you do something like that because the insert operation can change what the root element is. For example, the root element may be NULL until you perform the first insert. A balanced tree like a red-black tree occasionally needs to be shuffled after an insert, which changes the value of the root.

It can also make some operations more convenient, like immediately using that new root value in a larger expression:

if ( (newroot = insert( root, val )) == NULL )
  // error on insert
else
  // do something with newroot

An alternative to returning the root value is to pass a pointer and modify the parameter:

void insert( struct node **root, int val )
{
  if ( !*root )
    *root = new_node( val );
  else
    ...
}

Answer 2

an insert might change the root of the tree and should be set to the "root" reference.
Best example is 'inserting the first node will make it the root node';

another way to do that is declare something like
void insert_elements(struct node** root, int val);
note the "pointer to node*" passed, that can change the caller's reference instead of returning the "new root"

node* myTree;
insert_element(&myTree, xVal);

Answer 3

This declaration in the file scope

struct node *root;

initialize the pointer root by NULL .

Now in this call

insert_elements(root, val)

a copy of the value of the pointer root is passed to the function. That is the argument is passed by value. The function deals with a copy of the pointer root defined in the file scope.

Changing the copy within the function does not influence on the original pointer root . So after the function call the pointer root will still have the value NULL .

So the function returns the new pointer of a dynamically allocated node within the function that will be assigned to the pointer root defined in the file scope.

root = insert_elements(root, val);

Another approach is to pass the pointer root to the function by reference. In C passing by reference measn passing an object indirectly through a pointer to it. So the function can be declared like for example

void insert_elements(struct node **root, int val);

and called like

insert_elements( &root, val );

In this case dereferencing the pointer to the pointer root (that is dereferencing the function parameter) within the function you will get a direct access to the pointer root defined in the file scope and can change it within the function.

To make it clear consider the following demonstrative program.

#include <stdio.h>
#include <stdlib.h>

void f( int *p )
{
    p = malloc( sizeof( int ) );
    
    *p = 20;
}

int main(void) 
{
    int x = 10;
    int *px = &x;
    
    printf( "Before the call of f *px = %d\n", *px );
    
    f( px );
    
    printf( "After  the call of f *px = %d\n", *px );

    return 0;
}

The program output is

Before the call of f *px = 10
After  the call of f *px = 10

As you see the pointer px defined in main was not changed. You can imagine the function call and the function definition the following way

f( px );

//...

void f( /* int *p */ )
{
    int *p = px;

    p = malloc( sizeof( int ) );
    
    *p = 20;
}

That is the parameter p is initialized by the value of the function argument px and then the parameter is reassigned with the address of the dynamically allocated memory. The argument px was not changed.