Given a collection of distinct numbers, return all possible permutations.

For example,
[1,2,3] have the following permutations:

[
  [1,2,3],
  [1,3,2],
  [2,1,3],
  [2,3,1],
  [3,1,2],
  [3,2,1]
]

给定一个数组，求所有的排列组合。

做出这道题很简单，主要是要比较快的速度，第一次做，耗时5ms，比较慢，主要就是用递归，每次向arraylist中放入一个数（不重复），放够数目的数就result.add();

public class Solution {
    public List<List<Integer>> permute(int[] nums) {
		
		List<List<Integer>> result = new ArrayList<List<Integer>>();
		if( nums.length == 0)
			return result;
		getResult(result,nums,new ArrayList<Integer>(),0);
		return result;
    }
	
	public static void getResult(List<List<Integer>> result,int[] nums,ArrayList<Integer> ans,int num){
		if( num == nums.length){
			result.add(new ArrayList<Integer>(ans));
			return ;
		}
		for( int i = 0 ;i <nums.length;i++){
			if( !ans.contains(nums[i]) ){
				ans.add(nums[i]);
				getResult(result,nums,ans,num+1);
				ans.remove((Integer)nums[i]);
			}
		}	
	}
}

 还有一种方法，用迭代，一个数字的时候，就是数字本身，两个数字的时候，就是将第二数字放在第一个数字的左边和右边两种，然后依次类推，在第n个数字的时候，就是在n-1的基础上，每一个空位（每个数字的左边和右边，共n个）放入第n个数字。耗时4ms

public class Solution {
    public static List<List<Integer>> permute(int[] nums) {

		List<List<Integer>> result = new ArrayList<List<Integer>>();
		if (nums.length == 0)
			return result;
		List<Integer> l0 = new ArrayList<Integer>();
		l0.add(nums[0]);
		result.add(l0);
		for( int i = 1;i<nums.length;i++){
			List<List<Integer>> l1 = new ArrayList<List<Integer>>();
			for( List<Integer> ll : result ){
				for(int j =0; j<=i;j++ ){
				    List<Integer> l2 = new ArrayList<Integer>(ll);
					l2.add(j, nums[i]);
					l1.add(l2);	
				}
			}
			result = l1;			
		}
		return result;
	}
}

 讲两种方法综合一下，递归＋迭代，这样是3ms

public class Solution {
    public List<List<Integer>> permute(int[] nums) {
	    List<List<Integer>> result = new ArrayList<List<Integer>>();
	    List<Integer> element = new ArrayList<Integer>();
	    getResult(result, element, nums, 0);
	    return result;
	}

	private void getResult(List<List<Integer>> result, List<Integer> element, int[] nums, int n){
	    if(n==nums.length){
	        result.add(element);
	        return;
	    }

	    int size = element.size();
	    for(int i = 0; i <= size; i++){
	        List<Integer> temp = new ArrayList<Integer>(element); 
	        temp.add(i,nums[n]);
	        getResult(result, temp, nums, n+1);
	    }
	    return;
	}
}

 

 然后还有一种方法，有n位数，那么第1位有n种情况，在确定第一位的情况下，第2位就有n-1种情况，以此类推，使用数组就可以使运行时间更快，用时2ms

public class Solution {
    public List<List<Integer>> permute(int[] nums) {
		List<List<Integer>> result = new ArrayList<List<Integer>>();
		if (nums.length == 0)
			return null;
		int len = nums.length - 1;
		result = getResult(nums, 0, len, result);
		return result;
	}

	public List<List<Integer>> getResult(int[] nums, int k, int len,
			List<List<Integer>> result) {

		if (k == len) {
			List<Integer> subList = new ArrayList<Integer>();
			for (int i = 0; i < nums.length; i++) {

				subList.add(nums[i]);
			}
			result.add(subList);
		} else {
			for (int i = k; i <= len; i++) {

				int temp = nums[k];
				nums[k] = nums[i];
				nums[i] = temp;
				getResult(nums, k + 1, len, result);
				int temp1 = nums[k];
				nums[k] = nums[i];
				nums[i] = temp1;

			}

		}

		return result;
	}
}