2021-1-29斐波那契数列 青蛙跳台阶 二叉树深度

题目1 斐波那契数列

写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项（即 F(N)）。斐波那契数列的定义如下：

F(0) = 0, F(1) = 1
其中 N > 1.
斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。

解法1 递归

终止条件：n=0：返回0；n=1：返回1
返回值：F(N) = F(N - 1) + F(N - 2)

class Solution {
public:
    int fib(int n) {
        if(n == 0) return 0;
        if(n == 1) return 1;
        return (fib(n-1)+fib(n-2));
    }
};

解法2 记忆递归

在递归的过程中，当执行F(N - 1) + F(N - 2)，会重复计算F(N - 2)，因此代码中会出现大量的重复计算。
改进：设置一个数组arr，长度为N+1，记录每一个每次计算的结果值。若数组该位置的值已设置，返回该数组中的值即可。

int Fibonacci(int n,int arr[])
{
	//值为0或1
	if(0 == n && arr[n] == -1) 
		arr[n] = 0;
	else if(1 == n && arr[n] == -1) 
		arr[n] = 1;
	//数组中以存储F(n)的值
	if(arr[n] != -1)
		return arr[n];
	//计算F(n-1),F(n-2),并将结果赋值给数组对应位置
	arr[n] = Fibonacci(n-1,arr)+Fibonacci(n-2,arr);
	return arr[n];
}

解法3 循环

设置一个数组arr，长度为N+1，初始化设置arr[0] = 0,arr[1] = 1，后面的每个值为前两个值的加和。最后返回arr[n]即可。

class Solution {
public:
    int fib(int n) {
   		//n=0或1
        if(0 == n) return 0;
        if(1 == n) return 1;
        int arr[n+1];
        //初始化arr[0]，arr[1]
        arr[0] = 0;
        arr[1] = 1;
        //循环设置数组每个值
        for(int i=2 ; i<n+1 ; i++)
        {
            arr[i] = arr[i-1]+arr[i-2];
            arr[i] %= 1000000007;
        }
        return arr[n];
    }
};

题目2 青蛙跳台阶问题

一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。

1. 对于0、1级台阶，都是1种跳法
2. 对于n级台阶，因为青蛙每次可以跳1级或2级，因此对于上次跳的台阶数有1级或2级两种。
   所以种数为n-1级的种类数和n-2级种类数的和。

可以得知该类题和斐波那契数列类似，区别在于初始值不同。如下以递归为例给出代码，具体参考上一题。

class Solution {
public:
    int numWays(int n) {
        if(n == 1 || n == 0)
            return 1;
        int num = numWays(n-1)+numWays(n-2);
    }
};

题目3 求二叉树深度

解1 dfs递归

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root == NULL) return 0;
        int leftHeight = maxDepth(root->left);
        int rightHeight = maxDepth(root->right);
        return max(leftHeight,rightHeight)+1;
    }
};

解2 bfs广度优先遍历

设置一个队列Q，利用循环嵌套。具体过程见代码注释

class Solution {
public:
    int maxDepth(TreeNode* root) {
        int height = 0;
        queue<TreeNode*> Q;
        //1. 处理根节点，若非空则入队
        if(root) Q.push(root);
        while(!Q.empty())
        {
        	//获取该层结点个数
            int size = Q.size();
            //开始循环遍历该层结点，若该层节点有孩子，则孩子入队
            while(size > 0)
            {
            	//逐个取出结点
                TreeNode* pNode = Q.front();
                Q.pop();
                size--;
                //结点孩子入队
                if(pNode && pNode->left) Q.push(pNode->left);
                if(pNode && pNode->right) Q.push(pNode->right);
            }
            //本层遍历结束，高度加1，队列非空则开始遍历下一层
            height++;
        }
        return height;
    }
};