Debugging of a recursive algorithm

Question

My question is if there are some smart ways of debugging complicated recursive algorithms. Assume that we have a complicated one (not a simple case when recursion counter i

Answer 1

if you want to check for endless loops,

write a System.out.println("no its not endless"); at the next line of calling the recursive function.

if the loop would be endless, this statement wont get print, if otherwise you will see the output

Answer 2

You need to form a theory for why you think the algorithm does terminate. Ideally, prove the theory as a mathematical theorem.

You can look for a function of the problem state that does reduce on each recursive call. For example, see the following discussion of Ackermann's function, from Wikipedia

It may not be immediately obvious that the evaluation of A(m, n) always terminates. However, the recursion is bounded because in each recursive application either m decreases, or m remains the same and n decreases. Each time that n reaches zero, m decreases, so m eventually reaches zero as well. (Expressed more technically, in each case the pair (m, n) decreases in the lexicographic order on pairs, which is a well-ordering, just like the ordering of single non-negative integers; this means one cannot go down in the ordering infinitely many times in succession.) However, when m decreases there is no upper bound on how much n can increase — and it will often increase greatly.

That is the type of reasoning you should be thinking of applying to your algorithm.

If you cannot find any way to prove your algorithm terminates, consider looking for a variation whose termination you can prove. It is not always possible to decide whether an arbitrary program terminates or not. The trick is to write algorithms you can prove terminate.

Answer 3

You need to count the depth of recursive calls ... and then throw an exception if the depth of recursive calls reaches a certain threshold.

For example:

void TheMethod(object[] otherParameters, int recursiveCallDepth)
{
   if (recursiveCallDepth > 100) { 
      throw new Exception("...."); }
   TheMethod(otherParameters, ++recursiveCallDepth);
}

Answer 4

Best is proving finiteness by pre and post conditions, variants and invariants. If you can specify a (virtual) formula which value increases on every call you have a guarantee.

This is the same as proving loops to be finite. Furthermore it might make complex algorithms more tackable.

Answer 5

One suggestion is the following:

If you have endless loop then in the graph case you will obtain a path with number of vertices greater than the total number of vertices in the graph. Assuming that the number of vertices in the graph is a global variable (which, I think, is the most common case) you can do a conditional breakpoint in the beginning of the recursion if the depth is already above the total number of vertices.

Here is a link how you do conditional breakpoints for java in Eclipse.