剑指Offer_面试题28_字符串的排列

题目描述

输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

输入描述:

输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。

分析：复杂问题分解成小问题。首先确定第一个位置的字符，即：把第一个字符和其他位置字符交换。

如：{a，b，c} 让第一位分别跟第一位、第二位、第三位交换：

（1）a，{b，c}

（2）b，{a，c}

（3）c，{b，a}

对于以上每种情况中 {  } 的部分递归执行排列。注意每次交换完成，递归他的子串后，需要交换回去，还原到交换前的状态，这样可以继续交换下一位。而且只要递归执行交换回去，必定在递归返回后是交换前的状态（这点我认为是递归很难理解的一点，有时候不要太过纠结细节到底是怎么实现的，迈过这道坎，或者举个极简单的例子自己走一遍）。

代码：

#include <stdio.h>
#include <vector>
#include <iostream>
#include <string>
using namespace std;

///字符串排列
//原版
void Permutation(char *pStr, char *pBegin)
{
	if (*pBegin == '\0')
		printf("%s\n", pStr);
	else
	{
		for (char *p = pBegin; *p != '\0'; ++p)
		{
			//交换
			char temp = *p;
			*p = *pBegin;
			*pBegin = temp;
			//递归子串
			Permutation(pStr, pBegin + 1);
			//交换回去
			temp = *p;
			*p = *pBegin;
			*pBegin = temp;
		}
	}
}
void Permutation(char *pStr)
{
	if (pStr)
		Permutation(pStr, pStr);
}

//精装版
void swap(char &a, char &b) {
	char temp = a;
	a = b;
	b = temp;
}
void permcore(string list, int low, int high) {
	if (low == high) {   //当low==high时,此时list就是其中一个排列,输出list
		cout << list;
	cout << endl;
	}
	else {
		for (int i = low; i <= high; i++) {//每个元素与第一个元素交换
			if (i == low || list[i] != list[low]) {    //去重
				swap(list[i], list[low]);
				permcore(list, low + 1, high); //交换后,得到子序列,用函数perm得到子序列的全排列
				swap(list[i], list[low]);//最后,将元素交换回来,复原,然后交换另一个元素
			}
		}
	}
}

void perm(string str)
{
	permcore(str, 0, str.size()-1);
}





int main()
{
	char str[] = "abc";
	Permutation(str);
	printf("\n");

	string stdstr = "abb";
	perm(stdstr);
	printf("\n");

	string stdstr2 = "aab";
	perm(stdstr2);
	getchar();
	return 0;
}

效果：

根据截图可以看出例如“abb”这种类型是会重复的，而“aab”则不会重复，这是算法的锅，但是可以通过OJ

改进一下，结果保存在vector中，每次加入vector时判断是否已存在，这样可以避免重复，但是时间复杂度上会多一些，不知道有没有更好的办法：

#include <stdio.h>
#include <vector>
#include <iostream>
#include <string>
using namespace std;
//牛客网精装版
void swap(char &a, char &b) {
	char temp = a;
	a = b;
	b = temp;
}
void permcore(string list, int low, int high, vector<string>& res) {
	if (low == high &&
		find(res.begin(), res.end(), list) == res.end()) {  //去重 
		res.push_back(list);
	}
	else {
		for (int i = low; i <= high; i++) {//每个元素与第一个元素交换
			if (i == low || list[i] != list[low]) {    //去重
				swap(list[i], list[low]);
				permcore(list, low + 1, high, res); //交换后,得到子序列,用函数perm得到子序列的全排列
				swap(list[i], list[low]);//最后,将元素交换回来,复原,然后交换另一个元素
			}
		}
	}
}

vector<string> perm(string str)
{
	vector<string> res;
	if(!str.empty())
		permcore(str, 0, str.size()-1, res);
	return res;
}

int main()
{
	vector<string> res;
	string stdstr = "abb";
	res = perm(stdstr);
	for (auto s : res)
		cout << s << endl;
	cout << endl;

	string stdstr2 = "aab";
	res = perm(stdstr2);
	for (auto s : res)
		cout << s << endl;
	cout << endl;

	getchar();
	return 0;
}

效果：

这样就可以做到去重了。哦对了，res最后sort一下保证字典序，我忘了加了。

看了牛客网一个高赞的答案，用了unordered_set来记录交换的字符去重，我自己模拟了一下茅塞顿开。之所以会出现两个bba，两个bab的原因是最外层递归三种情况：（1）a,b,b（2）b,a,b（3）b,b,a，这三种情况用

if (i == low || list[i] != list[low]) 

是根本去不了重的，这个判断只能是去掉交换字符相同的情况，而对于已经交换过得情况是没有办法排除的，总结经验教训，得出最终版本：

//牛客网大拿版
//链接：https://www.nowcoder.com/questionTerminal/fe6b651b66ae47d7acce78ffdd9a96c7
//来源：牛客网

void PermutationHelp(vector<string> &ans, int k, string str) //遍历第k位的所有可能
{
	if (k == str.size() - 1)
		ans.push_back(str);
	unordered_set<char> us;
	//sort(str.begin() + k, str.end());//这个我不太懂，我把sort放到最后输出结果
	for (int i = k; i < str.size(); i++)
	{
		if (us.find(str[i]) == us.end()) //只和没交换过的换
		{
			us.insert(str[i]);
			swap(str[i], str[k]);
			PermutationHelp(ans, k + 1, str);
			swap(str[i], str[k]);
		}
	}
}

vector<string> Permutation(string str) {
	vector<string> ans;
	PermutationHelp(ans, 0, str);
	sort(ans.begin(), ans.end());
	return ans;
}

这种代码用set去重，只要交换过就不交换了，同时for循环刚开始时i = k，“自己和自己交换一次”会把自己加入set中，这样也会去掉同样字符交换的情况如abb中的b和b交换

这道题可以扩展到排列组合的问题，详见下一篇扩展篇