Comment générer toutes les permutations d'un tableau, y compris les cas avec des valeurs répétées ?

Permutation du tableau

Étant donné un tableau d'entiers distincts, trouvez le nombre total et répertoriez toutes les permutations possibles du tableau.

Code

Le code suivant fournit un algorithme récursif pour trouver les permutations d'un tableau :

import java.util.*;

public class Permute {

    public static void main(String[] args) {
        int[] a = new int[]{3, 4, 6, 2, 1};
        permute(a, 0);
    }

    private static void permute(int[] a, int k) {
        if (k == a.length - 1) {
            System.out.println(Arrays.toString(a));
        } else {
            for (int i = k; i < a.length; i++) {
                swap(a, i, k);
                permute(a, k + 1);
                swap(a, i, k);
            }
        }
    }

    private static void swap(int[] a, int x, int y) {
        int temp = a[x];
        a[x] = a[y];
        a[y] = temp;
    }
}

Cet algorithme génère toutes les permutations du tableau en échangeant le premier élément avec chacun des autres éléments du tableau, puis en appelant récursivement l'algorithme sur le tableau restant .

Itérateurs et Extension au cas de valeurs répétées

L'inconvénient de cet algorithme est qu'il ne gère pas le cas de valeurs répétées dans le tableau. Pour gérer ce cas, nous pouvons modifier l'algorithme pour utiliser une pile au lieu de la récursivité. Le code suivant fournit un algorithme itératif pour trouver les permutations d'un tableau :

import java.util.*;

public class Permute {

    public static void main(String[] args) {
        int[] a = new int[]{3, 3, 4, 4, 6, 2, 1};
        permuteIterative(a);
    }

    private static void permuteIterative(int[] a) {
        Stack<Integer> stack = new Stack<>();
        Set<Integer> visited = new HashSet<>();
        stack.push(0);
        visited.add(0);

        while (!stack.isEmpty()) {
            int k = stack.peek();
            if (k == a.length - 1) {
                System.out.println(Arrays.toString(a));
                stack.pop();
            } else {
                for (int i = k + 1; i < a.length; i++) {
                    if (!visited.contains(i)) {
                        swap(a, i, k);
                        stack.push(i);
                        visited.add(i);
                        break;
                    }
                }
                if (stack.peek() == k) {
                    stack.pop();
                    visited.remove(k);
                }
            }
        }
    }

    private static void swap(int[] a, int x, int y) {
        int temp = a[x];
        a[x] = a[y];
        a[y] = temp;
    }
}

Cet algorithme utilise une pile pour garder une trace de la permutation actuelle. L'algorithme commence par placer le premier élément du tableau sur la pile. Ensuite, l'algorithme extrait à plusieurs reprises les éléments de la pile et les échange avec l'élément non visité suivant du tableau. S'il n'y a plus d'éléments non visités dans le tableau, l'algorithme supprime l'élément de la pile et continue avec l'élément suivant dans la pile.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!