74. 搜索二维矩阵 - 力扣(LeetCode)
class Solution {
public:
bool searchMatrix(vector<vector<int>>& matrix, int target) {
int n = matrix.size(), m = matrix[0].size();
int x = 0, y = m - 1;
while(true)
{
if(x >= n || y < 0) return false;
if(matrix[x][y] == target) return true;
if(matrix[x][y] < target)
{
x ++;
}
else y --;
}
return true;
}
};
173. 二叉搜索树迭代器 - 力扣(LeetCode)
class BSTIterator {
private:
TreeNode* cur;
stack<TreeNode*> stk;
public:
BSTIterator(TreeNode* root): cur(root) {}
int next() {
while(cur != nullptr)
{
stk.push(cur);
cur = cur->left;
}
cur = stk.top();
stk.pop();
int ret = cur->val;
cur = cur->right;
return ret;
}
bool hasNext() {
return cur || !stk.empty();
}
};
331. 验证二叉树的前序序列化 - 力扣(LeetCode)
671. 二叉树中第二小的节点 - 力扣(LeetCode)
class Solution {
public:
int ans = -1;
int findSecondMinimumValue(TreeNode* root) {
dfs(root, root->val);
return ans;
}
void dfs(TreeNode* root, int val)
{
if(root == nullptr) return;
if(root->val != val)
{
if(ans == -1) ans = root->val;
else ans = min(ans, root->val);
return;
}
dfs(root->left, val);
dfs(root->right, val);
}
};
778. 水位上升的泳池中游泳 - 力扣(LeetCode)
优先队列
class Solution {
public:
typedef pair<int,int> PII;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
int swimInWater(vector<vector<int>>& grid) {
//深度优先搜索
int n = grid.size(), m = grid[0].size();// x * m + y
priority_queue <PII, vector<PII>, greater<PII> > q;
vector<int> st(m * n);
q.push({grid[0][0], 0});
st[0] = true;//入队和出队都只有一次,所有保证入队一次即可
int ans;
int cnt = 0;
while(!q.empty())
{
cnt ++;
auto t = q.top();
q.pop();
int dep = t.first, u = t.second;
if(u == m * n - 1)
{
ans = dep;
break;
}
for(int i = 0; i < 4; i ++ )
{
int nx = dx[i] + u / m;
int ny = dy[i] + u % m;
if(nx < 0 || ny < 0 || nx >= n || ny >= m) continue;
if(st[nx * m + ny]) continue;//只会入队一次
q.push({max(dep, grid[nx][ny]), nx * m + ny});
st[nx * m + ny] = true;
}
}
return ans;
}
};
并查集
class Solution {
public:
int f[2510];
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
int find(int x)
{
if(f[x] == x) return x;
return f[x] = find(f[x]);
}
int swimInWater(vector<vector<int>>& grid) {
//从最小的开始,每次将这个点和周围比他小的点连接起来,直到起点和终点连接起来了
vector<pair<int, int>> nums;
int n = grid.size();
for(int i = 0; i < n * n; i ++ ) f[i] = i;
for(int i = 0; i < n; i ++ )
for(int j = 0; j < n; j ++ )
{
nums.push_back({grid[i][j], i * n + j});
}
sort(nums.begin(), nums.end());//从小到大
int ans;
for(int i = 0; i < nums.size(); i ++ )
{
int dep = nums[i].first, u = nums[i].second;
int a = find(u);
for(int j = 0; j < 4; j ++ )
{
int nx = dx[j] + u / n;
int ny = dy[j] + u % n;
if(nx < 0 || ny < 0 || nx >= n || ny >= n) continue;
if(dep > grid[nx][ny])
{
int b = find(nx * n + ny);
f[b] = a;
}
}
if(find(0) == find(n * n - 1))
{
ans = dep;
break;
}
}
return ans;
}
};
897. 递增顺序搜索树 - 力扣(LeetCode)
class Solution {
public:
TreeNode* last;
TreeNode* increasingBST(TreeNode* root) {
//拉成链
dfs(root);
return last;
}
void dfs(TreeNode* root)
{
if(root == nullptr) return;
TreeNode* l = root->left;
dfs(root->right);
root->right = last;
root->left = nullptr;//每个节点都要有
last = root;
dfs(l);
}
};
2
230. 二叉搜索树中第K小的元素 - 力扣(LeetCode)
class Solution {
public:
int ans = -1;
int cnt = 0;
int kthSmallest(TreeNode* root, int k) {
//中序遍历
dfs(root, k);
return ans;
}
void dfs(TreeNode* root, int k)
{
if(ans != -1) return ;//找到答案。
if(root == nullptr) return ;
dfs(root->left, k);
cnt += 1;
if(cnt == k) ans = root->val;//这说正好是根为第k小
dfs(root->right, k);
}
};
538. 把二叉搜索树转换为累加树 - 力扣(LeetCode)
逆中序遍历
class Solution {
public:
int last = 0;
TreeNode* bstToGst(TreeNode* root) {
dfs(root);
return root;
}
void dfs(TreeNode* root)
{
if(root == nullptr) return;
dfs(root->right);
root->val += last;
last = root->val;
dfs(root->left);
}
};
450. 删除二叉搜索树中的节点 - 力扣(LeetCode)
class Solution {
public:
//简单思路,遍历成链
TreeNode* last = nullptr;
TreeNode* deleteNode(TreeNode* root, int key) {
dfs(root, key);
return last;
}
void dfs(TreeNode* root, int key)
{
if(root == nullptr) return;
TreeNode* r = root->right;//涉及last的一定要记录下当前的左右节点
TreeNode* l = root->left;
dfs(l, key);
if(root->val != key)
{
root->left = last;
root->right = nullptr;
last = root;
}
dfs(r, key);
}
};
98. 验证二叉搜索树 - 力扣(LeetCode)
class Solution {
public:
bool flag = true;
int last;
int num = 1;
bool isValidBST(TreeNode* root) {
dfs(root);
return flag;
}
void dfs(TreeNode* root)
{
if(root == nullptr || flag == false) return;
dfs(root->left);
if(num != 1)
{
if(root->val <= last) flag = false;
}
else num ++;
last = root->val;
dfs(root->right);
}
};
701. 二叉搜索树中的插入操作 - 力扣(LeetCode)
递归搜索空节点
class Solution {
public:
TreeNode* insertIntoBST(TreeNode* root, int val) {
if(root == nullptr) return new TreeNode(val);
if(root->val > val)
root->left = insertIntoBST(root->left, val);
if(root->val < val)
root->right = insertIntoBST(root->right, val);
return root;
}
};
96. 不同的二叉搜索树 - 力扣(LeetCode)
class Solution {
public:
int dp[100];
int numTrees(int n) {
dp[0] = 1;
for(int i = 1; i <= n; i ++ )//总点数
{
for(int j = 1; j <= i; j ++ )//根节点的位置
{
dp[i] += dp[j - 1] * dp[i - j];
}
}
return dp[n];
}
};
95. 不同的二叉搜索树 II - 力扣(LeetCode)
寻找1-n
的所有左右儿子节点
class Solution {
public:
vector<TreeNode*> generateTrees(int n) {
if(n == 0) return {};
return build(1, n);
}
vector<TreeNode*> build(int l, int r)
{
vector<TreeNode*> res;
if(l > r)
{
res.push_back(nullptr);
return res;
}
for(int i = l; i <= r; i ++ )
{
vector<TreeNode*> ltree = build(l, i - 1);
vector<TreeNode*> rtree = build(i + 1, r);
for(auto left: ltree)
for(auto right: rtree)
{
TreeNode* root = new TreeNode(i);
root->left = left;
root->right = right;
res.push_back(root);
}
}
return res;
}
};
1373. 二叉搜索子树的最大键值和 题解 - 力扣(LeetCode)
class Solution {
private:
// 记录全局的最大键值和
int maxRes = 0;
// 返回值
// 0: 1是搜索树,0不是搜索树
// 1: 最小值
// 2: 最大值
// 3: 总和: 对于非搜索树,直接返回0
vector<int> dfs(TreeNode* curr)
{
if (curr == nullptr)
{
return {1, INT_MAX, INT_MIN, 0};
}
auto l = dfs(curr->left);
auto r = dfs(curr->right);
vector<int> res(4, 0);
// 只有满足二叉搜索树,才返回结果
// cout << l[0] << " " << r[0] << " " << l[2] << " " << r[1] << " : " << curr->val << endl;
if (l[0] == 1 && r[0] == 1 && l[2] < curr->val && r[1] > curr->val)
{
res[0] = 1;
res[1] = min(l[1], curr->val);
res[2] = max(r[2], curr->val);
res[3] = l[3] + r[3] + curr->val;
maxRes = max(maxRes, res[3]);
}
return res;
}
public:
int maxSumBST(TreeNode* root) {
dfs(root);
return maxRes;
}
};