Permutation program in Java

Combinatorics' basic idea of permutations is the arrangement of a collection of items in several orders. We'll go through several techniques for creating permutations in Java and include code samples along with thorough explanations.

How Do Permutations Occur?

A permutation is the organization of elements in a particular sequence. It involves arranging the members of a set in a specific linear or sequential order. For example, consider the set A={11,66}. In this problem, there are only two possible permutations: {11,66} and {66,11}. There are no other possible permutations for this set.

Method 1: Recursive Technique

Recursive methods are among the easiest techniques to produce permutations. This Java program uses recursion to produce array permutations:

PermutationsRecursive.java

import java.util.*;
public class PermutationsRecursive {
    public static void generate(int[] a, int len) {
        if (len == 1) {
            System.out.println(Arrays.toString(a));
        } else {
            for (int j = 0; j < len; j++) {
                int temp = a[j];
                a[j] = a[len - 1];
                a[len - 1] = temp;
                generate(a, len - 1);
                temp = a[j];
                a[j] = a[len - 1];
                a[len - 1] = temp;
            }
        }
    }
    public static void main(String[] args) {
        int[] a = {100, 120 , 230};
	int n=a.length;
        generate (a, n);
    }
}

Output:

[100, 120, 230]
[100, 230, 120]
[120, 100, 230]
[120, 230, 100]
[230, 100, 120]
[230, 120, 100]

Explanation

This code uses recursion to create permutations of the array. It outputs the various ordering that are created by switching around the elements in the array. In the simplest scenario, the array is printed when n, its length, equals 1.

Approach 2: Lexicographic Sequence

Lexicographic order is another way to create permutations. When you need to find permutations in a certain order, this approach may be used to produce permutations one by one. This Java program produces lexicographically ordered permutations.

PermutationsLexicographic.java

import java.util.*;

public class PermutationsLexicographic {
    public static void generate (int[] a) {
        Arrays.sort(a);
        boolean hasNext = true;
        while (hasNext) {
            System.out.println(Arrays.toString(a));
	Int n=a.length;
            int i = n - 2;
            while (i >= 0 && a[i] >= a[i + 1]) {
                i--;
            }            
            if (i < 0) {
                hasNext = false;
            } else {
                int j = n - 1;
                while (a[j] <= a[i]) {
                    j--;
                }
                swap(a, i, j);
                reverse(a, i + 1);
            }
        }
    }

    public static void swap(int[] arr, int a, int b) {
        int t = arr[a];
        arr[a] = arr[b];
        arr[b] = t;
    }

    public static void reverse(int[] a, int first) {
	int n=a.length;
        int last = n-1;
        while (first< last) {
            swap(a, first, last);
            first++;
            last--;
        }
    }

    public static void main(String[] args) {
        int[] a = {100, 120, 230};
        generate (a);
    }
}

Output:

[100, 120, 230]
[100, 230, 120]
[120, 100, 230]
[120, 230, 100]
[230, 100, 120]
[230, 120, 100]

Explanation

The items in this code are first sorted, and we iteratively discover the next lexicographically greater permutation. The generatePermutations technique makes use of the fact that identifying the rightmost element that may be increased provides the foundation for each step.

Method 3: Without External Libraries

PermutationsWithoutLibraries.java

import java.util.*;
public class PermutationsWithoutLibraries{
    public static void generate(ArrayList<Integer> nums, ArrayList<Integer> combination, ArrayList<List<Integer>> answer) {
        if (nums.isEmpty()) {
            answer.add(new ArrayList<>(combination));
            return;
        }

        for (int j = 0; j < nums.size(); j++) {
            int cur = nums.get(j);
            combination.add(cur);
            ArrayList<Integer> remainingPart = new ArrayList<>(nums);
            remainingPart.remove(j);
            generate(remainingPart, combination, answer);
            combination.remove(combination.size() - 1);
        }
    }

    public static void main(String[] arguments) {
        List<Integer> nums = List.of(100, 120, 230);
        ArrayList<List<Integer>> combinations = new ArrayList<>();
        generate(new ArrayList<>(nums), new ArrayList<>(), combinations);

        for (List<Integer> perm : combinations) {
            System.out.println(perm);
        }
    }
}

Output:

[100, 120, 230]
[100, 230, 120]
[120, 100, 230]
[120, 230, 100]
[230, 100, 120]
[230, 120, 100]

Explanation

Using the list of components, the current permutation, and a list to hold the results, we build a recursive function called generatePermutations in this code. By adding each element to the current permutation and eliminating it from the remaining components, the function iteratively produces all possible permutations.

Conclusion

Creating permutations is a frequent issue that may be solved in several ways. We studied three approaches using Java: lexicographic order, recursive, and utilizing Collections. The strategy you choose will rely on your unique needs and limitations. These examples ought to aid in your comprehension of the fundamentals of Java permutation generation and lay the groundwork for more difficult permutation-related activities.

Next TopicProfile Annotation in Java

← prev next →