Given the root of a binary tree, return the same tree where every subtree (of the given tree) not containing a 1 has been removed.

A subtree of a node node is node plus every node that is a descendant of node.

&nbsp;
Example 1:

Input: root = [1,null,0,0,1]
Output: [1,null,0,null,1]
Explanation: 
Only the red nodes satisfy the property "every subtree not containing a 1".
The diagram on the right represents the answer.


Example 2:

Input: root = [1,0,1,0,0,0,1]
Output: [1,null,1,null,1]


Example 3:

Input: root = [1,1,0,1,1,0,1,0]
Output: [1,1,0,1,1,null,1]


&nbsp;
Constraints:


	The number of nodes in the tree is in the range [1, 200].
	Node.val is either 0 or 1.


# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def pruneTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        
        def dfs(node):
            if not node:
                return None
            
            left = dfs(node.left)
            right = dfs(node.right)
            if node.val == 0 and not left and not right:
                return None
            else:
                node.left = left
                node.right = right
                return node
        
        return dfs(root)
            
class Solution {
    public TreeNode pruneTree(TreeNode root) {
        
        if(root == null) return root;
        
        root.left = pruneTree(root.left);
        root.right = pruneTree(root.right);
    
        if(root.left == null && root.right == null && root.val == 0) return null;
        else return root;
    }
}
class Solution {
public:
    TreeNode* pruneTree(TreeNode* root) {
        if(!root) return NULL;
        root->left = pruneTree(root->left);
        root->right = pruneTree(root->right);
        if(!root->left && !root->right && root->val==0) return NULL;
        return root;
    }
    
   
};
/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 * this.val = (val===undefined ? 0 : val)
 * this.left = (left===undefined ? null : left)
 * this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {TreeNode}
 */
var pruneTree = function(root) {
    let rec = function(node){
        if(node==null) return null;
        if(node.val===0 && node.left == null && node.right == null){
            return null
        }
        node.left = rec(node.left);
        node.right = rec(node.right);
        // For updated tree structure if threre are leaf nodes with zero value present, if yes then return null otherewise return node itself.
        if(node.val===0 && node.left == null && node.right == null){
            return null
        }
        return node;
    }
    rec (root);
    if(root.val == 0 && root.left == null && root.right == null) return null

    return root;
};
Binary Tree Pruning