递归全排列理解

递归定义

一种计算过程，如果其中每一步都要用到前一步或前几步的结果，称为递归的。用递归过程定义的函数，称为递归函数，例如连加、连乘及阶乘等。百度百科

递归函数：函数直接或间接调用函数本身的方法，则该函数称为递归函数，递归调用时必须有递归终止条件（防止程序死在里面）

f(x0)
{
    if(x0) //终止条件
        return 1;
    else 
        return x0* f(x0-1);
}

累加求和

描述：给定一个数n，求n+(n-1)+(n-2)…+1
简化示例：1+2+3+....10

• 循环方法

int sum (n)
{
    int value = 0;
    while(n--)
        value += n;
    return value;
}

• 递归方法

int sum(n)
{
    if(n == 1) return 1;
    else return n+sum(n -1); 
}

结论：

• 使用循环来处理的话，时间复杂度为O(n)，空间复杂度为O(1)
• 使用递归的方法，时空复杂度为O(n)，且在进行自调时需要开辟栈空间，效率也较低

全排列

参照Lintcode上面的全排列实例
问题描述：给定一个数字列表，返回其所有可能的排列。

• 输入

[1,2,3]

• 输出

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

思路

根据数学中排列组合定义，[1,2,3]的所有排列数为 n*(n-1)..* 1 = 3 * 2 * 1 = 6
即以1 2 3为首地址的排列各位两种

C实现

void permute(int array[], int arrayLength, int start, int end)
{
	int temp,n,i;
	if(start == end)//获取到一组数据 
	{	
		for( n = 0; n < arrayLength; n++)//打印 
			printf("%d",array[n]);
		printf("\n");
	}	
	
	for(i = start; i <= end; i++)
	{
		temp = array[start]; array[start] = array[i]; array[i] = temp;//跟换位置 
		permute(array,arrayLength,start+1,end);	
		temp = array[start]; array[start] = array[i]; array[i] = temp;//跟换位置 
	}
		
}

int main() 
{
	int array[] = {1,2,3,4};
	printf("sizeof = %d \n",sizeof(array)/sizeof(int));
	permute(array,sizeof(array)/sizeof(int),0,sizeof(array)/sizeof(int)-1);
}

Java实现

    /*
     * @param nums: A list of integers.
     * @return: A list of permutations.
     */
    public static List<List<Integer>> permute(int[] nums) {
        // write your code here

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

        Sort(nums,0,nums.length-1,resultList);
        return resultList;


    }

    public static void Sort(int[] array, int begin, int end, List<List<Integer>> sourceList)
    {
        if(begin == end)
        {
            List<Integer> origi = new ArrayList<Integer>();
            for(int a:array)
            {
                origi.add(a);
            }
            sourceList.add(origi);
        }

        for(int i = begin; i <= end; i++)
        {
            swap(array,begin,i);
            Sort(array,begin+1,end,sourceList);
            swap(array,begin,i);
        }
    }

    public static void swap(int[] array, int a, int b)
    {
        int temp = array[a];
        array[a] = array[b];
        array[b] = temp;
    }

    public static void main(String[] args)
    {
        int[] a = {1,2,3,4};
        permute(a);
        for(List<Integer> b:permute(a))
        {

            for(int c:b)
                System.out.print(c);
            System.out.println("");

        }
    }