# Program for nth Catalan Number

Catalan numbers are a sequence of natural numbers that occurs in many interesting counting problems like following.

1) Count the number of expressions containing n pairs of parentheses which 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.

See this for more applications.

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

## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

Recursive Solution
Catalan numbers satisfy the following recursive formula.

Following is the implementation of above recursive formula.

## C++

```#include<iostream>
using namespace std;

// A recursive function to find nth catalan number
unsigned 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 program to test above function
int main()
{
for (int i=0; i<10; i++)
cout << catalan(i) << " ";
return 0;
}
```

## Java

```
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;
}

public static void main(String[] args) {
CatalnNumber cn = new CatalnNumber();
for (int i = 0; i < 10; i++) {
System.out.print(cn.catalan(i) + " ");
}
}
}

```

## Python

```# 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 Program to test above function
for i in range(10):
print catalan(i),
# This code is contributed by Nikhil Kumar Singh (nickzuck_007)

```

Output :
`1 1 2 5 14 42 132 429 1430 4862`

Time complexity of above implementation is equivalent to nth catalan number.

The value of nth catalan number is exponential that makes the time complexity exponential.

Dynamic Programming Solution
We can observe that the above recursive implementation does a lot of repeated work (we can the same by drawing recursion tree). Since there are overlapping subproblems, we can use dynamic programming for this. Following is a Dynamic programming based implementation in C++.

## C++

```#include<iostream>
using namespace std;

// A dynamic programming based function to find nth
// Catalan number
unsigned 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 program to test above function
int main()
{
for (int i = 0; i < 10; i++)
cout << catalanDP(i) << " ";
return 0;
}
```

## Python

```# A dynamic programming based function to find nth
# Catalan number
def catalanDP(n):
if (n == 0 or n == 1):
return 1

# Table to store results of subproblems
catalan = [0 for i in range(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):
catalan[i] = 0
for j in range(i):
catalan[i] = catalan[i] + catalan[j] * catalan[i-j-1]

# Return last entry
return catalan[n]

# Driver code
for i in range (11):
print (catalanDP(i))
# This code is contributed by Aditi Sharma
```

Output:
`1 1 2 5 14 42 132 429 1430 4862 `

Time Complexity: Time complexity of above implementation is O(n2)

Using Binomial Coefficient
We can also use the below formula to find nth catalan number in O(n) time.

We have discussed a O(n) approach to find binomial coefficient nCr.

## C++

```#include<iostream>
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) time
unsigned 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 program to test above functions
int main()
{
for (int i = 0; i < 10; i++)
cout << catalan(i) << " ";
return 0;
}
```

## Python

```# 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)

for i in range (11):
print (catalan(i))

# This code is contributed by Aditi Sharma
```

Output:
`1 1 2 5 14 42 132 429 1430 4862`

Time Complexity: Time complexity of above implementation is O(n).

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

References:
http://en.wikipedia.org/wiki/Catalan_number

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
2.6 Average Difficulty : 2.6/5.0
Based on 57 vote(s)