## 1. Introduction

In first two parts of this article, we discuss recursion from a different dimension. In Recursion Primer Using C++, Part 1 we discussed how to implement the five different types of recursion at run time and compile time. Recursion Primer Using C++, Part 2 discussed the same five different types of recursion from another dimension, i.e. generative recursion and structure recursion. This article will combine all of the dimensions together, i.e. compile time/runtime and structure/generative with five different types of recursion.

## 2. Types of Recursion

### 2.1. Recursion Types on the Basis of Execution

In C++ the types of recursion can be defined in more than one dimension. In one dimension it can be categorized as run time recursion and compile time recursion using template meta-programming. Run time recursion is the most common recursion technique used in C++. This can be implemented when a C++ function (or member function) calls itself.

### 2.2. Recursion Types on the Basis of Data and Problem

Recursion can also be classified by Structure Recursion and Generative Recursion. The main difference between these are, Generative recursion usually decomposes the original problem into sub problem and solves it. For example to calculate the factorial of a given number, we calculate the factorial of a number one less than the given number and keep doing this until we reach the termination condition. In the case of a binary search, we divide the given array into 2 pieces and run the binary search on that. In this case, we eliminate half of the elements during every recursive call until we either found the required element or reach a point where we have only one element left. Now if that element is required then we found it at after Log2 (n) comparison (i.e. worst case); where "n" is the total number of elements in an array.

On the other hand Structure recursion usually performs data rather than decomposing the problem into smaller pieces. We can store data in recursive structures such as Binary Tree and in that case it would be natural to use recursion to perform an operation on it. Structure recursion is not only limited to recursive data structure, but it would be very handy in some linear structures such as Link List.

### 2.3. Recursion Types on the Basis of Algorithm

The other way to see the recursion is how the recursive algorithm is implemented. Recursive algorithm can be implemented in more than one way such as linear, tail, mutual, binary or nested recursion.

In this article we are going to study recursion types with respect to all the dimensions. It means we are going to study 20 different types of recursion. Also note that we didn't even include the template recursion, which we discussed in Recursion Primer Using C++, Part 1. We can display these three dimensions of the recursion types with this simple block diagram.

Figure 1: Dimensions of Recursion

Because this is a three dimensional type of recursion, we can't simply represent this with one table. One possible table representation is to fix one type of recursion in one table and display all other possibilities. One possible break down is break it by compile time and runtime. This is a quite logical break down because compile time recursion is not possible in all programming languages. If someone is using other than C++, the compile time table can be ignored.

Here is a table to represent different types of run time recursive algorithm.

Figure 2: Runtime Recursive Algorithms

Similarly, here is a table to represent different types of compile time recursive algorithm. These types of recursive algorithms are very specific to C++, because not every language supports compile-time recursion or template meta programming.

Figure 3: Compiletime Recursive Algorithms

This diagram shows the 20 different types of algorithms in a little bit more detail in the form of blocks.

Figure 4: Types of Recursion

## 7. Nested Recursion

This is a special type of recursion when the recursive call is nested. All of the above recursion we can replace them with either simple looping or loop with stack, but this type of recursion cannot be easily replaced by simple loop. In this type of recursion every recursive function calls another function that is also a recursive function. The nested recursive function can be the function itself or it can be another function altogether.

### 7.1. Runtime Structure Nested Recursion

Nested Link List can be a good example of Structured Nested Recursion. In simple link list every node of the Link List simply contains data as well as the address of the next node. In the case of nested link list, every node of a link list contains two addresses. The first address is just like a simple link list contains the address of next node in the link list, but the second node is an address of one more link list.

In other words, every node can contain the address of one more link list. Now the question is what might be the advantage of such a complex data structure, when we can do the same thing with two dimensional arrays? The main problem with two dimensional arrays is that every dimension should have the same length just like Matrix. We can't make a 2D array with every row containing different number of elements.

Here we have two different types of Nodes. Node is same as we studied earlier in case of Simple Link List. NestedNode has two pointers, one to store the address of the next node of the same type to create a link list of NestedNode type and other one is to store the header address of nested link list.

Here is a simple example of both types of nodes and nested recursive implementation to display the values of the nested link list. Here we have recursive TraverseNode method, which internally calls PrintNestedList method that is also a recursive function. TraverseNode prints the outer link list and PrintNestedList, as the name suggests, prints the values of nested link list.

// Node for Inner Link List struct Node { int iData; Node* pNextNode; Node() { iData = 0; pNextNode = NULL; } }; // Node for Nested Link List struct NestedNode { int iData; Node* pHead; NestedNode* pNextList; NestedNode() { iData = 0; pHead = NULL; pNextList = NULL; } }; // Print the inner link list void PrintNestedList(Node* pHead) { if (pHead != NULL) { std::cout << " -> " << pHead->iData << std::endl; PrintNestedList(pHead->pNextNode); } else return; } // Print the outer link list void TraverseNode(NestedNode* pHead) { if (pHead == NULL) return; else { std::cout << pHead->iData << std::endl; PrintNestedList(pHead->pHead); TraverseNode(pHead->pNextList); } }

Here is a simple usage of this function.

// Traverse Nested Link Recursively // Every items itself is Link List // Traverse that Link List Recursively too // to print all items in Nested Link List // Recursive function call another recursive function TraverseNode(pNested);

### 7.2. Compile Time Structure Nested Recursion

In a similar way we can create a nested link list at compile time. Here we defined two node types, just like the runtime version. In addition we have to define two different end markers, one for link list and the other for nested link list name End and NestedEnd respectively.

// Termination of Link List struct End { }; // Node of Static Link List template <int iData, typename Type> struct Node { enum { value = iData }; typedef Type Next; }; // Termination of Nested Link List struct NestedEnd { }; // Node of Nested Link List template <int iData, typename NestedType, typename Type> struct NestedNode { enum { value = iData }; typedef NestedType NestedList; typedef Type Next; };

Instead of printing the value of nested link list here we are going to count the values in link list and nested link list. Here Count is a structure that recursively instantiates itself as well as Length structure too. Length structure also instantiates itself to calculate the length of nested link list.

// Structure to calculate the length of Static Link List template <typename T> struct Length; // Partial Template Specialization call recursiveely calculate the length template <int iData, typename Type> struct Length<Node<iData, Type> > { enum { value = 1 + Length<Type>::value }; }; // Template Specialization to terminate recursion template <> struct Length<End> { enum { value = 0 }; }; // Structure to calculate the number of elements in Nested Static Link List template <typename T> struct Count; // Partial Template Specialization call recursiveely calculate the length template <int iData, typename NestedType, typename Type> struct Count<NestedNode<iData, NestedType, Type> > { enum { value = 1 + Count<Type>::value + Length<NestedType>::value }; }; template <> struct Count<NestedEnd> { enum { value = 0 }; };

Here is simple usage of these structures.

// Nested Link List // first nested link list contains elements multiple of 5 // second nested link list contains natural numbers // third nested link list contains prime number typedef NestedNode<100, Node<5, Node<10, Node<15, End> > >, NestedNode<200, Node<1, Node<2, Node<3, Node<4, Node<5, Node<6, End> > > > > >, NestedNode<300, Node<2, Node<3, Node<5, Node<7, Node<11, Node<13, Node<17, End> > > > > > >, NestedEnd> > > nestedList; std::cout << Count<nestedList>::value << std::endl;

### 7.3. Runtime Generative Nested Recursion

McCarthy function, also known as McCarthy 91 function, is a nested recursive function defined by John McCarthy. This function is proposed as a test case for formal verification of the system. This is also known as McCarthy 91 function because for every value less than 100 this function returns 91.

Here is a mathematical formula of this function.

Figure 10: McCarthy Function

Here is simple implementation of this function.

// Generative Nested Recursion int McCarthy(int no) { if (no > 100) return no - 10; else return McCarthy(McCarthy(no + 11)); }

Here is simple usage of this function.

std::cout << McCarthy(25) << std::endl;

### 7.4. Compile Time Generative Nested Recursion

One more example of a nested recursive function is Ackermann function. This function explodes very rapidly; therefore it is usually used to check the compiler's ability to optimize recursion. Here is mathematical formula for Ackermann function.

Figure 11: Ackermann Function

This is simple compile time implementation of this nested function.

template <int m, int n> struct Ackermann { // nested recursive call enum { value = Ackermann<m-1, Ackermann<m, n-1>::value>::value }; }; template <int m> struct Ackermann<m, 0> { // linear recursive call enum { value = Ackermann<m-1, 1>::value }; }; // termination condition template <int n> struct Ackermann<0, n> { enum { value = n + 1 }; };

Here is a usage of this function.

std::cout << Ackermann<2, 3>::value << std::endl;

## 8. References

- A Gentle Introduction to Mutual Recursion

Manuel Rubio-Sanchez, Jaime Urquiza-Fuentes, Cristobal Pareja-Flores

Proceedings of the 13th annual conference on Innovation and technology in computer science education, June 30-July 2, 2008, Madrid, Spain. - Concrete Mathematics 2nd edition

Ronald L. Graham, Donald E Knuth, Oren Patashnik - Recursion Primer Using C++: Part 1

Zeeshan Amjad

http://www.codeproject.com/KB/cpp/Recursion_Prmr_CPP_01.aspx

http://www.codeguru.com/cpp/cpp/algorithms/math/article.php/c15111/ - Recursion Primer Using C++: Part 2

Zeeshan Amjad

http://www.codeproject.com/KB/cpp/Recursion_Prmr_CPP_02.aspx

http://www.codeguru.com/cpp/cpp/algorithms/math/print.php/c15693__4/