leetcode 46. 全排列

给定一个没有重复数字的序列，返回其所有可能的全排列。

示例:

输入: [1,2,3]
输出:
[
  [1,2,3],
  [1,3,2],
  [2,1,3],
  [2,3,1],
  [3,1,2],
  [3,2,1]
]

思路：递归的思路来实现，即固定第一位，对剩下的数字进行同样的算法，知道把一个数组全部遍历完。
用vector<vector<int>>& ans来保存全排列的数组， 用begin来表示需要全排列的起始位置，end来表示需要全排列的终止位置
很明显可以看出这种算法的复杂度为O(n!)，第一位需要交换n次， 第二位需要交换n-1次，....
上面说的固定，其实就是递归的交换第i位
可以发现程序中有两个swap(nums, begin, i)的调用，首先这是交换nums中的begin,i之间的数字。 再者调用两次是把数组还原，以便保证下一个排列的正确性
用1，2，3来解释这个程序，最开始的时候begin=0, end = 2;(end始终是数组的最后一位的下标)
permute(nums, ans, 0, 2)
　　i=0;　　//交换第一位
　　swap(nums,0,0);      　　　　　　　　　　　　　　　　　　nums=1,2,3
　　permute(nums, ans, 1, 2)
　　　　i=1;
　　　　swap(nums, 1, 1); 　　　　　　　　　　　　　　　　　　nums=1,2,3
　　　　permute(nums, ans, 2, 2)
　　　　　　ans.push(nums);         　　　　　　　　　　　　 ans=[[1,2,3]]
　　　　//完成一个完整的排列后，把数组还原到上一个状态，这个完整的排列是针对递归中的每一个子列而言的，而不是对整个数列而言的
　　　　swap(nums, 1, 2); 　　　　　　　　　　　　　　　　  　nums=1,2,3
　　　　i=2;
　　　　swap(nums, 1, 2);　　　　　　　　　　　　　　　　　　  nums=1,3,2
　　　　permute(nums, ans, 2, 2)
　　　　　　ans.push(nums);　　　　　　　　　　　　　　　　　  ans=[[1,2,3],[1,3,2]]
　　　　swap(nums, 1, 2);  　　　　　　　　　　　　　　　　　　nums=1,2,3
　　swap(nums, 0, 0)  　　　　　　　　　　　　　　　　　　　　 nums=1,2,3
　　i=1;
　　swap(nums, 0, 1);  　　　　　　　　　　　　　　　　　　　　nums=2,1,3
　　permute(nums, ans, 1, 2);
　　　　i=1;
　　　　swap(nums, 1, 1);  　　　　　　　　　　　　　　　　　　nums = 2,1,3
　　　　permute(nums, ans, 2, 2);
　　　　　　ans.push_back(nums);  　　　　　　　　　　　　　  ans=[[1,2,3], [1,3,2], [2,1,3]]
　　　　swap(nums, 1, 1);　　　　　　　　　　　　　　　　　　　nums = 2,1,3
　　　　i=2;
　　　　swap(nums, 1, 2);  　　　　　　　　　　　　　　　　　　nums=2,3,1
　　　　permute(nums, ans, 2, 2);
　　　　　　ans.push_back(nums);　　　　　　　　　　　　　　  ans=[[1,2,3], [1,3,2], [2,1,3], [2,3,1]]
　　　　swap(nums, 1, 2); 　　　　　　　　　　　　　　　　　　 nums=2,1,3
　　swap(nums, 0, 1);   　　　　　　　　　　　　　　　　　   　nums=1,2,3
　　i=2;
　　swap(nums, 0, 2); 　　　　　　　　　　　　　　　　　　　　 nums=3,2,1
　　permute(nums, ans, 1, 2);
　　　　i = 1;
　　　　swap(nums, 1, 1); 　　　　　　　　　　　　　　　　　　 nums=3,2,1
　　　　permute(nums, ans, 2, 2);
　　　　　　ans.push_back(nums);　　　　　　　　　　　　　　　ans=[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,2,1]]
　　　　swap(nums, 1, 1); 　　　　　　　　　　　　　　　　　　nums=3,2,1
　　　　i = 2;
　　　　swap(nums, 1, 2);  　　　　　　　　　　　　　　　　　nums=3,1,2
　　　　permute(nums, ans, 2, 2);
　　　　　　ans.push_back(nums);　　　　　　　　　　　　　　　ans=[[1,2,3],[1,3,2],[2,1,3],[3,2,1],[3,1,2]]
　　　　swap(nums, 1, 2);  　　　　　　　　　　　　　　　　　　nums=3,2,1
　　swap(nums, 0, 2); 　　　　　　　　　　　　　　　　　　　　 nums=1,2,3
　　
结合上面的递归分析和下面的程序就很容易理解这个递归的算法

class Solution {
public:
    void permute(vector<int>&nums, vector<vector<int>>& ans, int begin, int end){
        if(begin == end){//完成一次完整的排列，就把此时的nums压入到ans中
            ans.push_back(nums);
            return;
        }else{
            for(int i = begin; i <= end; i++){
                swap(nums, begin, i);　　
                permute(nums, ans, begin+1, end);//对剩下的元素进行全排列
                swap(nums, begin, i);　　//还原数组
            }
        }
    }
    
    void swap(vector<int>& nums, int k, int i){
        int temp = nums[k];
        nums[k] = nums[i];
        nums[i] = temp;
    }
    
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> ans;
        int len = nums.size()-1;
        permute(nums, ans, 0, len);
        return ans;
    }
};

nums按值传递，会让代码更加简便，按值传递不会改变nums原来的排列，因而不需要多余的一次swap来使其恢复原来的排列。

class Solution {
public:
    void permute(vector<int>nums, vector<vector<int>>& ans, int begin, int end){
        if(begin > end){
            ans.push_back(nums);
            return;
        }else{
            for(int i = begin; i <= end; i++){
                swap(nums[begin], nums[i]);
                permute(nums, ans, begin+1, end); 
            }
        }
    }
    
  
    
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> ans;
        int len = nums.size()-1;
        permute(nums, ans, 0, len);
        return ans;
    }
};