1.错误思路;

我原来的思路是前序遍历

    void dfs(TreeNode* root,TreeNode* node,int low,int high){
        if(node){

            if(node->val<low||node->val>high){
                remove(root,node->val);
                
            }
            dfs(root,node->left,low,high);
            dfs(root,node->right,low,high);
        }
    }

挨个删除不符合low和high之间的元素，后面发现一个重大的bug是在遍历的时候删除元素，就是存在delete指针之后又再次访问原有内存空间的der B行为，然后把代码又改成

    void dfs(TreeNode* root,TreeNode* node,int low,int high){
        if(node){

            if(node->val<low||node->val>high){
                v.push_back(node);
            }
            dfs(root,node->left,low,high);
            dfs(root,node->right,low,high);
        }
    }

虽然理论上，可以行得通，但是后面发现这个样例输入无法通过

，后面发现直接remove函数里面如果加上了delete函数，就问题更大！

经过分析，认为原因依旧是出在原有删除算法上的问题，我这个原来的算法代码如下

class Solution {
public:
    vector<TreeNode*> v;
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        dfs(root, root, low, high);
        for (const auto& i : v) {
            remove(root, i->val);
        }
        return root;
    }

    void dfs(TreeNode* root, TreeNode* node, int low, int high) {
        if (node) {
            if (node->val < low || node->val > high) {
                v.push_back(node);
            }
            dfs(root, node->left, low, high);
            dfs(root, node->right, low, high);
        }
    }

    void remove(TreeNode*& node, int key) {
        if (!node) {
            return;
        }
        if (node->val < key) {
            remove(node->right, key);
        } else if (node->val > key) {
            remove(node->left, key);
        } else if (node->left && node->right) {
            TreeNode* iter = node->right;
            while (iter->left) {
                iter = iter->left;
            }
            node->val = iter->val;
            remove(node->right, node->val);
        } else {
            TreeNode* tmp = node;
            node = node->left ? node->left : node->right;
            delete tmp; // 将节点标记为需要删除，但不实际删除
        }
    }
};

问题依旧可能存在记录了待删除的指针，但是实际上挨个删除节点值得时候，采用懒惰删除，直接覆盖的方式，实际上没有改动指针的指向，因此仍然存在delete相应内存之后仍然访问原有内存的情况，因此出现内存段错误！
因此我的算法到此彻底破产BBQ了，只能直接抄答案抄题解了！

2.题解思路

思路：
根据BST特性，如果当前节点node的值小于low，则包括所有节点在内的所有左子树，必然不符合要求，同样的，如果当前节点node的值大于high，那么包括node在内的所有右子树必然都不符合要求，因此直接排除出去。最后递归只保留合适的元素。
本题带给我的启示非常大！一定不要边删除边遍历元素，容易出现段错误！
如果非要采用我原有的思路，可以再研究一下代码随想录的BST里面删除节点的代码算法！
后面发现代码随想录的代码也沦陷了，我的这个算法确实行不通了！只有题解的算法靠谱！

class Solution {
public:
    vector<TreeNode*> v;
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        if(!root){
            return nullptr;
        }
        if(root->val<low){
            return trimBST(root->right,low,high);
        }
        if(root->val>high){
            return trimBST(root->left,low,high);
        }
        if(root->val<=high&&root->val>=low){
            root->left=trimBST(root->left,low,high);
            root->right=trimBST(root->right,low,high);
            return root;
        }
        return root;
    }
    
    
};