530. 二叉搜索树的最小绝对差

先中序遍历获得数组，然后遍历数组得到结果

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 8  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 9  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10  * };
11  */
12 class Solution {
13 public:
14     int getMinimumDifference(TreeNode* root) {
15         vector<int> vec;
16         ldf(root,vec);
17         int result = INT_MAX;
18         for(int i = 1; i < vec.size(); i++){
19             result = min(result, abs(vec[i]-vec[i-1]));
20         }
21         return result;
22     }
23 private:
24     void ldf(TreeNode* root, vector<int>& vec){
25         if(root == nullptr) return;
26         ldf(root->left, vec);
27         vec.push_back(root->val);
28         ldf(root->right,vec);
29     }
30 };

501. 二叉搜索树中的众数

中序遍历，记录前一个节点，然后记录次数，并比较

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 8  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 9  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10  * };
11  */
12 class Solution {
13 public:
14     int max_count = 0;
15     int count = 0;
16     TreeNode* pre;
17     vector<int> result;
18     vector<int> findMode(TreeNode* root) {
19         ldr(root);
20         return result;
21     }
22 private:
23     void ldr(TreeNode* root){
24         if(root == nullptr) return;
25         ldr(root->left);
26         
27         if(pre == nullptr){ // 第一个.
28             count = 1;
29         }else if(root->val == pre->val){// 与前一个节点相同
30             count++;
31         }else{
32             count = 1;
33         }
34 
35         pre = root;
36         if(count == max_count)  result.push_back(root->val);
37         else if(count > max_count){
38             max_count = count;
39             result.clear();
40             result.push_back(root->val);
41         }
42         ldr(root->right);
43     }
44 };

236. 二叉树的最近公共祖先

其实就是后序遍历

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 8  * };
 9  */
10 class Solution {
11 public:
12     TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
13         if(root == p)   return root;
14         if(root == q)   return root;
15         if(root == nullptr) return nullptr;
16         TreeNode* left = lowestCommonAncestor(root->left, p, q);
17         TreeNode* right = lowestCommonAncestor(root->right, p, q);
18         if(left != nullptr && right != nullptr) return root;
19         if(left == nullptr) return right;
20         return left;
21     }
22 };