【数据结构】递归

1.递归的定义

• 若一个对象部分地包含它自己或者用它自己给自己定义，则称这个对象是递归的。
• 若一个过程直接地或者间接地调用自己，则称这个过程是递归的过程。

2.递归条件

• 缩小问题规模，使新问题与原问题具有相同的解决形式。
• 设置递归的出口(存在简单场景，可以使递归在简单场景下退出)。

3.时间复杂度&空间复杂度&深度

递归算法的时间复杂度：递归总次数*每次递归次数
递归算法的空间复杂度：递归深度*每次创建对象的个数
递归算法的深度：每次递归空间大小*N

4.尾递归

• 定义
  在递归函数中，递归调用返回的结果总被直接返回则称为尾递归。

• 本质
  将单次计算的结果缓存起来，传递给下次调用，相当于自动累积。

5.递归的应用

• 斐波那契数列

举个栗子，大家都知道“斐波那契数”，即1,1,2,3,5,8,13……以此为规律排列下去。那么，要想实现斐波那契数列，可以通过循环和递归两种方法，下面分别给出。

【递归写法】

long long Fib(int N)
{
    if (N < 3)
        return 1;
    return Fib(N - 1) + Fib(N - 2);
}

int main()
{
    cout << Fib(5) << endl; //5
    return 0;
}

分析：
时间复杂度：o(2^N)
空间复杂度：N-1
深度：O(N)

若要求对上述方法进行改进，使得其空间复杂度满足O(N)，则我们可以通过尾递归的方法实现，代码如下：

【尾递归写法】

int Fib(int N, int first, int second)
{
    if (N < 3)
        return 1;
    if (N == 3)
        return first + second;
    return Fib(N - 1, second, first + second);
}

int main()
{
    cout << Fib(5, 1, 1) << endl;
    return 0;
}

分析：
时间复杂度：O(N)
空间复杂度：O(1)

栈环境只创建一份，无函数调用，直接发生跳转。

【循环写法】

long long Fib(int N)
{
    if (N < 3)
        return 1;  
    long long first = 1;
    long long second = 1;
    long long count = 0;
    while (N>=3)
    {
        count = first + second;
        first = second;
        second = count;
        N--;
    }
    return count;
}
int main()
{
    cout<<Fib(7)<<endl;
    return 0;
}

• 二分查找
  【递归写法】

版本一：左闭右开 [)

int BinarySearch(int arr[], int left, int right, int key)
{
    int mid = left - (left - right) / 2;
    while(left < right)
    {
        if (arr[mid] == key)
            return mid;
        else if (arr[mid] > key)
        {
            return BinarySearch(arr, left, mid, key);
        }
        return BinarySearch(arr, mid + 1, right, key);
    }
    return -1;
}
int main()
{
    int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    int ret = BinarySearch(arr, 2, 6, 4);
    cout << ret << endl;
    return 0;
}

版本二：左闭右闭 []

int BinarySearch(int arr[], int left, int right, int key)
{
    int mid = left - (left - right) / 2;
    while (left <= right)
    {
        if (arr[mid] == key)
            return mid;
        else if (arr[mid] > key)
        {
            return BinarySearch(arr, left, mid-1, key);
        }
        return BinarySearch(arr, mid + 1, right, key);
    }
    return -1;
}
int main()
{
    int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    int ret = BinarySearch(arr, 2, 6, 5);
    cout << ret << endl;
    return 0;
}

【非递归写法】

int BinarySearch(int arr[], int left, int right, int key)
{
    int mid = left - (left - right) / 2;
    while (left <= right)
    {
        if (arr[mid] == key)
            return mid;
        else if (arr[mid] > key)
        {
            right = mid - 1;
        }
        else
            left = mid + 1;
    }
    return -1;
}
int main()
{
    int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    int ret = BinarySearch(arr, 2, 6, 5);
    cout << ret << endl;
    return 0;
}

• 求一个数组的全排列

void Perm(int array[], int size, int N)
{
    int i;
    if (size <= N)
    {
        for (i = 0; i < size; ++i)
            cout << array[i] << " ";
        cout << endl;
    }
    else
    {
        for (i = N; i < size; ++i)
        {
            swap(array[i], array[N]);
            Perm(array, size, N + 1);
            swap(array[i], array[N]);
        }
    }
}

int main()
{
    int array[] = { 1, 2, 3, 4 };
    cout << Perm(array, 4, 2) << endl; //1 2 3 4  1 2 4 3
    cout << Perm(array, 4, 0) << endl; //全排
    return 0;
}