字符串的排列。输入一字符串，打印出该字符串中字符的所有排列。例如输入abc，则排列为abc,acb,bac,bca,cab,cba

import java.util.HashMap;

public class Permutation {
	private char[] ch;
	
	public Permutation(String str) {
		ch = str.toCharArray();
	}
	
	public void listPermutation() {
		recursivePermute(ch, 0);
	}
	
	private void recursivePermute(char[] pstr, int k) {
		int i;
		if (k == pstr.length)
			System.out.println(String.copyValueOf(pstr));
		else {
			for (i = k; i < pstr.length; i++) {
				exchange(pstr, k, i);
				recursivePermute(pstr, k + 1);
				exchange(pstr, k, i);
			}
		}
	}

	private void exchange(char[] pstr, int k, int i) {
		char temp = pstr[k];
		pstr[k] = pstr[i];
		pstr[i] = temp;
	}

	public static void main(String[] args) {
		String test = "ABC";
		Permutation permutation = new Permutation(test);
		permutation.listPermutation();		
	}
}

#include <stdio.h>

void listPermutations(char*, int);
void recursivePermute(char*, int, int);
void exchange2(char*, int, int);
void exchange(char* a, char* b); 


static char ch[] = "ABC";
//static char* ch = "ABC";//error

int 
main() {
	listPermutations(ch, 3);
}

void 
listPermutations(char* str, int length) {
	if (str == NULL)
		return;
	recursivePermute(str, 0, length);
}

void 
recursivePermute(char* str, int k, int length) {
	int i;
	if (k == length) {
		printf("%s\n", str);
	} else {
		for (i = k; i < length; i++) {
			exchange2(str, k, i);
			//exchange(&str[k], &str[i]);
			recursivePermute(str, k + 1, length);
			exchange2(str, k, i);
			//exchange(&str[k], &str[i]);
		}
	}
}

void
exchange(char* a, char* b) {
	char m;
	m = *a;
	*a = *b;
	*b = m;
}

void 
exchange2(char* str, int p1, int p2) {
	if (str) {
		
		char tmp = str[p1];
		str[p1] = str[p2];
		str[p2] = tmp;

		//char tmp = *(str + p1);
		//*(str + p1) = *(str + p2);
		//*(str + p2) = tmp;

	}
} 

解决原问题与递归子问题之间不对称时，最简单的方式就是定义一个函数作为一个简单的包装函数，然后调用一个辅助函数解决更普通的情况。

在这个示例中，一个新的过程recursivePermute能解决一般情况，它能产生一个前k个字母已确定的字符串的所有排列组合。当k==0时，所有的字母都可以随意改变位置，这是最初的问题了。当K增大时，问题就会越来越简单。当K等于该字符串的长度时，没有字母可以移动，字符串显示不变。