day21.|二叉树07

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

. - 力扣（LeetCode）

思路：

1.二叉搜索树：中序遍历。

2.注意是二叉搜索树，二叉搜索树可是有序的。

3.二叉搜索树可以转化为数组，通过中序遍历将二叉搜索树转化为一个从小到大排序的有序数组。

class Solution {
public:
    //转化为数组
    int result = INT_MAX;
    void traversal(TreeNode* node,vector<int>& vec){
        if(node == NULL) return ;

        traversal(node -> left, vec);
        vec.push_back(node -> val);
        traversal(node -> right, vec);
        return ;
    }

    int getMinimumDifference(TreeNode* root) {
        if(root == NULL)  return 0;
        
        vector<int> vec;
        traversal(root,vec);
        for(int i = 1;i < vec.size();i++){
            if(vec[i] - vec[i - 1] < result){
                result = vec[i] - vec[i - 1];
            }
        }
        return result;
    }
};

4.双指针法

class Solution {
public:
    TreeNode* pre = NULL;
    int result = INT_MAX;
    void traversal(TreeNode* cur){
        if(cur == NULL) return ;

        traversal(cur -> left);
        if(pre != NULL && cur -> val > pre -> val){
        result = min(cur -> val - pre -> val,result);
        }
        pre = cur;
        traversal(cur -> right);

        return ;
    }

    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return result;
    }
};

---

 2.二叉搜索树中的众数

. - 力扣（LeetCode）

思路：

1.既然是搜索树，它中序遍历就是有序的。

2.双指针的技巧。

class Solution {
public:
    TreeNode* pre = NULL;
    int count = 0;
    int max = 0;
    void traversal(TreeNode* cur, vector<int>& vec){
        if(cur == NULL) return ;

        //中序
        traversal(cur -> left,vec);

        if(pre != NULL && pre -> val == cur -> val){
            count++;
        }
        else if(pre != NULL && pre -> val != cur -> val){
            count = 1;
        }
        else if(pre == NULL){
            count = 1;
        }
        pre = cur;

        if(count > max){
            max = count;
            vec.clear();
            vec.push_back(cur -> val);
        }
        else if(count == max){
            vec.push_back(cur -> val);
        }
        
        traversal(cur -> right,vec);

        return ;
    }

    vector<int> findMode(TreeNode* root) {
        vector<int> result;
        if(root == NULL)  return result;
        traversal(root,result);
        return result;
    }
};

---

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

. - 力扣（LeetCode）

思路：

1.普通二叉树。二叉树的遍历是从上到下的，但是该题的处理顺序需要从下向上，所以必然会利用到回溯。

2.因此，遍历顺序是后序遍历，后序遍历是从下往上。涉及到回溯的过程，结果一层一层往上返回，一定用到后序遍历。

3.后序遍历（左右中）就是天然的回溯过程，可以根据左右子树的返回值，来处理中节点的逻辑。

class Solution {
public:
    TreeNode* traversal(TreeNode* cur, TreeNode* p, TreeNode* q){
        if(cur == NULL || cur == p || cur == q)  return cur;

        TreeNode* left = traversal(cur -> left,p,q);
        TreeNode* right = traversal(cur -> right,p,q);
        if(left != NULL && right != NULL)  return cur;
        else if(left == NULL && right != NULL) return right;
        else if(left != NULL && right == NULL) return left;
        else  return NULL;
    }

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root == NULL) return root;
        return traversal(root, p, q);
    }
};

4.求最小公共祖先，需要从底向上遍历，那么二叉树，只能通过后序遍历（即：回溯）实现从底向上的遍历方式。