# Heap’s Algorithm for generating permutations

• Difficulty Level : Hard
• Last Updated : 15 Jun, 2021

Heap’s algorithm is used to generate all permutations of n objects. The idea is to generate each permutation from the previous permutation by choosing a pair of elements to interchange, without disturbing the other n-2 elements.
Following is the illustration of generating all the permutations of n given numbers.
Example:

```Input: 1 2 3
Output: 1 2 3
2 1 3
3 1 2
1 3 2
2 3 1
3 2 1```

Algorithm:

1. The algorithm generates (n-1)! permutations of the first n-1 elements, adjoining the last element to each of these. This will generate all of the permutations that end with the last element.
2. If n is odd, swap the first and last element and if n is even, then swap the ith element (i is the counter starting from 0) and the last element and repeat the above algorithm till i is less than n.
3. In each iteration, the algorithm will produce all the permutations that end with the current last element.

Implementation:

## C++

 `// C++ program to print all permutations using``// Heap's algorithm``#include ``using` `namespace` `std;` `// Prints the array``void` `printArr(``int` `a[], ``int` `n)``{``    ``for` `(``int` `i = 0; i < n; i++)``        ``cout << a[i] << ``" "``;``    ``printf``(``"\n"``);``}` `// Generating permutation using Heap Algorithm``void` `heapPermutation(``int` `a[], ``int` `size, ``int` `n)``{``    ``// if size becomes 1 then prints the obtained``    ``// permutation``    ``if` `(size == 1) {``        ``printArr(a, n);``        ``return``;``    ``}` `    ``for` `(``int` `i = 0; i < size; i++) {``        ``heapPermutation(a, size - 1, n);` `        ``// if size is odd, swap 0th i.e (first) and``        ``// (size-1)th i.e (last) element``        ``if` `(size % 2 == 1)``            ``swap(a, a[size - 1]);` `        ``// If size is even, swap ith and``        ``// (size-1)th i.e (last) element``        ``else``            ``swap(a[i], a[size - 1]);``    ``}``}` `// Driver code``int` `main()``{``    ``int` `a[] = { 1, 2, 3 };``    ``int` `n = ``sizeof` `a / ``sizeof` `a;``    ``heapPermutation(a, n, n);``    ``return` `0;``}`

## Java

 `// Java program to print all permutations using``// Heap's algorithm``class` `HeapAlgo {``    ``// Prints the array``    ``void` `printArr(``int` `a[], ``int` `n)``    ``{``        ``for` `(``int` `i = ``0``; i < n; i++)``            ``System.out.print(a[i] + ``" "``);``        ``System.out.println();``    ``}` `    ``// Generating permutation using Heap Algorithm``    ``void` `heapPermutation(``int` `a[], ``int` `size, ``int` `n)``    ``{``        ``// if size becomes 1 then prints the obtained``        ``// permutation``        ``if` `(size == ``1``)``            ``printArr(a, n);` `        ``for` `(``int` `i = ``0``; i < size; i++) {``            ``heapPermutation(a, size - ``1``, n);` `            ``// if size is odd, swap 0th i.e (first) and``            ``// (size-1)th i.e (last) element``            ``if` `(size % ``2` `== ``1``) {``                ``int` `temp = a[``0``];``                ``a[``0``] = a[size - ``1``];``                ``a[size - ``1``] = temp;``            ``}` `            ``// If size is even, swap ith``            ``// and (size-1)th i.e last element``            ``else` `{``                ``int` `temp = a[i];``                ``a[i] = a[size - ``1``];``                ``a[size - ``1``] = temp;``            ``}``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String args[])``    ``{``        ``HeapAlgo obj = ``new` `HeapAlgo();``        ``int` `a[] = { ``1``, ``2``, ``3` `};``        ``obj.heapPermutation(a, a.length, a.length);``    ``}``}` `// This code has been contributed by Amit Khandelwal.`

## Python3

 `# Python program to print all permutations using``# Heap's algorithm` `# Generating permutation using Heap Algorithm``def` `heapPermutation(a, size):` `    ``# if size becomes 1 then prints the obtained``    ``# permutation``    ``if` `size ``=``=` `1``:``        ``print``(a)``        ``return` `    ``for` `i ``in` `range``(size):``        ``heapPermutation(a, size``-``1``)` `        ``# if size is odd, swap 0th i.e (first)``        ``# and (size-1)th i.e (last) element``        ``# else If size is even, swap ith``        ``# and (size-1)th i.e (last) element``        ``if` `size & ``1``:``            ``a[``0``], a[size``-``1``] ``=` `a[size``-``1``], a[``0``]``        ``else``:``            ``a[i], a[size``-``1``] ``=` `a[size``-``1``], a[i]`  `# Driver code``a ``=` `[``1``, ``2``, ``3``]``n ``=` `len``(a)``heapPermutation(a, n)` `# This code is contributed by ankush_953``# This code was cleaned up to by more pythonic by glubs9`

## C#

 `// C# program to print all permutations using``// Heap's algorithm``using` `System;` `public` `class` `GFG {``    ``// Prints the array``    ``static` `void` `printArr(``int``[] a, ``int` `n)``    ``{``        ``for` `(``int` `i = 0; i < n; i++)``            ``Console.Write(a[i] + ``" "``);``        ``Console.WriteLine();``    ``}` `    ``// Generating permutation using Heap Algorithm``    ``static` `void` `heapPermutation(``int``[] a, ``int` `size, ``int` `n)``    ``{``        ``// if size becomes 1 then prints the obtained``        ``// permutation``        ``if` `(size == 1)``            ``printArr(a, n);` `        ``for` `(``int` `i = 0; i < size; i++) {``            ``heapPermutation(a, size - 1, n);` `            ``// if size is odd, swap 0th i.e (first) and``            ``// (size-1)th i.e (last) element``            ``if` `(size % 2 == 1) {``                ``int` `temp = a;``                ``a = a[size - 1];``                ``a[size - 1] = temp;``            ``}` `            ``// If size is even, swap ith and``            ``// (size-1)th i.e (last) element``            ``else` `{``                ``int` `temp = a[i];``                ``a[i] = a[size - 1];``                ``a[size - 1] = temp;``            ``}``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{` `        ``int``[] a = { 1, 2, 3 };``        ``heapPermutation(a, a.Length, a.Length);``    ``}``}` `/* This Java code is contributed by 29AjayKumar*/`

## Javascript

 ``

Output:

```1 2 3
2 1 3
3 1 2
1 3 2
2 3 1
3 2 1```

References:
1. “https://en.wikipedia.org/wiki/Heap%27s_algorithm#cite_note-3
This article is contributed by Rahul Agrawal .If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up