遞歸全排列理解

遞歸定義

一種計算過程，如果其中每一步都要用到前一步或前幾步的結果，稱爲遞歸的。用遞歸過程定義的函數，稱爲遞歸函數，例如連加、連乘及階乘等。百度百科

遞歸函數：函數直接或間接調用函數本身的方法，則該函數稱爲遞歸函數，遞歸調用時必須有遞歸終止條件（防止程序死在裏面）

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("");

        }
    }