day 21 第六章 二叉树part07

● 530.二叉搜索树的最小绝对差
● 501.二叉搜索树中的众数
● 236. 二叉树的最近公共祖先

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

#include <climits>
/*
 * 530. 二叉搜索树的最小绝对差
简单
给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。
差值是一个正数，其数值等于两值之差的绝对值。
 提示：
树中节点的数目范围是 [2, 104]
0 <= Node.val <= 105
 */

class Solution_530 {
 public:
  struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode() : val(0), left(nullptr), right(nullptr) {}
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  };

  /*
   * 中序遍历，方便利用有序特性,定义一个前指针，与当前节点比较
输入参数为当前节点，无输出
终止条件为输入节点为空
单层递归逻辑：
判断终止条件
遍历左节点
遍历中节点，计算当前节点与前一个节点差值，更新前一个节点
遍历右节点
   */
  TreeNode* per = nullptr;
  int res = INT_MAX;
  void get(TreeNode* node){
      //判断终止条件
      if(!node)
          return;
      //遍历左节点
      get(node->left);
      //遍历中节点，计算当前节点与前一个节点差值，更新前一个节点
      if(per){
          int temp = abs(node->val - per->val);
          res = min(temp, res);
      }
      per = node;
      //遍历右节点
      get(node->right);
      return;
  }

  int getMinimumDifference(TreeNode* root) {
      get(root);
      return res;
  }
};

● 501.二叉搜索树中的众数

/*
 * 501. 二叉搜索树中的众数
简单
给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有 众数（即，出现频率最高的元素）。
如果树中有不止一个众数，可以按 任意顺序 返回。
假定 BST 满足如下定义：
结点左子树中所含节点的值 小于等于 当前节点的值
结点右子树中所含节点的值 大于等于 当前节点的值
左子树和右子树都是二叉搜索树
 */

class Solution_501 {
 public:
  struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode() : val(0), left(nullptr), right(nullptr) {}
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  };
  /*
 *
   * 如果是不是二叉搜索树，那就用map保存出现频率
   * 但是是二叉搜索树，那就是有序的，即重复元素会相邻出现，方便计算出现频率
   * 并且对众数而言只需得到最大出现频率的数保存起来就行
   * 中序遍历，方便利用有序特性,定义一个前指针，与当前节点比较
输入参数为当前节点及众数集合，无输出
终止条件为输入节点为空
单层递归逻辑：
判断终止条件
遍历左节点
遍历中节点
判断上一节点是否为空，
若不为空，比较节点值,若相等，出现频率加一,如果当前节点值与前一个节点值不相等，说明前节点值不再出现,出现频率=1
更新上一节点
比较最大出现频率，
若大于最大出现频，清空当前结果集，加入上一节点值，若等于最大出现频，加入上一节点值，
遍历右节点
 */
  TreeNode *per = nullptr;
  int count = 1;//默认1是因为根节点没有前一个节点
  int max_count = 0;
  void get(TreeNode *node, vector<int> &res) {
      //判断终止条件
      if (!node)
          return;
      //遍历左节点
      get(node->left, res);
      //遍历中节点
      //判断上一节点是否为空，
      //若不为空，比较节点值
      if (per) {
          //若相等，出现频率加一
          if (node->val == per->val) {
              count += 1;
          } else{//如果当前节点值与前一个节点值不相等
              count = 1;
          }
      }
      //更新上一节点
      per = node;

      //比较最大出现频率
      //若大于，清空当前结果集，加入上一节点值，若等于，加入上一节点值，
      if (count > max_count) {
          res.clear();
          res.push_back(node->val);
          max_count = count;
      } else if (count == max_count) {
          res.push_back(node->val);
      }

      //遍历右节点
      get(node->right, res);
      return;
  }
  vector<int> findMode(TreeNode *root) {
      vector<int> res;
      get(root, res);
      return res;
  }
};

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

/*
 * 236. 二叉树的最近公共祖先
中等
给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为：
 “对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

 提示：
树中节点数目在范围 [2, 105] 内。
-109 <= Node.val <= 109
所有 Node.val 互不相同 。
p != q
p 和 q 均存在于给定的二叉树中。
 */

class Solution_236 {
 public:
  struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode() : val(0), left(nullptr), right(nullptr) {}
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  };
  /*
   *
   * 公共节点，先找到指定节点，那就是自下而上寻找，后序遍历
输入参数为两个指定节点，当前节点，返回结果为公共祖先节点
终止条件为当前节点为空
单层递归逻辑
    判断终止条件，为真返回空
    左子节点遍历
    右子节点遍历
    当前节点计算，当前节点值是否等于指定节点值
        若等于，当前节点为祖先节点，返回当前节点
    判断是否为公共祖先节点
        若左右子节点遍历返回值不为空，则为最近公共祖先节点，返回
        若左为空右不为空，返回右
        若左不为空右为空，返回左
   */
  TreeNode *get(TreeNode *node, TreeNode *p, TreeNode *q) {
      //判断终止条件，为真返回空
      if (!node)
          return nullptr;
      //左子节点遍历
      TreeNode *left = get(node->left, p, q);
      //右子节点遍历
      TreeNode *right = get(node->right, p, q);
      //当前节点计算，当前节点值是否等于指定节点值
      if (node == p || node == q)//若等于，当前节点为祖先节点，返回当前节点
          return node;
      //判断是否为公共祖先节点
      //若左右子节点遍历返回值不为空，则为最近公共祖先节点，返回
      if (left && right)
          return node;
      else if (left)
          return left;
      else if (right)
          return right;
      return nullptr;
  }

  TreeNode *lowestCommonAncestor(TreeNode *root, TreeNode *p, TreeNode *q) {
      return get(root, p, q);
  }
};