Open In App
Related Articles
• Write an Interview Experience
• Share Your Campus Experience
• Mathematical Algorithms

# Program for nth Catalan Number

Catalan numbers are defined as a mathematical sequence that consists of positive integers, which can be used to find the number of possibilities of various combinations.

The nth term in the sequence denoted Cn, is found in the following formula:

The first few Catalan numbers for n = 0, 1, 2, 3, … are : 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, …

Catalan numbers occur in many interesting counting problems like the following.

1. Count the number of expressions containing n pairs of parentheses that are correctly matched. For n = 3, possible expressions are ((())), ()(()), ()()(), (())(), (()()).
2. Count the number of possible Binary Search Trees with n keys (See this)
3. Count the number of full binary trees (A rooted binary tree is full if every vertex has either two children or no children) with n+1 leaves.
4. Given a number n, return the number of ways you can draw n chords in a circle with 2 x n points such that no 2 chords intersect.

See this for more applications.

Examples:

Input: n = 6
Output: 132

Input: n = 8
Output: 1430

## Recursive Solution for Catalan number:

Catalan numbers satisfy the following recursive formula:

Follow the steps below to implement the above recursive formula

• Base condition for the recursive approach, when n <= 1, return 1
• Iterate from i = 0 to i < n
• Make a recursive call catalan(i) and catalan(n – i – 1) and keep adding the product of both into res.
• Return the res.

Following is the implementation of the above recursive formula.

## C++

 #include using namespace std; // A recursive function to find nth catalan numberunsigned long int catalan(unsigned int n){    // Base case    if (n <= 1)        return 1;     // catalan(n) is sum of    // catalan(i)*catalan(n-i-1)    unsigned long int res = 0;    for (int i = 0; i < n; i++)        res += catalan(i) * catalan(n - i - 1);     return res;} // Driver codeint main(){    for (int i = 0; i < 10; i++)        cout << catalan(i) << " ";    return 0;}

## Java

 import java.io.*; class CatalnNumber {     // A recursive function to find nth catalan number     int catalan(int n)    {        int res = 0;         // Base case        if (n <= 1) {            return 1;        }        for (int i = 0; i < n; i++) {            res += catalan(i) * catalan(n - i - 1);        }        return res;    }     // Driver Code    public static void main(String[] args)    {        CatalnNumber cn = new CatalnNumber();        for (int i = 0; i < 10; i++) {            System.out.print(cn.catalan(i) + " ");        }    }}

## Python3

 # A recursive function to# find nth catalan number  def catalan(n):    # Base Case    if n <= 1:        return 1     # Catalan(n) is the sum    # of catalan(i)*catalan(n-i-1)    res = 0    for i in range(n):        res += catalan(i) * catalan(n-i-1)     return res  # Driver Codefor i in range(10):    print(catalan(i), end=" ")# This code is contributed by# Nikhil Kumar Singh (nickzuck_007)

## C#

 // A recursive C# program to find// nth catalan numberusing System; class GFG {     // A recursive function to find    // nth catalan number    static int catalan(int n)    {        int res = 0;         // Base case        if (n <= 1) {            return 1;        }        for (int i = 0; i < n; i++) {            res += catalan(i) * catalan(n - i - 1);        }        return res;    }     // Driver Code    public static void Main()    {        for (int i = 0; i < 10; i++)            Console.Write(catalan(i) + " ");    }} // This code is contributed by// nitin mittal.

## PHP

 

## Javascript

 

Output

1 1 2 5 14 42 132 429 1430 4862

Time Complexity: The above implementation is equivalent to nth Catalan number.

The value of nth Catalan number is exponential which makes the time complexity exponential.
Auxiliary Space: O(n)

## Dynamic Programming Solution for Catalan number:

We can observe that the above recursive implementation does a lot of repeated work. Since there are overlapping subproblems, we can use dynamic programming for this.

Below is the implementation of the above idea:

• Create an array catalan[] for storing ith Catalan number.
• Initialize, catalan[0] and catalan[1] = 1
• Loop through i = 2 to the given Catalan number n.
• Loop through j = 0 to j < i and Keep adding value of catalan[j] * catalan[i – j – 1] into catalan[i].
• Finally, return catalan[n]

Follow the steps below to implement the above approach:

## C++

 #include using namespace std; // A dynamic programming based function to find nth// Catalan numberunsigned long int catalanDP(unsigned int n){    // Table to store results of subproblems    unsigned long int catalan[n + 1];     // Initialize first two values in table    catalan[0] = catalan[1] = 1;     // Fill entries in catalan[] using recursive formula    for (int i = 2; i <= n; i++) {        catalan[i] = 0;        for (int j = 0; j < i; j++)            catalan[i] += catalan[j] * catalan[i - j - 1];    }     // Return last entry    return catalan[n];} // Driver codeint main(){    for (int i = 0; i < 10; i++)        cout << catalanDP(i) << " ";    return 0;}

## Java

 import java.io.*;class GFG {     // A dynamic programming based function to find nth    // Catalan number    static int catalanDP(int n)    {        // Table to store results of subproblems        int catalan[] = new int[n + 2];         // Initialize first two values in table        catalan[0] = 1;        catalan[1] = 1;         // Fill entries in catalan[]        // using recursive formula        for (int i = 2; i <= n; i++) {            catalan[i] = 0;            for (int j = 0; j < i; j++) {                catalan[i]                    += catalan[j] * catalan[i - j - 1];            }        }         // Return last entry        return catalan[n];    }     // Driver code    public static void main(String[] args)    {        for (int i = 0; i < 10; i++) {            System.out.print(catalanDP(i) + " ");        }    }}// This code contributed by Rajput-Ji

## Python3

 # A dynamic programming based function to find nth# Catalan number  def catalan(n):    if (n == 0 or n == 1):        return 1     # Table to store results of subproblems    catalan = [0]*(n+1)     # Initialize first two values in table    catalan[0] = 1    catalan[1] = 1     # Fill entries in catalan[]    # using recursive formula    for i in range(2, n + 1):        for j in range(i):            catalan[i] += catalan[j] * catalan[i-j-1]     # Return last entry    return catalan[n]  # Driver codefor i in range(10):    print(catalan(i), end=" ")# This code is contributed by Ediga_manisha

## C#

 using System; class GFG {     // A dynamic programming based    // function to find nth    // Catalan number    static uint catalanDP(uint n)    {        // Table to store results of subproblems        uint[] catalan = new uint[n + 2];         // Initialize first two values in table        catalan[0] = catalan[1] = 1;         // Fill entries in catalan[]        // using recursive formula        for (uint i = 2; i <= n; i++) {            catalan[i] = 0;            for (uint j = 0; j < i; j++)                catalan[i]                    += catalan[j] * catalan[i - j - 1];        }         // Return last entry        return catalan[n];    }     // Driver code    static void Main()    {        for (uint i = 0; i < 10; i++)            Console.Write(catalanDP(i) + " ");    }} // This code is contributed by Chandan_jnu

## PHP

 

## Javascript

 

Output

1 1 2 5 14 42 132 429 1430 4862

Time Complexity: O(n2)
Auxiliary Space: O(n)

## Binomial Coefficient  Solution for Catalan number:

We can also use the below formula to find nth Catalan number in O(n) time.

Here is the proof for the Expression:–

This is the expression for which we are going to see the proof

In the pascal triangle,

1
1         1
1        2        1
1       3         3       1
1      4         6       4         1
1     5         10     10       5         1

Pascal’s triangle as binomial coefficients

the formula for a cell of Pascal’s triangle

Pascal’s triangle

.

.

.

Below are the steps for calculating nCr.

• Create a variable to store the answer and change r to n – r if r is greater than n – r because we know that C(n, r) = C(n, n-r) if r > n – r
• Run a loop from 0 to r-1
• In every iteration update ans as (ans*(n-i))/(i+1), where i is the loop counter.
• So the answer will be equal to ((n/1)*((n-1)/2)*…*((n-r+1)/r), which is equal to nCr.

Below are steps to calculate Catalan numbers using the formula: 2nCn/(n+1)

• Calculate 2nCn using the similar steps that we use to calculate nCr
• Return the value 2nCn/ (n + 1)\

Below is the implementation of the above approach:

## C++

 // C++ program for nth Catalan Number#include using namespace std; // Returns value of Binomial Coefficient C(n, k)unsigned long int binomialCoeff(unsigned int n,                                unsigned int k){    unsigned long int res = 1;     // Since C(n, k) = C(n, n-k)    if (k > n - k)        k = n - k;     // Calculate value of [n*(n-1)*---*(n-k+1)] /    // [k*(k-1)*---*1]    for (int i = 0; i < k; ++i) {        res *= (n - i);        res /= (i + 1);    }     return res;} // A Binomial coefficient based function to find nth catalan// number in O(n) timeunsigned long int catalan(unsigned int n){    // Calculate value of 2nCn    unsigned long int c = binomialCoeff(2 * n, n);     // return 2nCn/(n+1)    return c / (n + 1);} // Driver codeint main(){    for (int i = 0; i < 10; i++)        cout << catalan(i) << " ";    return 0;}

## Java

 // Java program for nth Catalan Number class GFG {     // Returns value of Binomial Coefficient C(n, k)    static long binomialCoeff(int n, int k)    {        long res = 1;         // Since C(n, k) = C(n, n-k)        if (k > n - k) {            k = n - k;        }         // Calculate value of [n*(n-1)*---*(n-k+1)] /        // [k*(k-1)*---*1]        for (int i = 0; i < k; ++i) {            res *= (n - i);            res /= (i + 1);        }         return res;    }     // A Binomial coefficient based function    //  to find nth catalan number in O(n) time    static long catalan(int n)    {        // Calculate value of 2nCn        long c = binomialCoeff(2 * n, n);         // return 2nCn/(n+1)        return c / (n + 1);    }     // Driver code    public static void main(String[] args)    {        for (int i = 0; i < 10; i++) {            System.out.print(catalan(i) + " ");        }    }}

## Python3

 # Python program for nth Catalan Number# Returns value of Binomial Coefficient C(n, k)  def binomialCoefficient(n, k):     # since C(n, k) = C(n, n - k)    if (k > n - k):        k = n - k     # initialize result    res = 1     # Calculate value of [n * (n-1) *---* (n-k + 1)]    # / [k * (k-1) *----* 1]    for i in range(k):        res = res * (n - i)        res = res / (i + 1)    return res # A Binomial coefficient based function to# find nth catalan number in O(n) time  def catalan(n):    c = binomialCoefficient(2*n, n)    return c/(n + 1)  # Driver Codefor i in range(10):    print(catalan(i), end=" ") # This code is contributed by Aditi Sharma

## C#

 // C# program for nth Catalan Numberusing System;class GFG {     // Returns value of Binomial Coefficient C(n, k)    static long binomialCoeff(int n, int k)    {        long res = 1;         // Since C(n, k) = C(n, n-k)        if (k > n - k) {            k = n - k;        }         // Calculate value of [n*(n-1)*---*(n-k+1)] /        // [k*(k-1)*---*1]        for (int i = 0; i < k; ++i) {            res *= (n - i);            res /= (i + 1);        }         return res;    }     // A Binomial coefficient based function to find nth    // catalan number in O(n) time    static long catalan(int n)    {        // Calculate value of 2nCn        long c = binomialCoeff(2 * n, n);         // return 2nCn/(n+1)        return c / (n + 1);    }     // Driver code    public static void Main()    {        for (int i = 0; i < 10; i++) {            Console.Write(catalan(i) + " ");        }    }} // This code is contributed// by Akanksha Rai

## PHP

  $n - $k)        $k = $n - $k;  // Calculate value of [n*(n-1)*---*(n-k+1)] / // [k*(k-1)*---*1] for ($i = 0; $i < $k; ++$i) { $res *= ($n - $i);        $res = floor($res / ($i + 1)); }  return $res;} // A Binomial coefficient based function// to find nth catalan number in O(n) timefunction catalan($n){ // Calculate value of 2nCn $c = binomialCoeff(2 * ($n), $n);     // return 2nCn/(n+1)    return floor($c / ($n + 1));} // Driver codefor ($i = 0; $i < 10; $i++)echo catalan($i), " " ; // This code is contributed by Ryuga?>

## Javascript

 

Output

1 1 2 5 14 42 132 429 1430 4862

Time Complexity: O(n).
Auxiliary Space: O(1)

We can also use the below formulas to find nth Catalan number in O(n) time.

## Catalan number using the multi-Precision library:

In this method, we have used a boost multi-precision library, and the motive behind its use is just only to have precision meanwhile finding the large Catalan number and a generalized technique using for loop to calculate Catalan numbers.

Pseudocode:

a) initially set cat_=1 and print it
b) run a for loop i=1 to i<=n
cat_ *= (4*i-2)
cat_ /= (i+1)
print cat_
c) end loop and exit        

Below is the implementation using the multi-precision library:

## C++

 #include #include using boost::multiprecision::cpp_int;using namespace std; // Function to print the numbervoid catalan(int n){    cpp_int cat_ = 1;     // For the first number    cout << cat_ << " "; // C(0)     // Iterate till N    for (cpp_int i = 1; i <= n; i++) {        // Calculate the number        // and print it        cat_ *= (4 * i - 2);        cat_ /= (i + 1);        cout << cat_ << " ";    }} // Driver codeint main(){    int n = 5;     // Function call    catalan(n);    return 0;}

## Java

 import java.util.*;class GFG {     // Function to print the number    static void catalan(int n)    {        int cat_ = 1;         // For the first number        System.out.print(cat_ + " "); // C(0)         // Iterate till N        for (int i = 1; i < n; i++) {            // Calculate the number            // and print it            cat_ *= (4 * i - 2);            cat_ /= (i + 1);            System.out.print(cat_ + " ");        }    }     // Driver code    public static void main(String args[])    {        int n = 5;         // Function call        catalan(n);    }} // This code is contributed by Debojyoti Mandal

## Python3

 # Function to print the numberdef catalan(n):     cat_ = 1     # For the first number    print(cat_, " ", end='')  # C(0)     # Iterate till N    for i in range(1, n):         # Calculate the number        # and print it        cat_ *= (4 * i - 2)        cat_ //= (i + 1)        print(cat_, " ", end='')  # Driver coden = 5 # Function callcatalan(n) # This code is contributed by rohan07

## C#

 using System; public class GFG {     // Function to print the number    static void catalan(int n)    {        int cat_ = 1;         // For the first number        Console.Write(cat_ + " "); // C(0)         // Iterate till N        for (int i = 1; i < n; i++) {            // Calculate the number            // and print it            cat_ *= (4 * i - 2);            cat_ /= (i + 1);            Console.Write(cat_ + " ");        }    }     // Driver code    public static void Main(String[] args)    {        int n = 5;         // Function call        catalan(n);    }} // This code is contributed by Rajput-Ji

## Javascript

 

Output

1 1 2 5 14

Time Complexity: O(n)
Auxiliary Space: O(1), since no extra space has been taken.

## Catalan number using BigInteger in java:

Finding values of Catalan numbers for N>80 is not possible even by using long in java, so we use BigInteger.

Follow the steps below for the implementation:

• Create a BigInteger variable b and initialize it to 1.
• Calculate n! and store it into b.
• Calculate n! * n! and store into b.
• Create another BigInteger variable d and initialize it to 1.
• Calculate 2n! and store into d.
• Calculate (2n)! / (n! * n!) into ans
• Calculate ans / (n + 1) and return ans.

Below is the implementation of the above approach:

## C++

 #include using namespace std; #define bigint long long int bigint findCatalan(int n){    bigint b = 1;     // calculating n!    for (int i = 1; i <= n; i++) {        b = b * i;    }     // calculating n! * n!    b = b * b;     bigint d = 1;     // calculating (2n)!    for (int i = 1; i <= 2 * n; i++) {        d = d * i;    }     // calculating (2n)! / (n! * n!)    bigint ans = d / b;     // calculating (2n)! / ((n! * n!) * (n+1))    ans = ans / (n + 1);    return ans;} // Driver Codeint main() {    int n = 5;    cout << findCatalan(n);} // This code is contributed by ajaymakvana.

## Java

 import java.io.*;import java.math.*;import java.util.*; class GFG {    public static BigInteger findCatalan(int n)    {        // using BigInteger to calculate large factorials        BigInteger b = new BigInteger("1");         // calculating n!        for (int i = 1; i <= n; i++) {            b = b.multiply(BigInteger.valueOf(i));        }         // calculating n! * n!        b = b.multiply(b);         BigInteger d = new BigInteger("1");         // calculating (2n)!        for (int i = 1; i <= 2 * n; i++) {            d = d.multiply(BigInteger.valueOf(i));        }         // calculating (2n)! / (n! * n!)        BigInteger ans = d.divide(b);         // calculating (2n)! / ((n! * n!) * (n+1))        ans = ans.divide(BigInteger.valueOf(n + 1));        return ans;    }     // Driver Code    public static void main(String[] args)    {        int n = 5;        System.out.println(findCatalan(n));    }}// Contributed by Rohit Oberoi

## Python3

 def findCatalan(n):    b = 1     # calculating n!    for i in range(1, n + 1, 1):        b = b * i     # calculating n! * n!    b = b * b    d = 1     # calculating (2n)!    for i in range(1, 2 * n + 1, 1):        d = d * i             # calculating (2n)! / (n! * n!)    ans = d / b         # calculating (2n)! / ((n! * n!) * (n+1))    ans = ans / (n + 1)     return ans # Driver Coden = 50print(int(findCatalan(n))) # This code is contributed by ajaymakavana.

## C#

 // C# code to implement the approachusing System;using System.Numerics; class GFG {    public static BigInteger findCatalan(int n)    {        // using BigInteger to calculate large factorials        BigInteger b = new BigInteger(1);         // calculating n!        for (int i = 1; i <= n; i++) {            b = BigInteger.Multiply(b, new BigInteger(i));        }         // calculating n! * n!        b = BigInteger.Multiply(b, b);         BigInteger d = new BigInteger(1);         // calculating (2n)!        for (int i = 1; i <= 2 * n; i++) {            d = BigInteger.Multiply(d, new BigInteger(i));        }         // calculating (2n)! / (n! * n!)        BigInteger ans = BigInteger.Divide(d, b);         // calculating (2n)! / ((n! * n!) * (n+1))        ans = BigInteger.Divide(ans, new BigInteger(n + 1));        return ans;    }     // Driver Code    public static void Main(string[] args)    {        int n = 5;        Console.WriteLine(findCatalan(n));    }} // This code is contributed by phasing17.

## Javascript

 // JavaScript code to implement the approach function findCatalan(n){    let b = 1         // calculating n!    for(let i = 1; i <= n; i++){        b = b * i;    }         // calculating n! * n!    b = b * b;    let d = 1;         // calculating (2n)!    for(let i = 1; i <= 2 * n; i++){        d = d * i    }         // calculating (2n)! / (n! * n!)    let ans = d/b;         // calculating (2n)! / ((n! * n!) * (n+1))    ans = ans / (n + 1);         return ans;} let n = 5;console.log(findCatalan(n)); // This code is contributed by lokeshmvs21.

Output

42

Time Complexity: O(n)
Auxiliary Space: O(1), since no extra space has been taken.