LeetCode

LeetCode 1137 第 N 个泰波那契数

递归tag，类似斐波那契，递归解法很简洁

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

然后超时了...

尾递归改写为迭代

class Solution {
public:
    int tribonacci(int n) {
        vector<long long> trib(38,0);
        trib[0]=0;
        trib[1]=1;
        trib[2]=1;
        for(int i=3;i<=n;++i)
            trib[i]=trib[i-1]+trib[i-2]+trib[i-3];
        return trib[n];
    }
};

LeetCode 104 二叉树的最大深度

经典的题目，应该说是后面很多关于树的题目的基础

dfs

终止条件：遍历结束，NULL == root，叶结点高度为0

递归表达式：maxDepth(node) = max(maxDepth(node->left),maxDepth(node->right))+1

当前结点的高度=max（左子树高度，右子树高度）+1

class Solution {
public:

    int maxDepth(TreeNode* root) {
        if(NULL==root) return 0;
        return max(maxDepth(root->left),maxDepth(root->right))+1;
    }
};

bfs

借助队列

class Solution {
public:
    int maxDepth(TreeNode* root) {
        int depth=0;
        queue<TreeNode*> q;
        if(root)
            q.push(root);
        while(!q.empty())
        {
            for(int i=q.size()-1;i>=0;--i)
            {
                TreeNode* node=q.front();
                q.pop();
                if(node->left)
                    q.push(node->left);
                if(node->right)
                    q.push(node->right);
            }
            ++depth;
        }
        return depth;
    }
};

LeetCode 783 二叉搜索树节点最小距离

最关键的是要想到利用二叉搜索树自带的顺序性

二叉搜索树的中序遍历是一个递增的序列。

终止条件：NULL==node

递归表达式：目的是得到中序遍历序列，dfs(node)=dfs(node->left) and dfs(node->right)

class Solution {
public:
    int count=0;
    int num[105]={0};
    int minDiffInBST(TreeNode* root) {
        int min=-1;
        dfs(root);
        for(int i=1;i<count;++i){
            int temp=num[i]-num[i-1];
            if(-1==min||min>temp){
                min=temp;
            }
        }
        return min;
    }
    void dfs(TreeNode* node) {
        if(NULL==node){
            return;    
        }
        dfs(node->left);
        num[count++]=node->val;
        dfs(node->right);
    }
};

LeetCode 543 二叉树的直径

问题分解为两个：

1）求两个叶节点之间的路径长

2）求它们之中最长的

最重要的是要分析得出：二叉树直径=对于每个结点左右子树高度之和的最大值

官方题解很值得一看

class Solution {
public:
    int max=0;
    int diameterOfBinaryTree(TreeNode* root) {
        dfs(root);
        return max;
    }
    int dfs(TreeNode* node) {
        if(NULL==node) return 0;
        int left=dfs(node->left);
        int right=dfs(node->right);
        max=max>left+right?max:left+right;
        return (left>right?left:right)+1;
    }
};

LeetCode 563 二叉树的坡度

和二叉树直径非常相似的一道题

递归表达式：dfs(node)=dfs(node->left)+dfs(node->right)+node->val

class Solution {
public:
    int sum=0;
    int findTilt(TreeNode* root) {
        dfs(root);
        return sum;
    }
    int dfs(TreeNode* node)
    {
        if(NULL==node)
            return 0;
        int left=dfs(node->left);
        int right=dfs(node->right);
        sum+=abs(left-right);
        return left+right+node->val;
    }
};