力扣：501. 二叉搜索树中的众数

题目描述

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

问题分析

1. 将二叉搜索树看成普通二叉树，那么就一定要遍历整棵树了。遍历二叉树，用map统计频率；对按照出现频率进行排序，这里涉及map只能按照key排序而不能按value排序的问题，那么就将map转化成数组，元素为pair<key,value>；最后取频率最高的元素就行了。
2. 二叉搜索树按照中序遍历是不严格的递增，那么相同节点值就挨在一起。只要用定义pre指向前一个节点，cur指向当前节点，比较两个节点的值，如果相同频率+1，不相等就频率重新赋值为1；然后判断是否与最大频率相同，相同加入结果数组result，如果计数大于最大频率，更新最大频率，清空结果数组result，再加入当前最大频率元素，最后返回最大频率的节点值数组就行了。
3. 迭代法就将2的中序遍历转成迭代就可以了，其他的逻辑是一样的。

代码实现

// 编程软件：VS2019
// 参考书籍：代码随想录
#include<iostream>
#include<unordered_map>
#include<stack>
#include<vector>
#include<queue>
using namespace std;

// 定义二叉树
struct TreeNode {
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode(int v):val(v),left(nullptr),right(nullptr){}
};

/*
* 递归法：普通二叉树
* 遍历二叉树，用map统计频率，对按照出现频率进行排序，取频率最高的元素
*/
// 先序遍历
void searchBST1(TreeNode* cur, unordered_map<int, int>& map) {
	if (cur == NULL) return;
	map[cur->val]++;
	searchBST1(cur->left, map);
	searchBST1(cur->right, map);
	return;
}
// 排序说明
bool static cmp(const pair<int, int>& a, const pair<int, int>& b) {
	return a.second > b.second; // 从大到小排序
}
vector<int> findMode1(TreeNode* root) {
	unordered_map<int, int>map; // key:元素，value:元素出现频率
	vector<int> result1;
	if (root == NULL) return result1;
	searchBST1(root, map); 
	// c++中，只能对map的key排序，无法对value排，那么就要序将map转化为数组
	vector<pair<int, int>> vec(map.begin(), map.end()); 
	sort(vec.begin(), vec.end(), cmp); // 排序
	result1.push_back(vec[0].first); // 加入频率最高的元素
	// 如果后面还有频率一样最高也要加入
	for (int i = 1; i < vec.size(); i++) {
		if (vec[i].second == vec[0].second) result1.push_back(vec[i].first);
		else break;
	}
	return result1;
}

/*
* 递归法：二叉搜索树
* 定义pre指向前一个节点，cur指向当前节点，比较两个节点的值，如果相同频率+1，不相等就频率重新赋值为1
* 然后判断是否与最大频率相同，相同加入结果数组result，如果计数大于最大频率，更新最大频率，清空结果数组result，再加入当前最大频率元素
*/
int maxCount2; // 最大频率
int cnt; // 统计频率
TreeNode* pre;
vector<int> result2;
void searchBST2(TreeNode* cur) {
	if (cur == NULL) return;
	searchBST2(cur->left); // 左
	// 中
	if (pre == NULL) {  // 第一个节点，cnt赋值为1
		cnt = 1;
	}else if(pre->val==cur->val){ // 如果当前节点值与前一个节点值，cnt++
		cnt++;
	}else { // 与前一个节点的数值不同，cnt重新赋值为1
		cnt = 1;
	}
	pre = cur; // 更新上一个节点
	if (cnt == maxCount2) { // 如果和最大值相同，则将其放入result
		result2.push_back(cur->val);
	}
	if (cnt > maxCount2) { // 如果计数大于最大频率
		maxCount2 = cnt; // 更新最大频率
		result2.clear(); // 清空result
		result2.push_back(cur->val); // 重新加入当前最大频率的元素
	}
	searchBST2(cur->right); // 右
	return;
}
vector<int> findMode2(TreeNode* root) {
	cnt = 0;
	maxCount2 = 0;
	TreeNode* pre = NULL; // 记录前一个节点
	result2.clear();
	searchBST2(root);
	return result2;
}

// 迭代法：将中序遍历转成迭代即可
vector<int> findMode3(TreeNode* root) {
	stack<TreeNode*> st;
	TreeNode* cur = root;
	TreeNode* pre = NULL;
	int maxCount3 = 0;
	int count = 0;
	vector<int> result3;
	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 == maxCount3) { // 如果和最大值相同，则将其放入result
				result3.push_back(cur->val);
			}
			if (count > maxCount3) { // 如果计数大于最大频率
				maxCount3 = count; // 更新最大频率
				result3.clear(); // 清空result
				result3.push_back(cur->val); // 重新加入当前最大频率的元素
			}
			pre = cur;
			cur = cur->right; // 右
		}
	}
	return result3;
}

int main() {
	TreeNode* root = new TreeNode(5);
	root->left = new TreeNode(3);
	root->right = new TreeNode(8);
	root->left->left = new TreeNode(1);
	root->left->right = new TreeNode(3);
	root->right->left = new TreeNode(7);
	root->right->right = new TreeNode(8);
	// 二叉树中序遍历：[1,3,3,5,7,8,8]
	vector<int> res = findMode2(root);
	for (int i = 0; i < res.size(); i++) {
		cout << res[i] << " ";
	}
}
// 结果为：3 8