Les algorithmes de disposition et de combinaison sont largement utilisés et doivent être maîtrisés. Afin de réduire le seuil, cet article se concentre principalement sur la logique et la simplicité de l'algorithme, mais ne fait pas attention à l'efficacité de l'algorithme. En combinant la mise en œuvre dans les livres en ligne et leurs propres besoins, il y a quatre objectifs ici:
1. Arrangement complet de tous les éléments: L'arrangement complet de AB est AB, BA (l'ordre lié);
2. Combinaison complète de tous les éléments: la combinaison complète d'AB est a, b, ab (ordre non pertinent);
3. Découvrez quelles sont les combinaisons de sélection des éléments M parmi les éléments n: la combinaison de 2 éléments dans ABC est AB, AC, BC;
4. Découvrez quelles sont les arrangements pour sélectionner M éléments parmi les éléments n: les arrangements pour sélectionner 2 éléments dans ABC sont AB, BA, AC, CA, BC, CB;
On peut constater qu'après avoir trouvé la disposition de sélection des éléments M parmi les éléments N, nous organisons en fait l'ensemble des éléments (tableaux) composés de chaque combinaison après avoir trouvé la méthode combinée de sélection des éléments M entre les éléments, il s'agit donc d'une fonction d'assemblage, et les exemples ne sont pas répertoriés. Pour les trois autres objectifs, voir le code:
Public Final Class PermutationCembinationHolder {/ ** combinaison complète d'éléments de tableau * / combinaison de void statique (char [] chars) {char [] subchars = new char [chars.length]; // tableaux qui stockent les données de sous-combinaison // Le problème de l'ensemble de la combinaison est de sélectionner 1 élément de tous les éléments (indiqué n), plus la combinaison de 2 éléments ... plus la somme de la combinaison de n éléments pour (int i = 0; i <chars.length; ++ i) {final int m = i + 1; combinaison (chars, chars.length, m, subchars, m); }} / ** * Implémentation de la combinaison de n éléments avec n éléments. Le principe est le suivant: * Sélectionnez de l'arrière vers l'avant, sélectionnez Position I, puis sélectionnez M-1 dans le premier I-1. * Par exemple: 3 éléments sont sélectionnés à partir de 1, 2, 3, 4, 5. * 1) Après avoir sélectionné 5, puis en sélectionnant 2 dans les 4 premiers, et la sélection 2 dans les 4 premiers est un autre sous-problème, juste récursif; * 2) Si vous n'incluez pas 5, sélectionnez 4 directement, sélectionnez 2 dans les 3 premiers et sélectionnant 2 dans les trois premiers est un autre sous-problème, juste récursif; * 3) Si vous n'incluez pas 4, sélectionnez 3 directement, alors sélectionnez 2 dans les 2 premiers, et qu'il n'y en a que deux dans les 2 premiers. * En regardant la direction verticale, 1 et 2 et 3 se trouvent être une boucle pour une boucle, la valeur initiale est 5 et la valeur finale est m. * En regardant la direction horizontale, ce problème est un récursif de M-1 dans le premier I-1. * / statique void combinaison (char [] chars, int n, int m, char [] subchars, int subn) {if (m == 0) {// export for (int i = 0; i <subn; ++ i) {System.out.print (subchars [i]); } System.out.println (); } else {for (int i = n; i> = m; --i) {// select subchars [m - 1] = chars [i - 1]; // Sélectionnez une combinaison (Chars, I - 1, M - 1, Subchars, Subn); // Sélectionnez M-1 parmi le premier I-1 pour la récursivité}}}} / ** Permutation complète des éléments du tableau * / permutation void statique (char [] chars) {permutation (chars, 0, chars.length - 1); } / ** Les sous-réseaux dans le tableau de l'index commencent à Index End Participer à la permutation complète * / static void Permutation (char [] Chars, int début, int fin) {if (begin == end) {// La sortie est lorsque seul le dernier caractère est laissé pour (int i = 0; i <chars.length; ++ i) {system.out.print (chars [i]); } System.out.println (); } else {for (int i = begin; i <= end; ++ i) {// Chaque caractère est fixé au premier if (canSwap (chars, begin, i)) {// deduplicate swap (chars, begin, i); // Swap Permutation (Chars, Begin + 1, End); // Trouvez de manière récursive la permutation complète du swap de sous-tableau (Chars, Begin, i); // Restore}}}}} statique void swap (char [] chars, int from, int to) {char temp = chars [from]; chars [de] = chars [à]; chars [à] = temp; } statique booléen canSwap (char [] chars, int begin, int end) {for (int i = begin; i <end; ++ i) {if (chars [i] == chars [end]) {return false; }} return true; } public static void main (string [] args) {final char [] chars = new char [] {'a', 'b', 'c'}; permutation (Chars); System.out.println ("=============================================================================================.Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.