Leetcode（1110）——删点成林

Leetcode（1110）——删点成林

题目

给出二叉树的根节点 root，树上每个节点都有一个不同的值。

如果节点值在 to_delete 中出现，我们就把该节点从树上删去，最后得到一个森林（一些不相交的树构成的集合）。

返回森林中的每棵树。你可以按任意顺序组织答案。

示例 1：

输入：root = [1,2,3,4,5,6,7], to_delete = [3,5]
输出：[[1,2,null,4],[6],[7]]

示例 2：

输入：root = [1,2,4,null,3], to_delete = [3]
输出：[[1,2,4]]

提示：

• 树中的节点数最大为 1000。
• 每个节点都有一个介于 1 到 1000 之间的值，且各不相同。
• to_delete.length <= 1000
• to_delete 包含一些从 1 到 1000、各不相同的值。

题解

方法：递归+DFS+哈希表（其实还有队列，但可以被优化）

思路

​​  因为所有的值都是不同的，所以可以根据结点的值来判断是不是要删除的点。首先把 to_delete 数组的全部元素都存入哈希表 set，以方便后面的快速查找并对比。另外，如果结点被删除，其父结点的 left 、 right 字段需要更新。

而要删除的点有两种情况：叶子结点和父母结点

1. 如果是叶子结点，直接删除即可；
2. 如果是父母结点，还要将其左右子树作为新的树的根结点加入到队列中。

代码实现

我的初始版本

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    queue<TreeNode*> tmp;
    unordered_set<int> to_del;
public:
    vector<TreeNode*> delNodes(TreeNode* root, vector<int>& to_delete) {
        // 因为所有的值都是不同的，所以根据值来判断是不是要删除的点
        // 要删除的点有两种情况：叶子结点和父母结点
        // 1.叶子结点的话直接删除即可
        // 2.父母结点的话删除了，还要将其左右子树作为新的树的根结点加入到数组中
        for(auto it: to_delete)to_del.emplace(it);
        vector<TreeNode*> ans;
        tmp.push(root);
        // dfs(root);
        while(!tmp.empty()){
            if(dfs(tmp.front())) tmp.pop(); // 如果返回 true 证明 it 指向的点是被删除的
            else{
                ans.push_back(tmp.front());
                tmp.pop();
            }
        }
        return ans;
    }
    bool dfs(TreeNode* root){
        if(root == nullptr) return false;
        // 判断当前结点是不是要删除的点
        if(to_del.count(root->val) != 0){
            // 判断是不是叶子结点
            if(root->left != nullptr || root->right != nullptr){
                // 不是叶子结点
                if(root->left != nullptr) tmp.push(root->left);
                if(root->right != nullptr) tmp.push(root->right);
            }
            return true;
        }else{
            if(dfs(root->left)) root->left = nullptr;
            if(dfs(root->right)) root->right = nullptr;
            return false;
        }
    }
};

我的优化版本（删去队列）

class Solution {
    unordered_set<int> to_del;
    vector<TreeNode*> ans;
public:
    vector<TreeNode*> delNodes(TreeNode* root, vector<int>& to_delete) {
        for(auto it: to_delete)to_del.emplace(it);
        if(to_del.count(root->val) == 0) ans.push_back(root);
        dfs(root);
        return ans;
    }
    bool dfs(TreeNode* root){
        if(root == nullptr) return false;
        if(to_del.count(root->val) != 0){
            if(root->left != nullptr || root->right != nullptr){
                if(root->left != nullptr){
                    if(to_del.count(root->left->val) == 0) ans.push_back(root->left);
                    dfs(root->left);
                }
                if(root->right != nullptr){
                    if(to_del.count(root->right->val) == 0) ans.push_back(root->right);
                    dfs(root->right);
                }
            }
            return true;
        }else{
            if(dfs(root->left)) root->left = nullptr;
            if(dfs(root->right)) root->right = nullptr;
            return false;
        }
    }
};

其它网友的题解

class Solution {
public:
	TreeNode* delNodesCore(TreeNode*& root, unordered_set<int>& set, vector<TreeNode*>& vec) {
    	if(!root)   return NULL;
    	delNodesCore(root->left, set, vec);
	    delNodesCore(root->right, set, vec);
	    if(set.find(root->val) != set.end())
	    {
	        if(root->left)  vec.push_back(root->left);
	        if(root->right)  vec.push_back(root->right);
	        delete(root);
	        root = NULL;
	    }
	    return root;
	}

	vector<TreeNode*> delNodes(TreeNode* root, vector<int>& to_delete) {
	    vector<TreeNode*> vec;
	    unordered_set<int> set(to_delete.begin(), to_delete.end());
	    delNodesCore(root, set, vec);
	    if(root)   vec.push_back(root);
	    return vec;
	}
};

复杂度分析

时间复杂度：$O(n)$，其中 $n$ 指的是树的结点个数。因为要遍历一遍树的全部结点。
空间复杂度：$O(i)$，其中 $i$ 指数组 to_delete 中的元素个数。因为要建立哈希表来存储数组 to_delete 中的全部 $i$ 个元素。