titre
Concevoir un algorithme, la sortie de l'ensemble du dispositif d'une chaîne de caractères. Par exemple, String = "ABC" est sortie
ABC
ACB
BAC
BCA
l'ABC
CAB
pensée
Notre premier instinct est possible, cela est une question de choix, le premier caractère de 3 à 1, second caractère de 2 à 1, le troisième caractère n'a pas le choix, trois cycles de violence peuvent être résolus rapidement. boucles emboîtées peuvent être utilisées pour générer une nouvelle chaîne.
Mais la longueur de cette chaîne est incertain, on n'a pas une syntaxe qui peut être le nombre de cycles spécifié de couches.
Si le nombre de couches à base opération, ne récursivité.
Une situation récurrente doit abstraite x, de telle sorte que la partie inférieure de la situation de traitement Simplifie à y, la solution récursive la situation y, et ainsi de suite, jusqu'à ce que le problème est assez simple à résoudre De toute évidence, puis revenir aux couches.
Lorsque abstraite récursion, on peut imaginer que je dispose d'une filiale, une filiale d'une autre filiale, toutes ces personnes peuvent résoudre le même problème. Les plus hauts dirigeants ont besoin de simplifier la situation un peu, puis nommé après une situation similaire à traiter avec les subordonnés peuvent simplifier, puis attend les résultats.
Dans cette question, on peut considérer ceci:
目标：输出全排列（字符数组）
我来搞定第一个字符
剩下的事，下级来处理剩下的部分
处理到最后一个字符时，就可以输出这个重新排列过的数组了Mais bientôt, vous trouverez que le premier caractère pour obtenir il y a beaucoup de choix, le raisonnement ci-dessus doit être réécrite comme:
目标：输出全排列（字符数组）
我来搞定第一个字符，这件事我会重复N次，每次选字符串中的一个
一旦选定（把某个字符挪到首位）
剩下的事，下级来处理剩下的部分
因为下次我要再选一个，所以先恢复到挪位之前Ainsi , lorsque la sortie de celui - ci?
Cette fonction est appelée une fois chacun, sont alignés en face de caractère supérieur, je dois traiter avec les caractères suivants, si je traite est le dernier caractère, parce que ses supérieurs se sont alignés devant moi tous les personnages à la sortie globale.
Code pseudo
// data：上级给任务时字符数组，index：上级已经排好了0~index-1的字符，要我处理index~length-1这段
f(char[] data,int index)
// 现在我试着从index开始找一个字符来作为首位，我要尝试length-index次
for(int i=index;i<length;i++)
swap(data,i,index);// 把i位置的字符交换到index这里来，我的工作就完成了
// 下面请直接下级来接招
f(data,index+1);
// 下级排好了，我即将选定下一个字符作为首位，必须先恢复一下
swap(data,i,index);
// 如果上级们已经处理好全部字符，我就输出
if(index==length)
println(data);code Java
package org.lanqiao.algo.recursion;
/**
* 输出字符串所有字符的全排列
* */
public class StrPermutation {
static int n;
public static void main(String[] args) {
String s = "ABCDE";
permutation(s.toCharArray(), 0);
System.out.println("---" + n + "---"); // n=长度的阶乘，可以用这个数字验证算法的正确性
}
//index代表0~index-1都已确认排列，[index,n-1]待排列
private static void permutation(char[] arr, int index) {
//至于什么时候输出，要考虑清楚
//考虑：只有所有位置上的字符都确认即index到达末尾，才算是排好一种情况
if (index == arr.length) {
n++;
System.out.println(String.valueOf(arr));
}
//现在index之前的字符都已就位，把之后的每个字符都交换到index这个位置
for (int k = index; k < arr.length; k++) {
//尝试交换
swap(arr, index, k);
//交换之后index这个位置就定好了，接下来的事就是递归去解决index+1位置开始的全排列就好了
permutation(arr, index + 1);
// 前面我们尝试交换，把全排列求出来了，交换时只尝试了一个字符，因此for循环继续之前要换回来，继续尝试交换下一个字符
swap(arr, index, k);
}
}
private static void swap(char[] arr, int index, int k) {
if(k==index)
return; // 不必交换了吧
char tmp = arr[k];
arr[k] = arr[index];
arr[index] = tmp;
}
}
résumé
Le code final est en fait relativement brève, il est caractéristiques récursives: le code est simple, le détour idée. Test de la pensée abstraite et de l' imagination.
Récursif, vous devez trouver le problème de similitude en sous-problèmes, autrement dit, vous devez trouver une structure de décomposition peut être simplifiée à la désintégration problème de lien direct jusqu'à la conclusion.
