https://oj.leetcode.com/problems/permutations/

http://fisherlei.blogspot.com/2012/12/leetcode-permutations.html 


public class Solution {
    
    // Assumes all input numbers are unique
    
    public List> permute(int[] num) 
    {
        // Solution A:
        // return permute_Insertion(num);
        
        // Solution B:
        // return permute_SwapRecursively(num);
        
        // Solution C:
        return permute_NP(num);
    }
    
    ////////////////////
    // Solution C: Swap Recursively:
    //
    private List> permute_NP(int[] num)
    {
        List> result = new ArrayList();
        boolean[] used = new boolean[num.length];
        permute_NPhelp(num, used, new ArrayList(), result);
        return result;
    }
    
    private void permute_NPhelp(int[] num, boolean[] used, List items, List> result)
    {
        int len = num.length;
        if (items.size() == len)
        {
            result.add(new ArrayList<>(items));
            return;
        }
        
        for (int i = 0; i < len ; i ++)
        {
            // Only use those unused chars.
            // Otherwise, need to input a list of int can be used.
            if (used[i])
                continue;

            used[i] = true;
            items.add(num[i]);
            
            permute_NPhelp(num, used, items, result);
            
            used[i] = false;
            items.remove(items.size() - 1);
        }
    }
    
    ////////////////////
    // Solution B: Swap Recursively:
    //
    // swap 0-0, 0-1, 0-2, 0-3, ..., 0-k
    // swap 1-1, 1-2, ... 1-k
    // swap 2-2 ...
    // ...
    // swap k-k
    public List> permute_SwapRecursively(int[] num)
    {
        List> result = new ArrayList();
        perm(0, num, result);
        return result;
    }

    private void perm(int start, int[] num, List> result)
    {
        int len = num.length;
        if(start >= len)
        {
        	List tmp = new ArrayList<>(num.length);
        	for(int n : num)
        	    tmp.add(n);
        	result.add(tmp);
        	return;
        }
        
        for(int i = start ; i < len ; i ++)
        {
            swap(num, start, i);
        	perm(start + 1, num , result);
        	swap(num, start, i);
        }
    }
    
    private void swap(int[] A, int i, int j)
    {
        int tmp = A[i];
    	A[i] = A[j];
    	A[j] = tmp;
    }
        
    ////////////////////
    // Solution A: Insertion:
    //
    // n = 1
    //      1
    //
    // n = 2
    //      2,1
    //      1,2
    //
    // n = 3
    //      3,2,1
    //      2,3,1
    //      2,1,3
    //      3,1,2
    //      1,3,2
    //      1,2,3
    //
    // 已知 n-1 集合，对每一个元素，在所有可能出插入数字n。   
    //
    // Bad point:
    // If the input numbers contains dups, need to use Set> to avoid dups.
    public List> permute_Insertion(int[] num) {
        
        List> toReturn = new ArrayList<>();
        if (num == null || num.length == 0)
            return toReturn;
            
        // Insert result when length = 1
        toReturn.add(Collections.singletonList(num[0]));
        for (int i = 1 ; i < num.length ; i ++)
        {
            List> newresults = new ArrayList<>();
            for (List lastr : toReturn)
            {
                for (int j = 0 ; j <= lastr.size() ; j++)
                {
                    List newr = new ArrayList<>(lastr);
                    newr.add(j, num[i]);
                    newresults.add(newr);
                }
            }
            toReturn = newresults;
        }
        return toReturn;
    }
}