LeetCode算法46：全排列

题目
给定一个没有重复数字的序列，返回其所有可能的全排列。
示例:
输入: [1,2,3]
输出:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]
分析
这里采用递归的求解思路。
把待全排列记录分为两个部分：
（1） 第一个记录
（2） 剩下的所有元素
所有记录的全排列就是所有可能出现在第一个位置的记录与剩下所有元素的全排列。

以[1,2,3]为例，
1,2,3的全排列可以看作是
1,[2,3的全排列]
[2,3]的全排列又可以看作是
2,[3的全排列]—————对应123
3,[2的全排列]—————对应132
2,[1,3的全排列]
[1,3]的全排列又可以看作是
1,[3的全排列]—————对应213
3,[1的全排列]—————对应231
3,[1,2的全排列]
[1,2]的全排列又可以看作是
1,[2的全排列]—————对应312
2,[1的全排列]—————对应321

所以很明显，这就是一个递归的思想：给你部分记录，全排列就是所有可能出现在第一个位置的记录与剩下的元素的全排列，剩下的元素的全排列又是剩下的可能出现在第一个位置的元素与剩下的元素的全排列，依次重复下去。

代码

package leetcode_01_50;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import leetcodeTools.Sort01_Bubble;

public class _46permute {

	public List<List<Integer>> _46permute(int[] nums) {

		nums = Sort01_Bubble.sort(nums);

		List<List<Integer>> listall = new ArrayList();

		fullsort(nums, 0, nums.length - 1, listall);

		return listall;

	}

	private void fullsort(int[] nums, int start, int end, List<List<Integer>> listall) {

		if (start == end) {
			List<Integer> list = new ArrayList();
			for (int i = 0; i < nums.length; i++) {
				list.add(nums[i]);
			}
			listall.add(list);
			return;
		}

		for (int i = start; i < nums.length; i++) {
			swap(nums, i, start);
			fullsort(nums,start+1, end, listall);
			swap(nums, i, start);
		}

	}

	private void swap(int[] nums, int i, int start) {
		int temp = nums[start];
		nums[start] = nums[i];
		nums[i] = temp;
	}

	public static void main(String[] args) {

		int[] list1 = {1,2,3,4};

		_46permute _46permute = new _46permute();
		List<List<Integer>> head1 = _46permute._46permute(list1);

		for (int i = 0; i < head1.size(); i++) {

			for (int j = 0; j < head1.get(0).size(); j++) {

				System.out.print(head1.get(i).get(j));

			}
			System.out.println();
		}

	}

}

参考
全排列之JAVA实现