二叉树中最大的二叉搜索子树

问题描述

思路和代码

暴力方法是每个节点为根节点，然后判断以该节点为根节点的树是否是二叉搜索树，然后求规模最大的，这种方式的时间复杂度是$O(N^2)$，空间复杂度是$O(h)$。

搜索二叉树左子树所有的数据都小于等于根节点，右子树所有的数据大于等于根节点；定义是递归的。如果左子树，有一个节点不满足，那么整个左子树都不是二叉搜索树，右子树同理。后序遍历的特征是，我们能在访问根节点前，遍历并获取所有左右子树的特性。

我们用LBST表示左子树中，最大的二叉搜索子树的根节点，LSize表示它的个数，LMin表示它的最小值，LMax表示它的最大值。RBST、RSize、RMin和RMax表示右子树对应的值。

那么，如果LBST和RBST中的至少一个不是当前节点root的孩子的话，则需要选择大的那个作为当前最大二叉搜索树；如果都是root的孩子，则左侧需要LMax<=root->val，右侧需要RMin>=root->val，如果满足，则当前节点是目前最大二叉搜索树，否则选择最大的那个孩子；利用后序不断递归求解即可。

#include <iostream>
#include <memory>
#include <algorithm>

const int TAG = -100;  // 终止的标记
const int INF = 10000000;

struct Node {
    int val;
    std::shared_ptr<Node> left{nullptr}, right{nullptr};
    Node(int n = 0): val(n), left(nullptr), right(nullptr) {}
};

struct Info {
    int Max{-INF}, Min{INF}, Size{0};
};

std::shared_ptr<Node> CreateTreeNode() {
    int n;
    std::cin >> n;
    if (n == TAG) {
        return nullptr;
    }
    auto root = std::make_shared<Node>(n);
    root->left = CreateTreeNode();
    root->right = CreateTreeNode();
    return root;
}

// 后序遍历二叉树，只要某个节点左子树的某个部分不是二叉搜索树，则整个左子树都不是二叉搜索树
std::shared_ptr<Node> MaxSubSearchTree(const std::shared_ptr<Node>& root, Info &info) {
    if (root == nullptr) {
        info.Size = 0;
        info.Max = -INF;
        info.Min = INF;
        return nullptr;
    }
    int val = root->val;
    auto LBST = MaxSubSearchTree(root->left, info);
    int LSize = info.Size;
    int LMin = info.Min;
    int LMax = info.Max;
    auto RBST = MaxSubSearchTree(root->right, info);
    int RSize = info.Size;
    int RMin = info.Min;
    int RMax = info.Max;
    info.Min = std::min(LMin, root->val);
    info.Max = std::max(RMax, root->val);
    if (root->left == LBST && root->right == RBST && LMax <= root->val && RMin >= root->val) {
        info.Size = LSize + RSize + 1;
        return root;
    }
    info.Size = std::max(LSize, RSize);  // 返回左右子树规模大的那个
    return LSize > RSize ? LBST: RBST;
}

void PreOrder(const std::shared_ptr<Node>& root) {
    if (root == nullptr) {
        return;
    }
    std::cout << root->val << " ";
    PreOrder(root->left);
    PreOrder(root->right);
}

int main() {
    // 6 1 0 -100 -100 3 -100 -100 12 10 4 2 -100 -100 5 -100 -100 14 11 -100 -100 15 -100 -100 13 20 -100 -100 16 -100 -100
    std::cout << "Create Tree:\n";
    auto root = CreateTreeNode();
    Info info{-INF, INF, 0};
    auto p = MaxSubSearchTree(root, info);
    PreOrder(p);
    return 0;
}

代码输出：

10 4 2 5 14 11 15