使用二叉树的级别顺序递归查找节点 - C

Question

In C, I need to recursively search through a Binary Tree (max heap) to find if a node is in the heap, and then return a pointer to that node, or NULL if not found. My recursive function always seems to recurs through the whole tree even after I find the value and try to return the node. I can never seem to quite wrap my head around recursion and have been stuck on this for a while. Here is my original code / pseudo code if anyone can point out if I'm logically thinking about this wrong.

Node* find_node(Heap *max_heap, int *key) {

Node *node = NULL;

node = find_node_aux(root, key);

return node;`
}`



 Node* find_node_aux(Node, key) {


if (node == NULL)
    return NULL;
if (Node == Key) {
    return node;
}

if (node->left != NULL)
    find_node_aux(node->left, d);
    
if (node->right != NULL)
    find_node_aux(node->right, d);


return NULL;
}

I think my issue with recursion is that i treat it like a loop when its not really. And I also realized i wasn't returning anything on the recursion, so i switched up my code to this

if (node == NULL)
        return NULL;
     
    if (node != key) {
        if (node->left != NULL)
            node = find_node_aux(node->left, d);
        if (node->right != NULL)
            node = find_node_aux(node->right, d);

}

return node;
}

but it always stops and returns the same node in the tree for some reason. I know this question is probably simple but i really struggle with recursion. (i know the indenting probably looks weird its just the way i entered into this question, im more confused about the logic)

Answer 1

• If the node you are seeking isn't in the left half, you are clobbering node before checking the right half.
• If the node you are seeking is in left half, you are proceed to try to search the right half of the tree too, clobbering node in the process.

Fixed:

if (node == NULL)
   return NULL;

if (node.value == value)
   return node;

if (node->left) {
   Node *found = find_node(node->left, value);
   if (found)
      return found;
}

if (node->right) {
   Node *found = find_node(node->right, value);
   if (found)
      return found;
}

return NULL;

The following is another approach:

1. If the tree is empty,
   1. Return NULL.
2. Create a to-visit stack.
3. Push the root node onto the stack.
4. While the stack isn't empty,
   1. Pop a node from the stack.
   2. If the node is the one being sought,
      1. Free the stack.
      2. Return the node.
   3. If the node has a left child,
      1. Push the left child onto the stack.
   4. If the node has a right child,
      1. Push the right child onto the stack.
5. Free the stack.
6. Return NULL.

They're really two versions of the same approach. The former simply uses the call stack as the to-visit stack.

There's a problem. Both of the above perform a depth-first search, but you said you wanted to use a breadth-first search (level-order traversal). A very small change is needed to the algorithm presented above to achieve this: Use a queue instead of stack.

1. If the tree is empty,
   1. Return NULL.
2. Create a to-visit queue.
3. Enqueue the root node onto the queue.
4. While the queue isn't empty,
   1. Dequeue a node from the queue.
   2. If the node is the one being sought,
      1. Free the queue.
      2. Return the node.
   3. If the node has a left child,
      1. Enqueue the left child onto the queue.
   4. If the node has a right child,
      1. Enqueue the right child onto the queue.
5. Free the queue.
6. Return NULL.

Since recursion provides a stack, recursion isn't useful here.