聊聊二叉搜索树中的众数是多少？

二叉树上应该怎么求，二叉搜索树上又应该怎么求?

创新互联是专业的北海网站建设公司，北海接单;提供网站设计制作、成都做网站,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行北海网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!

在求众数集合的时候有一个技巧，因为题目中众数是可以有多个的，所以一般的方法需要遍历两遍才能求出众数的集合。

但可以遍历一遍就可以求众数集合，使用了适时清空结果集的方法，这个方法还是很巧妙的。相信仔细读了文章的同学会惊呼其巧妙!

二叉搜索树中的众数

题目链接：https://leetcode-cn.com/problems/find-mode-in-binary-search-tree/solution

给定一个有相同值的二叉搜索树(BST)，找出 BST 中的所有众数(出现频率最高的元素)。

假定 BST 有如下定义：

结点左子树中所含结点的值小于等于当前结点的值
结点右子树中所含结点的值大于等于当前结点的值
左子树和右子树都是二叉搜索树

例如：

给定 BST [1,null,2,2],

返回[2].

提示：如果众数超过1个，不需考虑输出顺序

进阶：你可以不使用额外的空间吗?(假设由递归产生的隐式调用栈的开销不被计算在内)

思路

这道题目呢，递归法我从两个维度来讲。

首先如果不是二叉搜索树的话，应该怎么解题，是二叉搜索树，又应该如何解题，两种方式做一个比较，可以加深大家对二叉树的理解。

递归法

如果不是二叉搜索树

如果不是二叉搜索树，最直观的方法一定是把这个树都遍历了，用map统计频率，把频率排个序，最后取前面高频的元素的集合。

具体步骤如下：

这个树都遍历了，用map统计频率

至于用前中后序那种遍历也不重要，因为就是要全遍历一遍，怎么个遍历法都行，层序遍历都没毛病!

这里采用前序遍历，代码如下：

 
 
 
 
  
  
  
  // map key:元素，value:出现频率   
  
  
  void searchBST(TreeNode* cur, unordered_map& map) { // 前序遍历   
  
  
      if (cur == NULL) return ;   
  
  
      map[cur->val]++; // 统计元素频率   
  
  
      searchBST(cur->left, map);   
  
  
      searchBST(cur->right, map);   
  
  
      return ;   
  
  
  }

把统计的出来的出现频率(即map中的value)排个序

有的同学可能可以想直接对map中的value排序，还真做不到，C++中如果使用std::map或者std::multimap可以对key排序，但不能对value排序。

所以要把map转化数组即vector，再进行排序，当然vector里面放的也是pair

代码如下：

 
 
 
 
  
  
  
  bool static cmp (const pair& a, const pair& b) {   
  
  
      return a.second > b.second; // 按照频率从大到小排序   
  
  
  }   
  
  
     
  
  
  vector> vec(map.begin(), map.end());   
  
  
  sort(vec.begin(), vec.end(), cmp); // 给频率排个序

取前面高频的元素

此时数组vector中已经是存放着按照频率排好序的pair，那么把前面高频的元素取出来就可以了。

代码如下：

 
 
 
 
  
  
  
  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;

整体C++代码如下：

 
 
 
 
  
  
  
  class Solution {   
  
  
  private:   
  
  
     
  
  
  void searchBST(TreeNode* cur, unordered_map& map) { // 前序遍历   
  
  
      if (cur == NULL) return ;   
  
  
      map[cur->val]++; // 统计元素频率   
  
  
      searchBST(cur->left, map);   
  
  
      searchBST(cur->right, map);   
  
  
      return ;   
  
  
  }   
  
  
  bool static cmp (const pair& a, const pair& b) {   
  
  
      return a.second > b.second;   
  
  
  }   
  
  
  public:   
  
  
      vector findMode(TreeNode* root) {   
  
  
          unordered_map map; // key:元素，value:出现频率   
  
  
          vector result;   
  
  
          if (root == NULL) return result;   
  
  
          searchBST(root, map);   
  
  
          vector> 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;   
  
  
      }   
  
  
  };

所以如果本题没有说是二叉搜索树的话，那么就按照上面的思路写!

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

如图：

二叉搜索树中的众数1

中序遍历代码如下：

 
 
 
 
  
  
  
  void searchBST(TreeNode* cur) {   
  
  
      if (cur == NULL) return ;   
  
  
      searchBST(cur->left);       // 左   
  
  
      （处理节点）                // 中   
  
  
      searchBST(cur->right);      // 右   
  
  
      return ;   
  
  
  }

遍历有序数组的元素出现频率，从头遍历，那么一定是相邻两个元素作比较，然后就把出现频率最高的元素输出就可以了。

关键是在有序数组上的话，好搞，在树上怎么搞呢?

这就考察对树的操作了。

在二叉树：搜索树的最小绝对差中我们就使用了pre指针和cur指针的技巧，这次又用上了。

弄一个指针指向前一个节点，这样每次cur(当前节点)才能和pre(前一个节点)作比较。

而且初始化的时候pre = NULL，这样当pre为NULL时候，我们就知道这是比较的第一个元素。

代码如下：

 
 
 
 
  
  
  
  if (pre == NULL) { // 第一个节点   
  
  
      count = 1; // 频率为1   
  
  
  } else if (pre->val == cur->val) { // 与前一个节点数值相同   
  
  
      count++;   
  
  
  } else { // 与前一个节点数值不同   
  
  
      count = 1;   
  
  
  }   
  
  
  pre = cur; // 更新上一个节点

此时又有问题了，因为要求最大频率的元素集合(注意是集合，不是一个元素，可以有多个众数)，如果是数组上大家一般怎么办?

应该是先遍历一遍数组，找出最大频率(maxCount)，然后再重新遍历一遍数组把出现频率为maxCount的元素放进集合。(因为众数有多个)

这种方式遍历了两遍数组。

那么我们遍历两遍二叉搜索树，把众数集合算出来也是可以的。

但这里其实只需要遍历一次就可以找到所有的众数。

那么如何只遍历一遍呢?

如果频率count 等于 maxCount(最大频率)，当然要把这个元素加入到结果集中(以下代码为result数组)，代码如下：

 
 
 
 
  
  
  
  if (count == maxCount) { // 如果和最大值相同，放进result中   
  
  
      result.push_back(cur->val);   
  
  
  }

是不是感觉这里有问题，result怎么能轻易就把元素放进去了呢，万一，这个maxCount此时还不是真正最大频率呢。

所以下面要做如下操作：

频率count 大于 maxCount的时候，不仅要更新maxCount，而且要清空结果集(以下代码为result数组)，因为结果集之前的元素都失效了。

 
 
 
 
  
  
  
  if (count > maxCount) { // 如果计数大于最大值   
  
  
      maxCount = count;   // 更新最大频率   
  
  
      result.clear();     // 很关键的一步，不要忘记清空result，之前result里的元素都失效了   
  
  
      result.push_back(cur->val);   
  
  
  }

关键代码都讲完了，完整代码如下：(只需要遍历一遍二叉搜索树，就求出了众数的集合)

 
 
 
 
  
  
  
  class Solution {   
  
  
  private:   
  
  
      int maxCount; // 最大频率   
  
  
      int count; // 统计频率   
  
  
      TreeNode* pre;   
  
  
      vector result;   
  
  
      void searchBST(TreeNode* cur) {   
  
  
          if (cur == NULL) return ;   
  
  
     
  
  
          searchBST(cur->left);       // 左   
  
  
                                      // 中   
  
  
          if (pre == NULL) { // 第一个节点   
  
  
              count = 1;   
  
  
          } else if (pre->val == cur->val) { // 与前一个节点数值相同   
  
  
              count++;   
  
  
          } else { // 与前一个节点数值不同   
  
  
              count = 1;   
  
  
          }   
  
  
          pre = cur; // 更新上一个节点   
  
  
     
  
  
          if (count == maxCount) { // 如果和最大值相同，放进result中   
  
  
              result.push_back(cur->val);   
  
  
          }   
  
  
     
  
  
          if (count > maxCount) { // 如果计数大于最大值频率   
  
  
              maxCount = count;   // 更新最大频率   
  
  
              result.clear();     // 很关键的一步，不要忘记清空result，之前result里的元素都失效了   
  
  
              result.push_back(cur->val);   
  
  
          }   
  
  
     
  
  
          searchBST(cur->right);      // 右   
  
  
          return ;   
  
  
      }   
  
  
     
  
  
  public:   
  
  
      vector findMode(TreeNode* root) {   
  
  
          count = 0;   
  
  
          maxCount = 0;   
  
  
          TreeNode* pre = NULL; // 记录前一个节点   
  
  
          result.clear();   
  
  
     
  
  
          searchBST(root);   
  
  
          return result;   
  
  
      }   
  
  
  };

迭代法

只要把中序遍历转成迭代，中间节点的处理逻辑完全一样。

二叉树前中后序转迭代，传送门：

二叉树：前中后序迭代法
二叉树：前中后序统一风格的迭代方式

下面我给出其中的一种中序遍历的迭代法，其中间处理逻辑一点都没有变(我从递归法直接粘过来的代码，连注释都没改，哈哈)

代码如下：

 
 
 
 
  
  
  
  class Solution {   
  
  
  public:   
  
  
      vector findMode(TreeNode* root) {   
  
  
          stack st;   
  
  
          TreeNode* cur = root;   
  
  
          TreeNode* pre = NULL;   
  
  
          int maxCount = 0; // 最大频率   
  
  
          int count = 0; // 统计频率   
  
  
          vector result;   
  
  
          while (cur != NULL || !st.empty()) {   
  
  
              if (cur != NULL) { // 指针来访问节点，访问到最底层   
  
  
                  st.push(cur); // 将访问的节点放进栈   
  
  
                  cur = cur->left;                // 左   
  
  
              } else {   
  
  
                  cur = st.top();   
  
  
                  st.pop();                       // 中   
  
  
                  if (pre == NULL) { // 第一个节点   
  
  
                      count = 1;   
  
  
                  } else if (pre->val == cur->val) { // 与前一个节点数值相同   
  
  
                      count++;   
  
  
                  } else { // 与前一个节点数值不同   
  
  
                      count = 1;   
  
  
                  }   
  
  
                  if (count == maxCount) { // 如果和最大值相同，放进result中   
  
  
                      result.push_back(cur->val);   
  
  
                  }   
  
  
     
  
  
                  if (count > maxCount) { // 如果计数大于最大值频率   
  
  
                      maxCount = count;   // 更新最大频率   
  
  
                      result.clear();     // 很关键的一步，不要忘记清空result，之前result里的元素都失效了   
  
  
                      result.push_back(cur->val);   
  
  
                  }   
  
  
                  pre = cur;   
  
  
                  cur = cur->right;               // 右   
  
  
              }   
  
  
          }   
  
  
          return result;   
  
  
      }   
  
  
  };

总结

本题在递归法中，我给出了如果是普通二叉树，应该怎么求众数。

知道了普通二叉树的做法时候，我再进一步给出二叉搜索树又应该怎么求众数，这样鲜明的对比，相信会对二叉树又有更深层次的理解了。

在递归遍历二叉搜索树的过程中，我还介绍了一个统计最高出现频率元素集合的技巧，要不然就要遍历两次二叉搜索树才能把这个最高出现频率元素的集合求出来。

为什么没有这个技巧一定要遍历两次呢?因为要求的是集合，会有多个众数，如果规定只有一个众数，那么就遍历一次稳稳的了。

最后我依然给出对应的迭代法，其实就是迭代法中序遍历的模板加上递归法中中间节点的处理逻辑，分分钟就可以写出来，中间逻辑的代码我都是从递归法中直接粘过来的。

求二叉搜索树中的众数其实是一道简单题，但大家可以发现我写了这么一大篇幅的文章来讲解，主要是为了尽量从各个角度对本题进剖析，帮助大家更快更深入理解二叉树。

需要强调的是 leetcode上的耗时统计是非常不准确的，看个大概就行，一样的代码耗时可以差百分之50以上，所以leetcode的耗时统计别太当回事，知道理论上的效率优劣就行了。

其他语言版本

Java

暴力法

 
 
 
 
  
  
  
  class Solution {   
  
  
   public int[] findMode(FindModeInBinarySearchTree.TreeNode root) {   
  
  
    Map map = new HashMap<>();   
  
  
    List list = new ArrayList<>();   
  
  
    if (root == null) return list.stream().mapToInt(Integer::intValue).toArray();   
  
  
    // 获得频率 Map   
  
  
    searchBST(root, map);   
  
  
    List> mapList = map.entrySet().stream()   
  
  
      .sorted((c1, c2) -> c2.getValue().compareTo(c1.getValue()))   
  
  
      .collect(Collectors.toList());   
  
  
    list.add(mapList.get(0).getKey());   
  
  
    // 把频率最高的加入 list   
  
  
    for (int i = 1; i < mapList.size(); i++) {   
  
  
     if (mapList.get(i).getValue() == mapList.get(i - 1).getValue()) {   
  
  
      list.add(mapList.get(i).getKey());   
  
  
     } else {   
  
  
      break;   
  
  
     }   
  
  
    }   
  
  
    return list.stream().mapToInt(Integer::intValue).toArray();   
  
  
   }   
  
  
     
  
  
   void searchBST(FindModeInBinarySearchTree.TreeNode curr, Map map) {   
  
  
    if (curr == null) return;   
  
  
    map.put(curr.val, map.getOrDefault(curr.val, 0) + 1);   
  
  
    searchBST(curr.left, map);   
  
  
    searchBST(curr.right, map);   
  
  
   }   
  
  
     
  
  
  }

 
 
 
 
  
  
  
  class Solution {   
  
  
      ArrayList resList;   
  
  
      int maxCount;   
  
  
      int count;   
  
  
      TreeNode pre;   
  
  
     
  
  
      public int[] findMode(TreeNode root) {   
  
  
          resList = new ArrayList<>();   
  
  
          maxCount = 0;   
  
  
          count = 0;   
  
  
          pre = null;   
  
  
          findMode1(root);   
  
  
          int[] res = new int[resList.size()];   
  
  
          for (int i = 0; i < resList.size(); i++) {   
  
  
              res[i] = resList.get(i);   
  
  
          }   
  
  
          return res;   
  
  
      }   
  
  
     
  
  
      public void findMode1(TreeNode root) {   
  
  
          if (root == null) {   
  
  
              return;   
  
  
          }   
  
  
          findMode1(root.left);   
  
  
     
  
  
          int rootValue = root.val;   
  
  
          // 计数   
  
  
          if (pre == null || rootValue != pre.val) {   
  
  
              count = 1;   
  
  
          } else {   
  
  
              count++;   
  
  
          }   
  
  
          // 更新结果以及maxCount   
  
  
          if (count > maxCount) {   
  
  
              resList.clear();   
  
  
              resList.add(rootValue);   
  
  
              maxCount = count;   
  
  
          } else if (count == maxCount) {   
  
  
              resList.add(rootValue);   
  
  
          }   
  
  
          pre = root;   
  
  
     
  
  
          findMode1(root.right);   
  
  
      }   
  
  
  }

Python

递归法

 
 
 
 
  
  
  
  class Solution:   
  
  
      def findMode(self, root: TreeNode) -> List[int]:   
  
  
          if not root: return   
  
  
          self.pre = root   
  
  
          self.count = 0   //统计频率   
  
  
          self.countMax = 0  //最大频率   
  
  
          self.res = []   
  
  
          def findNumber(root):   
  
  
              if not root: return None  // 第一个节点   
  
  
              findNumber(root.left)  //左   
  
  
              if self.pre.val == root.val:  //中: 与前一个节点数值相同   
  
  
                  self.count += 1   
  
  
              else:  // 与前一个节点数值不同   
  
  
                  self.pre = root   
  
  
                  self.count = 1   
  
  
              if self.count > self.countMax:  // 如果计数大于最大值频率   
  
  
                  self.countMax = self.count  // 更新最大频率   
  
  
                  self.res = [root.val]  //更新res   
  
  
              elif self.count == self.countMax:  // 如果和最大值相同，放进res中   
  
  
                  self.res.append(root.val)   
  
  
              findNumber(root.right)  //右   
  
  
              return   
  
  
          findNumber(root)   
  
  
          return self.res

迭代法-中序遍历-不使用额外空间，利用二叉搜索树特性

 
 
 
 
  
  
  
  class Solution:   
  
  
      def findMode(self, root: TreeNode) -> List[int]:   
  
  
          stack = []   
  
  
          cur = root   
  
  
          pre = None   
  
  
          maxCount, count = 0, 0   
  
  
          res = []   
  
  
          while cur or stack:   
  
  
              if cur:  # 指针来访问节点，访问到最底层   
  
  
                  stack.append(cur)   
  
  
                  cur = cur.left   
  
  
              else:  # 逐一处理节点   
  
  
                  cur = stack.pop()   
  
  
                  if pre == None:  # 第一个节点   
  
  
                      count = 1   
  
  
                  elif pre.val == cur.val:  # 与前一个节点数值相同   
  
  
                      count += 1   
  
  
                  else:   
  
  
                      count = 1   
  
  
                  if count == maxCount:   
  
  
                      res.append(cur.val)   
  
  
                  if count > maxCount:   
  
  
                      maxCount = count   
  
  
                      res.clear()   
  
  
                      res.append(cur.val)   
  
  
     
  
  
                  pre = cur   
  
  
                  cur = cur.right   
  
  
          return res

网站题目：聊聊二叉搜索树中的众数是多少？
URL分享：http://www.csdahua.cn/qtweb/news32/521082.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：快上网

成都快上网为您推荐相关内容