递归算法 一（包含斐波那契非递归算法，全排列问题详解）

一.简单的例题

1.阶乘的实现：

int factorial(int n){
	if(n==0)
		return 1;
	return n*factorial(n-1);
} 

2.斐波那契数列：

//递归算法
int fibonacci(int n){
	if(n==0||n==1)
		return 1;
	return fibonacci(n-1)+fibonacci(n-2);
} 
//非递归算法
int fibonacci(int n)
{
    int a = 1, b = 1, c = 0; // 初始化a、b和c
    if (n <= 2) // 处理n小于等于2的情况
    {
        return 1;
    }
    else // n大于2的情况
    {
        for (int i = 3; i <= n; i++) // 从第3项开始计算
        {
            c = a + b; // 计算第i项的值
            a = b; // 更新a和b的值
            b = c;
        }
        return c; // 返回第n项的值
    }
}
int fibonacci(int n){
	int a=1,b=1,c=0;
	if(n<=2){
		return 1;
		
	}
	else{
		for(int i=0;i<n;i++){
			c=a+b;
			a=b;
			b=c;
		}
		return c;
	}
}

3.排列问题：

#include <stdio.h>

void permutation(int nums[], int start, int end);

void swap(int nums[], int i, int j);

int main()
{
    int nums[] = {1, 2, 3, 4};
    int n = sizeof(nums) / sizeof(int);
    permutation(nums, 0, n - 1);
    return 0;
}

void permutation(int nums[], int start, int end)
{
    if (start == end) // 如果start等于end，说明已经排列完毕，输出结果
    {
        for (int i = 0; i <= end; i++)
        {
            printf("%d ", nums[i]);
        }
        printf("\n");
    }
    else
    {
        for (int i = start; i <= end; i++) // 从第start个元素开始，依次将每个元素放到第一个位置
        {
            swap(nums, start, i); // 将第i个元素与第start个元素交换位置
            permutation(nums, start + 1, end); // 递归处理剩余元素的排列
            swap(nums, start, i); // 恢复原来的数组顺序
        }
    }
}

void swap(int nums[], int i, int j)
{
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}

在main函数中给出的例子是{1,2,3,4},对其进行全排列，运行过程如下：

当运行此程序时，首先在main函数中定义了一个长度为4的整型数组nums，数组中包含了数字1到4。然后，程序调用了permutation函数，开始对nums数组进行全排列。

在permutation函数中，程序首先判断当前排列是否完成，如果已经完成，则输出当前排列结果。如果未完成，则依次将每个元素放到第一个位置，然后递归地处理剩余元素的排列，最后恢复原来的数组顺序。通过这种方式，程序可以对nums数组进行全排列，得到所有可能的排列方式。

具体来说，程序的执行过程如下：

1. 首先调用permutation函数，参数为nums数组、起始索引0和结束索引3。

2. 在permutation函数中，程序判断当前排列是否完成，由于起始索引为0，因此当前排列未完成，程序继续执行。

3. 程序进入for循环，从第0个元素开始，依次将每个元素放到第一个位置。第一次循环时，i等于0，程序将第0个元素与第0个元素交换，相当于不交换。此时，nums数组仍然为{1, 2, 3, 4}。

4. 程序接着调用permutation函数，参数为nums数组、起始索引1和结束索引3。在这个新的permutation函数中，程序判断当前排列是否完成，由于起始索引为1，因此当前排列未完成，程序继续执行。

5. 程序进入for循环，从第1个元素开始，依次将每个元素放到第一个位置。第一次循环时，i等于1，程序将第1个元素与第0个元素交换，得到新的nums数组为{2, 1, 3, 4}。

6. 程序接着调用permutation函数，参数为nums数组、起始索引2和结束索引3。在这个新的permutation函数中，程序判断当前排列是否完成，由于起始索引为2，因此当前排列未完成，程序继续执行。

7. 程序进入for循环，从第2个元素开始，依次将每个元素放到第一个位置。第一次循环时，i等于2，程序将第2个元素与第0个元素交换，得到新的nums数组为{3, 1, 2, 4}。

8. 程序接着调用permutation函数，参数为nums数组、起始索引3和结束索引3。在这个新的permutation函数中，程序判断当前排列是否完成，由于起始索引等于结束索引，因此当前排列已完成，程序输出当前排列结果1 2 3 4。

9. 程序执行完当前permutation函数后，返回到上一个permutation函数中，继续执行for循环。此时i等于3，程序将第3个元素与第0个元素交换，得到新的nums数组为{4, 1, 2, 3}。

10. 程序接着调用permutation函数，参数为nums数组、起始索引1和结束索引3。在这个新的permutation函数中，程序判断当前排列是否完成，由于起始索引为1，因此当前排列未完成，程序继续执行,

11. 以此类推继续往下执行。

二..一些简单的小细节

C语言计算数组的长度,在C语言中，计算数组的长度可以使用sizeof运算符。具体来说，如果我们定义了一个数组a，可以通过sizeof(a) / sizeof(a[0])来计算a数组的长度，其中sizeof(a)表示整个数组所占的字节数，sizeof(a[0])表示数组中一个元素所占的字节数。因此，sizeof(a) / sizeof(a[0])的结果就是a数组中元素的个数。以下是一个示例代码：

#include <stdio.h>

int main()
{
    int a[] = {1, 2, 3, 4, 5};
    int len = sizeof(a) / sizeof(a[0]);
    printf("The length of a is %d\n", len);
    return 0;
}