含有重复元素的全排列问题

简介：

本文主要介绍基于分治方式（递归）和枚举方式（循环）来构建指定字符串的全排列方法，两种方法均可以解决重复元素的全排列

欢迎探讨，若有错误敬请指正

如需转载，请注明出处 http://www.cnblogs.com/nullzx/

---

1. 基于分治方式（递归实现）

1）一个元素的全排列只有一种

2）[A0, A1, A2]的全排列等于下面三个全排列的并集

A0开头，拼接上[A1,A2]的全部全排列

A1开头，拼接上[A0,A2]的全部全排列

A2开头，拼接上[A0,A1]的全部全排列

因此，对于[A0, A1, ……，An]的全排列，咱们能够将问题转换成n个子问题：

A0开头，拼接上[A1,A2 ……，An]的全部全排列

A1开头，拼接上[A0,A2 ……，An]的全部全排列

……

An开头，拼接上[A0,A2 ……，A(n-1)]的全部全排列

 

而每一个子问题又能够继续向下转化成n-1个子问题，最终能够转化到只有一个元素的全排列问题。

对于数组中有重复元素的状况，咱们只要保证，重复元素只能有一次做为子问题的开头元素，这样咱们就能够避免重复计算。

 

2. 基于枚举方式（循环实现）

若是咱们将全排列按照大小顺序进行排序，假设咱们知道了第i个排列是[A0, A1, A2, A3, ……]，那么第i+1个排列就是比[A0, A1, A2, A3, ……]大，且最小的那个。找到i+1个排列的步骤以下

1）从后往前两两比较，找到第一个知足a[i]<a[i+1]的两个元素

2）从a[i+1]开始日后找，找到一个大于a[i]中最小的一个元素,这个元素的下标记为j，交换a[i]和a[j]

3）将[i+1, a.length-1]的元素所有逆序

 

3. 代码实现

下面是java代码的实现

package interviewquestion;

import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;

public class Permutation {
	
	//返回 装有回字符串s的全排列的List对象
	public static List<String> byTraverse(String s){
		char[] chArr = s.toCharArray();
		List<String> list = new LinkedList<String>();
		byTraverse0(chArr, 0, list);
		return list;
	}
	
	
	private static void byTraverse0(char[] arr, int left, List<String> list){
		if(left >= arr.length-1){
			list.add(new String(arr));
			return;
		}
		
		//用于记录交换到left下标的每个元素，防止计算重复的排列
		HashSet<Character> hs = new HashSet<Character>();

		for(int i = left; i < arr.length; i++){
			//arr[left]后面的每个元素arr[i]都和arr[left]交换
			swap(arr, left, i);
			if(!hs.contains(arr[left])){
				hs.add(arr[left]);
				byTraverse0(arr, left+1, list);
			}
			//将left和i交换回来，防止遗漏，重复
			//已保证下一个交换到left下标的是未交换过的元素
			swap(arr, left, i);
		}
	}
	/*=================================================*/
	
	//返回 装有大于等于字符串s的全排列的List对象
	public static List<String> byNext(String s){
		char[] arr = s.toCharArray();
		List<String> list = new LinkedList<String>();
		list.add(s);
		
		while(next(arr)){
			list.add(new String(arr));
		}
		return list;
	}
	
	private static boolean next(char[] arr){
		boolean hasNext = false;
		int i;
		for(i = arr.length-2; i >= 0; i--){
			if(arr[i] < arr[i+1]){
				hasNext = true;
				break;
			}
		}
		
		//若是全部元素是从大到小排列，说明是最大的字符串
		if(!hasNext){
			return false;
		}
		
		//从i+1的下标日后找（一定是单调递减）,找一个比arr[i]大的集合中最小的一个
		int j;
		for(j = i+1; j < arr.length; j++){
			if(arr[j] <= arr[i]){
				break;
			}
		}
		j--;
		
		//交换这两个元素，而后逆序i+1之后的全部元素
		swap(arr, i, j);
		reverse(arr, i+1, arr.length-1);
		
		return true;
	}
	
	private static void reverse(char[] arr, int from, int to){
		for(int i = from, j = to; i < j; i++, j--){
			swap(arr, i, j);
		}
	}
	
	/*=================================================*/
	
	private static void swap(char[] chArr, int i, int j){
		char t = chArr[i];
		chArr[i] = chArr[j];
		chArr[j] = t;
	}
	
	public static void main(String[] args){
		List<String> list1 = Permutation.byNext("1233");
		System.out.println(list1);
		System.out.println(list1.size());
		
		System.out.println();
		
		List<String> list2 = Permutation.byTraverse("1233");
		System.out.println(list2);
		System.out.println(list2.size());
	}
}

 

运行结果

[1233, 1323, 1332, 2133, 2313, 2331, 3123, 3132, 3213, 3231, 3312, 3321]
12

[1233, 1323, 1332, 2133, 2313, 2331, 3213, 3231, 3123, 3132, 3312, 3321]
12