全排列算法（穷举、递归、字典序）

// Permutation.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <algorithm>
#include <string>
//全排列有三种思路来解决：暴力穷举、递归、字典序
//暴力穷举
//当数值很小的时候可以使用，但是数值很多的时候其时间复杂度就很高了n^n
void ExhaustivePermutation(int *a, int len)
{
	for (int i = 0; i < len; i++)
	{
		for (int j = 0; j < len; j++)
		{
			for (int m = 0; m < len; m++)
			{
				for (int n = 0; n < len; n++)
				{
					if(i != j && j != m && m != n && i != m && i != n && j!= n)
					std::cout << a[i] << a[j] << a[m] << a[n] << std::endl;
				}
			}
		}
	}
}
//递归（未去重复的）
//n个数，可摘出来第一个，然后对n-1进行全排列，故可实现递归。终止条件是n=1（只有一个数）的时候就打印输出
/*
以1，2，3，4四个数进行全排列举例说明步骤。
（1）第一位可以是1、2、3、4的四个，故第一位1可以1、2、3、4分别交换来循环遍历n次（n=4）
（2）n次遍历中每次递归（除第一位的n-1）次全排列函数perm，即对2、3、4全排列
（3）递归n-1次之后，需要将1再和1、2、3、4交换回来，因为下一次的时候需要拿1和3、4交换，依次类推
（4）对n=3、2、1进行同样的操作，依次类推
（5）n=1即只有一个数字的时候需要打印输出这组数据
*/
void swap(int *a, int *b)
{
	int tmp;
	tmp = *a;
	*a = *b;
	*b = tmp;
}

//left和right代表数组a的左右位
void RecursionPermutation(int *a, int left, int right)
{
	//终止条件
	if (left == right)
	{
		for (int i = 0; i < right+1; i++)
		{
			std::cout << a[i];
		}
		std::cout << std::endl;
	}
	for (int i = left; i <= right; i++)
	{
		swap(&a[left], &a[i]);
		RecursionPermutation(a, left+1, right);
		swap(&a[left], &a[i]);
	}
}


//递归(去重复的)
//遍历数组，当有重复元素的时候返回false，无则返回true
bool isRepeat(int *a, int left, int right)
{
	for (int i = left+1; i <= right; i++)
	{
		if (a[left] == a[i])
			return false;
	}
	return true;
}

void recursionUnRepeatedPermutation(int *a, int left, int right)
{
	//终止条件
	if (left == right)
	{
		for (int i = 0; i < right + 1; i++)
		{
			std::cout << a[i];
		}
		std::cout << std::endl;
	}

	for (int i = left; i <= right; i++)
	{
		if (isRepeat(a, i, right))
		{
			swap(&a[left], &a[i]);
			recursionUnRepeatedPermutation(a, left + 1, right);
			swap(&a[left], &a[i]);
		}
	}

}

//字典序列
/*
排列按照从小到大依次递增的排序叫做字典序列，
输入一个数值，然后计算出比其大的排列数值可分为以下几步：
（1）从右向左遍历，找到第一个左边小于右边的数值，记录其索引index，如果没有则其是最大的排列数值了
（2）再次从右向左遍历找到第一个比上步中大的数值
（3）交换这两个数值
（4）将index之后的数值按照升序排序，此数字就是比输入的数值稍大的排列了
*/

//找到排列中的下一个数值
bool nextPermutation(int *a, int len)
{
	int m;
	int idx = 0;
	for (m = len - 1; m > 0; m--)
	{
		if (a[m - 1] < a[m])
		{
			idx = m - 1;
			break;
		}	
	}
	if (m == 0)
		return false;

	for (int i = len - 1; i > 0; i--)
	{
		if (a[idx] < a[i])
		{
			swap(&a[idx], &a[i]);
			break;
		}		
	}
	std::sort(&a[idx+1], &a[len]);

	return true;
}

//字典序列
//可以剔除重复的
void dictPermutation(int *a, int len)
{
	//1、对数值进行排序，找到数值中的最小值
	std::sort(a, a + len);//可以自写排序，此处调用algorithm中的sort(begin, end),begin指向要排序的第一个数组位置， end指向数组的最后一个元素的下一个位置
	for (int i = 0; i < len; i++)
		std::cout << a[i];
	std::cout << std::endl;

	while (nextPermutation(a, len))
	{
		for (int i = 0; i < len; i++)
			std::cout << a[i];
		std::cout << std::endl;
	}
}

//组合
/*
计算出该数组元素的所有组合形式，比如[1,2,3]可组合成（1）（2）（3）（1,2）（1,3）（2,3）（1,2,3）
（1）采用bit与的操作,bit分别为（001、010、011、100、101、110、111）
（2）七种bit与数组
*/

void combination(std::string str)
{
	int len = str.size();
	int bit = (1 << len);
	for (int i = 1; i < bit; i++)
	{
		for (int j = 0; j < len; j++)
		{
			int temp = i;
			if (temp & (1 << j))   //对应位上为1，则输出对应的字符
			{
				std::cout<<str[j];
			}
		}
		std::cout << "\n";
	}
}


int main()
{
	int a[4] = { 1, 2, 1, 4 };
	//ExhaustivePermutation(a, 4);
	//RecursionPermutation(a, 0, 3);
	//dictPermutation(a, 4);
	//recursionUnRepeatedPermutation(a, 0, 3);
	std::string str = "abc";
	combination(str);
	return 0;
}