思路：我一开始想到的方法是先生成中序序列，然后对相邻两项的差进行计算，取最小值，时间复杂度O(n)。

class Solution {
public:vector<int> inorder;void traverse(TreeNode* root){if(!root){return;}traverse(root->left);inorder.push_back(root->val);traverse(root->right);}int getMinimumDifference(TreeNode* root) {traverse(root);//节点范围从2开始int min=INT_MAX;for(int i=1;i<inorder.size();i++){if(inorder[i]-inorder[i-1]<min){min=inorder[i]-inorder[i-1];}}return min;}
};

然后想想能不能直接迭代，即每次遍历的时候记录前置节点，然后将差值对比。

class Solution {
public:TreeNode* pre=nullptr;int getMinimumDifference(TreeNode* root) {if(!root){return INT_MAX;//指示最小差值不存在}int left=getMinimumDifference(root->left);int min=left;//首先设置为左子树算出的结果if(pre&&root->val-pre->val<left){min=root->val-pre->val;}pre=root;//赋值前置节点，然后继续往后遍历int right=getMinimumDifference(root->right);if(right<min){//完成了左右中的比较min=right;}return min;}
};

实际上这样写代码很容易出错，真正写的时候就可以用额外生成的vector。标答把答案当做全局变量了，我们也建议单独写一个void遍历函数。
标答：

class Solution {
private:
int result = INT_MAX;
TreeNode* pre = NULL;
void traversal(TreeNode* cur) {if (cur == NULL) return;traversal(cur->left);   // 左if (pre != NULL){       // 中result = min(result, cur->val - pre->val);}pre = cur; // 记录前一个traversal(cur->right);  // 右
}
public:int getMinimumDifference(TreeNode* root) {traversal(root);return result;}
};

迭代法pass。

思路：简单的想法就是生成中序数组，然后使用哈希表统计元素出现个数，然后再输出。但是会有很多额外空间。其实这个方法对不是BST也可以，就是记录所有元素个数。时间复杂度O(n)。

class Solution {
public:unordered_map<int,int> mp;void traverse(TreeNode* root){if(!root){return;}traverse(root->left);mp[root->val]++;traverse(root->right);}vector<int> findMode(TreeNode* root) {vector<int> ans;int max=0;traverse(root);for(auto it:mp){if(it.second>max){max=it.second;}}for(auto it:mp){if(it.second==max){ans.push_back(it.first);}}return ans;}
};

标答将map进行了一个转换为vector后排序，我觉得没必要，这样复杂度反而变成O(nlogn)。

class Solution {
private:void searchBST(TreeNode* cur, unordered_map<int, int>& map) { // 前序遍历if (cur == NULL) return ;map[cur->val]++; // 统计元素频率searchBST(cur->left, map);searchBST(cur->right, map);return ;
}
bool static cmp (const pair<int, int>& a, const pair<int, int>& b) {return a.second > b.second;
}
public:vector<int> findMode(TreeNode* root) {unordered_map<int, int> map; // key:元素，value:出现频率vector<int> result;if (root == NULL) return result;searchBST(root, map);vector<pair<int, int>> vec(map.begin(), map.end());sort(vec.begin(), vec.end(), cmp); // 给频率排个序result.push_back(vec[0].first);for (int i = 1; i < vec.size(); i++) {// 取最高的放到result数组中if (vec[i].second == vec[0].second) result.push_back(vec[i].first);else break;}return result;}
};

考虑一下能不能利用BST的性质。即中序遍历有序，可以直接再遍历过程中操作，和上一题一样，不需要使用额外空间，使用pre指针，在对每个节点遍历的时候记录其出现次数，遍历一遍即可记录最大次数，然后第二次遍历，对最大次数的节点进行输出即为结果。看完解析发现可以通过一些简单的代码操作只进行一次遍历，即每次进行次数更新的时候，将结果clear()即可。可以看到对BST，利用其有序性，双指针有很大用处。

class Solution {
public:TreeNode* pre=nullptr;int count=0;int maxCount=INT_MIN;void traverse(TreeNode* root,vector<int>& ans){if(!root){return;}traverse(root->left,ans);if(!pre||root->val!=pre->val){//第一个元素,指针为空,或者当前和pre不同count=1;}else{//两个相邻相等count++;}pre=root;//此时已经完成count计数，然后和max比较if(count>maxCount){ans.clear();//更新，之前全部删掉maxCount=count;ans.push_back(root->val);}else if(count==maxCount){//等于也要增加结果ans.push_back(root->val);}traverse(root->right,ans);}vector<int> findMode(TreeNode* root) {vector<int> ans;traverse(root,ans);return ans;}
};

迭代法pass

思路：由于二叉树无法自底向上搜索，肯定需要回溯法。给定pq，需要分情况讨论。首先是简单情况，一个节点的两个孩子分别为p和q，这时候直接返回p或者q，如果为空，则返回空。我们需要把返回值一层一层往上传递，对根节点root，如果左右孩子都为空，则返回空，如果两个节点仅有一个找到了 ，则直接把这一个往上传递，如果两个都不为空，那么这个节点就是最近公共祖先，直接往上返回，最后的返回结果会传递到根节点。本题需要先处理左右孩子，最后确定根节点的返回值，为后序遍历。时间复杂度O(n)。

class Solution {
public:TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {if(!root||root==p||root==q){//终止条件，表示找到return root;}TreeNode* left=lowestCommonAncestor(root->left,p,q);TreeNode* right=lowestCommonAncestor(root->right,p,q);if(!left&&!right){//处理完左右后四种情况return nullptr;}else if(left&&!right){return left;}else if(!left&&right){return right;}else{return root;}}
};

没有迭代法。