使用递归DFS在二叉树中查找节点

Question

I have to use DFS to search a binary tree to find a node. (tok is the string I'm searching for). If it finds it, it has to return the number of nodes it traversed to find it. If it doesn't then it has to return -1.

I have tried many recursive solutions but honestly, I'm stumped. I may not be returning values correctly.

Test case: Lets say i have a tree with the root called "John"."John" as a left child "Shayne" and a right child "Eric". Additionally, "Shayne" has a left child "Max". The output would be correct for John,Shayne and Max. But the output of Eric should be 4, since i traverse john and then shayne and then max and then Eric (considering im going left first and then right), but for Eric, im getting the output of 3

Edited with exact test case.

#include <stdio.h>

#include <stdlib.h>
#include <string.h>

struct node {
    char* name;
    char* tea;
    struct node* left;
    struct node* right;
};

typedef struct node Node;

int depth(struct node* root);
int dfs(struct node* root, char* tok);

int main() {

    Node* John = (Node*)malloc(sizeof(Node));
    John->left = NULL;
    John->right = NULL;
    John->name = "John";
    Node* Shayne = (Node*)malloc(sizeof(Node));
    Shayne->left = NULL;
    Shayne->right = NULL;
    Shayne->name = "Shayne";
    Node* Eric = (Node*)malloc(sizeof(Node));
    Eric->left = NULL;
    Eric->right = NULL;
    Eric->name = "Eric";
    Node* Max = (Node*)malloc(sizeof(Node));
    Max->left = NULL;
    Max->right = NULL;
    Max->name = "Max";

    John->left = Shayne;
    Shayne->left = Max;
    John->right = Eric;

    printf("%d",dfs(John,"Eric"));
}

int depth(struct node* root) {


    if (root == NULL) {
        return 0;
    }
    int l = depth(root->left);
    int r = depth(root->right);
    int d = max(l, r) + 1;
    return d;



}


int dfs(struct node* root, char* tok) {


    if (root == NULL) {
        return 0;
    }
    if (strcmp(root->name, tok) == 0) {
        return 1;
    }
    else {
        int l = dfs(root->left, tok);
        if (l != -1) {
            return 1 + l;
        }
        int r = dfs(root->right, tok);
        if (r != -1) {
            return 1+l+ r;
        }
        return -1;
    }
}

Answer 1

You correctly add 1 to the return value when the value has been found in an immediate child to produce the number of nodes. But it also means that you will return 2 to your parent.

You have to change your test to

if (l != -1) { //found on left child
        return 1 + l;
    }

Answer 2

The only problem with your function is that when you are returning from the child node you are always checking the value of l with 1 for instance:

int l = dfs(root->left, tok);
    if (l == 1) { //found on left child
        return 1 + l;
    }

which will work fine for the first 2 nodes but then the value of the return becomes 2,3,4,.... in that case it will skip the if and return -1 again, so to solving this problem a good approach will be to check if the return value is not -1, for example:

int l = dfs(root->left, string);
    if (l != -1) { 
        return 1 + l;
    }
    int r = dfs(root->right, string);
    if (r != -1) { 
        return 1 + r;
    }

Hope this gives you the answer.