如何在不将级别作为参数传递给 function 的情况下找到二叉树中节点的级别？

Question

This is the code to find the level while passing level as an argument to the function.

int findLevel(node* root, node* ptr,
    int level = 0) {
if (root == NULL)
    return -1;
if (root == ptr)
    return level;
// If NULL or leaf Node
if (root->left == NULL && root->right == NULL)
    return -1;
// Find If ptr is present in the left or right subtree.
int levelLeft = findLevel(root->left, ptr, level + 1);
int levelRight = findLevel(root->right, ptr, level + 1);
if (levelLeft == -1)
    return levelRight;
else
    return levelLeft;}

But how to find without passing level as an argument? Should I have level in my node struct? How to initialize it then?

This is my struct and insert right now:

typedef struct Node{
    int value;
    bst left;
    bst right;
} node;

node* bst_insert (node* root, int value){
    if(root == NULL){
        root = (node*) malloc(sizeof(node));
        root->value = value;
        root->left = NULL;
        root->right = NULL;
    }
    else{
        if(value > root->value)
            root->right = bst_insert(root->right, value);
        else
            root->left = bst_insert(root->left, value);
    }

    return root;
}

Answer 1

Your best option is probably to convert you recursive algorithm to an iterative version. Then you can store the level in a local variable, and keep track of your search path using a stack (for depth first search (DFS)).

You can, as you mentioned, store the level in each node, but that is technically passing it as an argument. On insert, you set the level of the new node to the level of the parent + 1. Here is a minimal implementation of this idea:

#include <assert.h>
#include <stdlib.h>

struct node;

struct node {
    int value;
    int level;
    struct node *left;
    struct node *right;
};

struct node *node_new(int value, int level) {
    struct node *n = malloc(sizeof(struct node));
    assert(n);
    n->value = value;
    n->level = level;
    n->left = 0;
    n->right = 0;
    return n;
}

void node_insert(struct node **current, int value) {
    // leaf
    struct node **next = value < (*current)->value ? &(*current)->left : &(*current)->right;
    if(!*next) {
        *next = node_new(value, (*current)->level + 1);
        return;
    }

    // non-leaf
    node_insert(next, value);
}

int main() {
    struct node *root = node_new(10, 0);
    node_insert(&root, 5);
    node_insert(&root, 20);
    node_insert(&root, 30);
}