Question

I have two algorithms here that mirror a BST. Both of them work fine, however as far as I understand the second one is recursive and the first one is tail recursive. I know in Java, the compiler doesn’t optimize for tail recursion, but my question is — in any other language, what would be the better algorithm out of these two? Is this too subjective of a question?

public Node mirror(Node root, Node newRoot) {
    newRoot.item = root.item;
    if (root.right != null) {
        newRoot.left = new Node();
        newRoot.left.item = root.right.item;
        mirror(root.right, newRoot.left);
    }
    if (root.left != null) {
        newRoot.right = new Node();
        newRoot.right.item = root.left.item;
        mirror(root.left, newRoot.right);
    }
    return newRoot;
}

///VERSION 2////

public Node mirror(Node currentNode) {
    if (currentNode == null) {
        return null;
    } else {
        Node newnode = new Node();
        newnode.item = currentNode.item;
        newnode.left = mirror(currentNode.right);
        newnode.right = mirror(currentNode.left);
        return newnode;
    }
}

Answer 1

A few things:

First, many imperative languages don’t optimize for tail recursion. That’s something very common for functional languages, and you should use one of those if you want this feature. Scala might be a good move, since it uses the JVM. Also, with Scala you need to specifically annotate what you want to make tail recursive

Second, the second piece of code isn’t tail recursive. Tail recursion is a fairly strong requirement: the recursive call must be the very last thing executed if the code were interpreted in continuation passing style. In practice, what that means is that your return statement must be the only thing that does recursion. For example, in C-like pseudocode:

int factorial(int x) {
  if (x == 0) return 1;
  else return x*factorial(x-1);
}

This is not tail recursive because the multiplication needs to be done after the recursive call but before the return statement. Here is a tail recursive version:

int factorial_helper(int acc, int x) {
   if (x == 0) return acc;
   else return factorial_helper(acc*x, x-1);
}

int factorial(int x) { return factorial_helper(1, x); }

You can see in factorial_helper that the value returned by the recursive call is exactly the value returned by the function — and that’s what make this tail recursive.

In your second algorithm, there are two recursive calls. In each recursive call the address of the mirrored tree is stored in the newnode. Then the address of the newnode is returned (Java secretly has pointers). So, this is not written tail-recursively because you’re not returning the exact result of your recursive call.

Third: for something like this, the best way to see which performs better is to run both and benchmark :). I don’t see any clear winner from the algorithms alone (maybe someone else does?). It doesn’t look like there’s going to be any asymptotic difference, although rewriting this to be actually tail recursive may speed things up.