Different Types of Recursion in Golang

Recursion is a concept where a function calls itself by direct or indirect means. Each call to the recursive function is a smaller version so that it converges at some point. Every recursive function has a base case or base condition which is the final executable statement in recursion and halts further calls.

There are different types of recursion as explained in the following examples:

1. Direct Recursion

Type of recursion where the function calls itself directly, without the assistance of another function is called a direct recursion. The following example explains the concept of direct recursion:

Example:

filter_none

edit
close

play_arrow

link
brightness_4
code

// Golang program to illustrate the
// concept of direct recursion
package main
  
import (
    "fmt"
)
  
// recursive function for 
// calculating a factorial 
// of a positive integer
func factorial_calc(number int) int {
  
    // this is the base condition
    // if number is 0 or 1 the
    // function will return 1
    if number == 0 || number == 1 {
        return 1
    }
      
    // if negative argument is 
    // given, it prints error
    // message and returns -1
    if number < 0 {
        fmt.Println("Invalid number")
        return -1
    }
      
    // recursive call to itself
    // with argument decremented 
    // by 1 integer so that it
    // eventually reaches the base case
    return number*factorial_calc(number - 1)
}
  
// the main function
func main() {
  
    // passing 0 as a parameter
    answer1 := factorial_calc(0)
    fmt.Println(answer1, "\n")
      
    // passing a positive integer
    answer2 := factorial_calc(5)
    fmt.Println(answer2, "\n")
      
    // passing a negative integer
    // prints an error message
    // with a return value of -1
    answer3 := factorial_calc(-1)
    fmt.Println(answer3, "\n")
      
    // passing a positive integer
    answer4 := factorial_calc(10)
    fmt.Println(answer4, "\n")
}

chevron_right


Output:



1 

120 

Invalid number
-1 

3628800

2. Indirect Recursion

The type of recursion where the function calls another function and this function, in turn, calls the calling function is called an indirect recursion. This type of recursion takes the assistance of another function. The function does call itself, but indirectly, i.e., through another function. The following example explains the concept of indirect recursion:

Example:

filter_none

edit
close

play_arrow

link
brightness_4
code

// Golang program to illustrate the
// concept of indirect recursion
package main
  
import (
    "fmt"
)
  
// recursive function for 
// printing all numbers 
// upto the number n
func print_one(n int) {
      
    // if the number is positive
    // print the number and call 
    // the second function
    if n >= 0 {
        fmt.Println("In first function:", n)
        // call to the second function
        // which calls this first
        // function indirectly
        print_two(n - 1)
    }
}
  
func print_two(n int) {
  
    // if the number is positive
    // print the number and call 
    // the second function
    if n >= 0 {
        fmt.Println("In second function:", n)
        // call to the first function
        print_one(n - 1)
    }
}
  
// main function
func main() {
      
    // passing a positive 
    // parameter which prints all 
    // numbers from 1 - 10
    print_one(10)
      
    // this will not print
    // anything as it does not
    // follow the base case
    print_one(-1)
}

chevron_right


Output:

In first function: 10
In second function: 9
In first function: 8
In second function: 7
In first function: 6
In second function: 5
In first function: 4
In second function: 3
In first function: 2
In second function: 1
In first function: 0

Note: An indirect recursion with only 2 functions is called mutual recursion. There can be more than 2 functions to facilitate indirect recursion.

3. Tail Recursion

A tail call is a subroutine call which is the last or final call of the function. When a tail call performs a call to the same function, the function is said to be tail-recursive. Here, the recursive call is the last thing executed by the function.

Example:

filter_none

edit
close

play_arrow

link
brightness_4
code

// Golang program to illustrate the
// concept of tail recursion
package main
  
import (
    "fmt"
)
  
// tail recursive function
// to print all numbers 
// from n to 1
func print_num(n int) {
      
    // if number is still 
    // positive, print it
    // and call the function
    // with decremented value
    if n > 0 {
        fmt.Println(n)
          
        // last statement in 
        // the recursive function
        // tail recursive call
        print_num(n-1)
    }
}
  
// main function
func main() {
      
    // passing a positive 
    // number, prints 5 to 1
    print_num(5)
}

chevron_right


Output:

5
4
3
2
1

4. Head Recursion

In a head recursion, the recursive call is the first statement in the function. There is no other statement or operation before the call. The function does not have to process anything at the time of calling and all operations are done at returning time.



Example:

filter_none

edit
close

play_arrow

link
brightness_4
code

// Golang program to illustrate the
// concept of head recursion
package main
  
import (
    "fmt"
)
  
// head recursive function
// to print all numbers 
// from 1 to n
func print_num(n int) {
      
    // if number is still 
    // less than n, call 
    // the function
    // with decremented value
    if n > 0 {
          
        // first statement in 
        // the function
        print_num(n-1)
          
        // printing is done at
        // returning time
        fmt.Println(n)
    }
}
  
// main function
func main() {
      
    // passing a positive 
    // number, prints 5 to 1
    print_num(5)
}

chevron_right


Output:

1
2
3
4
5

Note: Output of head recursion is exactly the reverse of that of tail recursion. This is because the tail recursion first prints the number and then calls itself, whereas, in head recursion, the function keeps calling itself until it reaches the base case and then starts printing during returning.

5. Infinite Recursion

All the recursive functions were definite or finite recursive functions, i.e., they halted on reaching a base condition. Infinite recursion is a type of recursion that goes on until infinity and never converges to a base case. This often results in system crashing or memory overflows.

Example:

filter_none

edit
close

play_arrow

link
brightness_4
code

// Golang program to illustrate the
// concept of infinite recursion
package main
  
import (
    "fmt"
)
  
// infinite recursion function
func print_hello() {
      
    // printing infinite times
    fmt.Println("GeeksforGeeks")
    print_hello()
}
  
// main function
func main() {
      
    // call to infinite 
    // recursive function
    print_hello()
}

chevron_right


Output:

GeeksforGeeks
GeeksforGeeks
GeeksforGeeks
..... infinite times

6. Anonymous Function Recursion

In Golang, there is a concept of functions which do not have a name. Such functions are called anonymous functions. Recursion can also be carried out using anonymous functions in Golang as shown below:

Example:

filter_none

edit
close

play_arrow

link
brightness_4
code

// Golang program to illustrate 
// the concept of anonymous 
// function recursion
package main
  
import (
    "fmt"
)
  
// main function
func main() {
      
    // declaring anonymous function
    // that takes an integer value
        var anon_func func(int)
           
    // defining an anonymous
    // function that prints
    // numbers from n to 1
        anon_func = func(number int) {
      
        // base case
            if number == 0 {
                    return 
            } else {
            fmt.Println(number)
              
            // calling anonymous 
            // function recursively
                    anon_func(number-1)
            }
        }
      
    // call to anonymous 
    // recursive function
        anon_func(5)
}

chevron_right


Output:

5
4
3
2
1

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.


Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.