Converting an iterative function into recursive - recursion

Question

One of the hardest concepts I've found in programming has been recursion. I have been trying to convert this function into a recursive call for 2 days now, but I just can't get it to work. Its a delete function for a BST
public void deleteByMerging(T el) {
BSTNode<T> tmp, node, p = root, prev = null;
while (p != null && !p.el.equals(el)) { // find the node p
prev = p; // with element el;
if (el.compareTo(p.el) < 0)
p = p.right;
else p = p.left;
}
node = p;
if (p != null && p.el.equals(el)) {
if (node.right == null) // node has no right child: its left
node = node.left; // child (if any) is attached to its parent;
else if (node.left == null) // node has no left child: its right
node = node.right; // child is attached to its parent;
else { // be ready for merging subtrees;
tmp = node.left; // 1. move left
while (tmp.right != null) // 2. and then right as far as
tmp = tmp.right; // possible;
tmp.right = // 3. establish the link between
node.right; // the rightmost node of the left
// subtree and the right subtree;
node = node.left; // 4.
}
if (p == root)
root = node;
else if (prev.left == p)
prev.left = node;
else prev.right = node; // 5.
}
else if (root != null)
System.out.println("el " + el + " is not in the tree");
else System.out.println("the tree is empty");
}
I got it as far as to find the node, but steps 1 through 5 (in comments) really breaks my brain.

Answer 1

First of all, you need to "find" the node. Let's try to think in recursive way:
function find(el, p)
if p == null, not found! (return p, i.e. null)
if p.el == el, found! (return p)
if el < p.el, return find(el, p.right)
if el > p.el, return find(el, p.left)
This is recursive, right? So, BSTNode<T> node = find(el, root) will return either the node that matches el or return null which implies NOT FOUND.
The remaining delete by merge only manages object reference, so I'm not to comment.

Answer 2

I think there is some problem with the merging algorithm steps 3 and 4. Imagine you are deleting a node with left and right subtree. The empty space is replaced with a node that must satisfy the BST condition (ie. greater than left node and smaller than right node). That replacement node is found in the rightmost left subtree (Step 2 of comments). That node is pointed to by tmp. So now we have "node" which points to the node being deleted and "tmp" which points to the replacement node. In Step 3, this is where the linking happens.
tmp.right = node.right
tmp.left = node.left // missing from the algorithm
Now in Step 4, this is where the "node" variable is changed to point to the replacement node "tmp" so in Step 5, the previous node "prev" can link to the replacement node. I believe Step 4 should be
node = tmp;
instead of
node = node.left;
Please check if my analysis is correct. Maybe that's why you're not able to understand what's going on. The recursive part of the deleteByMerging() is the searching for the node to delete. Once found, the algorithm to merge the tree would not change.