LeetCode

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

 1 class Solution {
 2 public:
 3     int tribonacci(int n) {
 4         if(0==n)
 5             return 0;
 6         else if(1==n)
 7             return 1;
 8         else if(2==n)
 9             return 1;
10         return tribonacci(n-1)+tribonacci(n-2)+tribonacci(n-3);
11     }
12 };

然后超时了...

尾递归改写为迭代

 1 class Solution {
 2 public:
 3     int tribonacci(int n) {
 4         vector<long long> trib(38,0);
 5         trib[0]=0;
 6         trib[1]=1;
 7         trib[2]=1;
 8         for(int i=3;i<=n;++i)
 9             trib[i]=trib[i-1]+trib[i-2]+trib[i-3];
10         return trib[n];
11     }
12 };

LeetCode 104 二叉树的最大深度

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

dfs

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

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

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

1 class Solution {
2 public:
3 
4     int maxDepth(TreeNode* root) {
5         if(NULL==root) return 0;
6         return max(maxDepth(root->left),maxDepth(root->right))+1;
7     }
8 };

bfs

借助队列

 1 class Solution {
 2 public:
 3     int maxDepth(TreeNode* root) {
 4         int depth=0;
 5         queue<TreeNode*> q;
 6         if(root)
 7             q.push(root);
 8         while(!q.empty())
 9         {
10             for(int i=q.size()-1;i>=0;--i)
11             {
12                 TreeNode* node=q.front();
13                 q.pop();
14                 if(node->left)
15                     q.push(node->left);
16                 if(node->right)
17                     q.push(node->right);
18             }
19             ++depth;
20         }
21         return depth;
22     }
23 };

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

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

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

终止条件：NULL==node

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

 1 class Solution {
 2 public:
 3     int count=0;
 4     int num[105]={0};
 5     int minDiffInBST(TreeNode* root) {
 6         int min=-1;
 7         dfs(root);
 8         for(int i=1;i<count;++i){
 9             int temp=num[i]-num[i-1];
10             if(-1==min||min>temp){
11                 min=temp;
12             }
13         }
14         return min;
15     }
16     void dfs(TreeNode* node) {
17         if(NULL==node){
18             return;    
19         }
20         dfs(node->left);
21         num[count++]=node->val;
22         dfs(node->right);
23     }
24 };

LeetCode 543 二叉树的直径

问题分解为两个：

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

2）求它们之中最长的

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

官方题解很值得一看

 1 class Solution {
 2 public:
 3     int max=0;
 4     int diameterOfBinaryTree(TreeNode* root) {
 5         dfs(root);
 6         return max;
 7     }
 8     int dfs(TreeNode* node) {
 9         if(NULL==node) return 0;
10         int left=dfs(node->left);
11         int right=dfs(node->right);
12         max=max>left+right?max:left+right;
13         return (left>right?left:right)+1;
14     }
15 };

LeetCode 563 二叉树的坡度

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

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

 1 class Solution {
 2 public:
 3     int sum=0;
 4     int findTilt(TreeNode* root) {
 5         dfs(root);
 6         return sum;
 7     }
 8     int dfs(TreeNode* node)
 9     {
10         if(NULL==node)
11             return 0;
12         int left=dfs(node->left);
13         int right=dfs(node->right);
14         sum+=abs(left-right);
15         return left+right+node->val;
16     }
17 };