we cannot stress enough how important such traces are when designing your algorithm you can use these trace tables to verify algorithm correctness at the cost of simple tableand quick sketch of the data structure you are operating on you can devise correct algorithms quicker visualising the problem domain and keeping track of changing data makes problems lot easier to solve moreover you always have point of reference which you can look back on recursive algorithms for the most part working through recursive algorithms is as simple as walking through an iterative algorithm one of the things that we need to keep track of though is which method call returns to who most recursive algorithms are much simple to follow when you draw out the recursive calls rather than using table based approach in this section we will use recursive implementation of an algorithm that computes number from the fiboncacci sequence algorithm fibonacci( pren is the number in the fibonacci sequence to compute postthe fibonacci sequence number has been computed if return else if return end if return fibonacci( fibonacci( end fibonacci before we jump into showing you diagrammtic representation of the algorithm calls for the fibonacci algorithm we will briefly talk about the cases of the algorithm the algorithm has three cases in total > the first two items in the preceeding list are the base cases of the algorithm until we hit one of our base cases in our recursive method call tree we won' return anything the third item from the list is our recursive case with each call to the recursive case we etch ever closer to one of our base cases figure shows diagrammtic representation of the recursive call chain in figure the order in which the methods are called are labelled figure shows the call chain annotated with the return values of each method call as well as the order in which methods return to their callers in figure the return values are represented as annotations to the red arrows it is important to note that each recursive call only ever returns to its caller upon hitting one of the two base cases when you do eventually hit base case that branch of recursive calls ceases upon hitting base case you go back to