递归之全排列

若要求{abc}的全排列（如图）：

实质就是求以a开头+以b开头+以c开头的全排列，即a{bc}+b{ac}+c{ab};

同理，若要求大括号内的全排列，就是求括号内以某个元素为首的全排列之和。

如此：若有n个元素，求其全排列。

大家都知道全排列公式：n! = n*(n-1)!；等式右边那个n就是在n个元素中选出一个元素为首元素，然后再将剩下n-1个元素全排列，最后结果累加起来，便是总的n元素全排列。然后看n-1个元素的全排列：(n-1)! = (n-1)*(n-2)!，同理，等式右边的n-1，就是除去第一次选出做首元素外，再在剩余n-1个元素中选取一个做首元素（共n-2种情况），剩余n-2个元素全排列·····

可以看出它有递归的性质。现以代码分析：

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;


void Permute(char* S, int j, int n)
{
    int i;
    char temp;
    if(j == n-1)
    {
        printf("%s\n", S);
        return ;
    }
    else
    {
        for(i = j; i < n; ++i)//在S[j···n-1]中，每次选取一个S[i]作为首元素，将剩下的n-1-j个元素全排列，初始时j = 0，for具有累加的性质，统计以各个元素为首的全部全排列
        {
            temp = S[j], S[j] = S[i], S[i] = temp;
            Permute(S, j+1, n);//将剩下全排列
            temp = S[j], S[j] = S[i], S[i] = temp;
        }
    }
}

int main()
{
    char arr[20];
    int n;
    while(~scanf("%s", arr))
    {
        n = strlen(arr);
        Permute(arr, 0, n);
        printf("\n");
    }
    return 0;
}

这里没有去重操作，即上述是n个不同的元素，如果这之间有重的，如：'aab'，它只有三中排列'aab'、'aba'、'baa'这三种，其余的都与它们相重复，因此上述代码需进一步改进，分析可知，在a[j....n]中，

判断如果当前所选的S[i]，在之前的S[j]到S[i]之间有跟S[i]相等的元素，就没必要更换了，就因为aab和aab换不换是一样的，就要去重.

bool Is_Match(char* str, int l, int r)
{
    for(int i = l; i < r; ++i)
        if(str[i] == str[r])
            return false;
    return true;
}

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;


bool Is_Match(char* str, int l, int r)
{
    for(int i = l; i < r; ++i)
        if(str[i] == str[r])
            return false;
    return true;
}
void Permute(char* S, int j, int n)
{
    int i;
    char temp;
    if(j == n-1)
    {
        printf("%s\n", S);
        return ;
    }
    else
    {
        for(i = j; i < n; ++i)//在S[j···n-1]中，每次选取一个S[i]作为首元素，将剩下的n-1-j个元素全排列，初始时j = 0，for具有累加的性质，统计以各个元素为首的全部全排列
        {
            if(Is_Match(S, j, i))//判断如果当前所选的S[i]，在之前的S[j]到S[i]之间有跟S[i]相等的元素，就没必要更换了，就因为aab和aab换不换是一样的，就要去重。
            {
                temp = S[j], S[j] = S[i], S[i] = temp;
                Permute(S, j+1, n);//将剩下全排列
                temp = S[j], S[j] = S[i], S[i] = temp;
            }
        }
    }
}

int main()
{
    char arr[20];
    int n;
    while(~scanf("%s", arr))
    {
        n = strlen(arr);
        Permute(arr, 0, n);
        printf("\n");
    }
    return 0;
}

以上全排列是已经给出了，但是，不是按字典序给出的，如此需要利用一个标志数组，具体例子如：

http://blog.csdn.net/hearthougan/article/details/31396671

以上全是递归形式，给出的，下面给出非递归的：

n个数的排列可以从1.2....n开始,至n.n-1....2.1结束。也就是按数值大小递增的顺序找出每一个排列。以6个数的排列为例，其初始排列为123456,最后一个排列是654321,如果当前排列是124653,找它的下一个排列的方法是，从这个序列中从右至左找第一个左邻小于右邻的数，如果找不到，则所有排列求解完成，如果找得到则说明排列未完成。本例中将找到46,计4所在的位置为i,找到后不能直接将46位置互换，而又要从右到左到第一个比4大的数，本例找到的数是5，其位置计为j，将i与j所在元素交换125643,然后将i+1至最后一个元素从小到大排序得到125346，这就是124653的下一个排列，如此下去，直至654321为止。算法结束。（参见百度百科）

这里无需再说什么按不按字典序排列了，因为初始的时候已经，将所有元素按从到达排列一遍，而再利用其思想，得出的最后结果输出就是字典序序列。

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>

using namespace std;

void Swap(char* a, char* b)
{
	char c = *a;
	*a = *b;
	*b = c;
}

void Revese_Str(char* a, char* b)
{
	while(a < b)
		Swap(a++, b--);
}

int CMP(const void *a, const void *b)
{
	return *(char*)a - *(char*)b;
}


bool Permutation(char str[])//寻找下一个全排列
{
	if(*str == '\0')
		return false;
	char *pa, *pb, *pStart, *pEnd;

	int iLen = strlen(str);
	pEnd = str + iLen;//此时pEnd代表最末尾的元素的下一位地址
	pa = --pEnd;

	while (pa != str)//从后向前找出两个相邻切递增的两个相邻数，即找出替换数
	{
		pb = pa;
		--pa;
		if(*pa < *pb)
		{
			pStart = pEnd;//找到之后，再从后向前找出比替换数大且是最小数（其实之前已经是排好序的，也就是找比替换数大的数即可）
			while(*pStart <= *pa)
				--pStart;
			Swap(pa, pStart);//交换替换数
			Revese_Str(pb, pEnd);//替换之后的字符逆转
			return true;
		}
	}
	return false;
}

int main()
{
	char str[30];
	while (~scanf("%s", str))
	{
		qsort(str, strlen(str), sizeof(str[0]), CMP);//为了最后好判断，先排一次序
		printf("%s\n", str);
		while (Permutation(str))
			printf("%s\n", str);
		printf("\n");
	}
	return 0;
}