LeetCode 솔루션

669. Trim a Binary Search Tree

mingki 쪽지보내기 메일보내기 자기소개 아이디로 검색 전체게시물 작성
작성일 2022.04.14 20:22

7,287 조회
4 댓글
0 추천
0 비추천
목록 게시글 쓰기

[ LeetCode 시즌 3 ] 2022년 4월 14일 문제입니다.

[Medium] 669. Trim a Binary Search Tree

Given the root of a binary search tree and the lowest and highest boundaries as low and high, trim the tree so that all its elements lies in [low, high]. Trimming the tree should not change the relative structure of the elements that will remain in the tree (i.e., any node's descendant should remain a descendant). It can be proven that there is a unique answer.

Return the root of the trimmed binary search tree. Note that the root may change depending on the given bounds.

Example 1:

Input: root = [1,0,2], low = 1, high = 2
Output: [1,null,2]

Example 2:

Input: root = [3,0,4,null,2,null,null,1], low = 1, high = 3
Output: [3,2,null,1]

Constraints:

The number of nodes in the tree in the range [1, 104].
0 <= Node.val <= 104
The value of each node in the tree is unique.
root is guaranteed to be a valid binary search tree.
0 <= low <= high <= 104

#leetcode, #문제풀이, #시즌3, #medium, #amazon, #facebook, #microsoft, #yahoo, #tree, #depth-first search, #binary search tree, #binary tree

링크

https://leetcode.com/problems/trim-a-binary-search-tree/ 1382 회 연결

익명
작성일 2022.04.14 20:29

재귀적 접근

class Solution {
    public TreeNode trimBST(TreeNode root, int low, int high) {
        
        if(root == null){ 
            return null; 
        }
        
        if(root.val > high){
            return trimBST(root.left, low, high);
        }
        if(root.val < low){
            return trimBST(root.right, low, high);
        }
        
        root.left = trimBST(root.left, low, high);
        root.right = trimBST(root.right, low, high);
        
        return root;
    }
}

익명
작성일 2022.04.15 11:07

class Solution:
    def trimBST(self, root: Optional[TreeNode], low: int, high: int) -> Optional[TreeNode]:
        def rec(root):
            if not root:
                return None
            if root.val < low:
                return rec(root.right)
            elif root.val > high:
                return rec(root.left)
            else:
                root.left = rec(root.left)
                root.right = rec(root.right)
                return root
        return rec(root)

익명
작성일 2022.04.15 12:22

C++
Runtime: 19 ms, faster than 66.98% of C++ online submissions for Trim a Binary Search Tree.
Memory Usage: 24 MB, less than 7.08% of C++ online submissions for Trim a Binary Search Tree.

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

익명
작성일 2022.04.17 00:25

Runtime: 20 ms, faster than 46.21% of C++ online submissions for Trim a Binary Search Tree.
Memory Usage: 17.3 MB, less than 94.24% of C++ online submissions for Trim a Binary Search Tree.

class Solution {
public:
    void leftTrim(TreeNode* &p,const int &low, const int &high){
        
        if(p->left != nullptr)
            leftTrim(p->left,low,high);
        if(p->right != nullptr)
            rightTrim(p->right,low,high);
        
        if(p->val < low){
            p=p->right;
        }else if(p->val > high){
            p=p->left;
        };
        return ;
    };
    
    void rightTrim(TreeNode* &p, const int &low, const int &high){
    
        if(p->left != nullptr)
            leftTrim(p->left,low,high);
        if(p->right != nullptr)
            rightTrim(p->right,low,high);
        
        if(p->val > high){
            p=p->left;
        }else if(p->val < low){
            p=p->right;
        };
        
        return ;
    };
    
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        
        if(root->val < low){
            leftTrim(root,low,high);
        }else{
            rightTrim(root,low,high);
        };
        return root;
    }
};

Runtime: 20 ms, faster than 46.21% of C++ online submissions for Trim a Binary Search Tree.
Memory Usage: 17.3 MB, less than 94.24% of C++ online submissions for Trim a Binary Search Tree.
[code=C++]class Solution {
public:
    void leftTrim(TreeNode* &p,const int &low, const int &high){
        
        if(p->left != nullptr)
            leftTrim(p->left,low,high);
        if(p->right != nullptr)
            rightTrim(p->right,low,high);
        
        if(p->val < low){
            p=p->right;
        }else if(p->val > high){
            p=p->left;
        };
        return ;
    };
    
    void rightTrim(TreeNode* &p, const int &low, const int &high){
    
        if(p->left != nullptr)
            leftTrim(p->left,low,high);
        if(p->right != nullptr)
            rightTrim(p->right,low,high);
        
        if(p->val > high){
            p=p->left;
        }else if(p->val < low){
            p=p->right;
        };
        
        return ;
    };
    
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        
        if(root->val < low){
            leftTrim(root,low,high);
        }else{
            rightTrim(root,low,high);
        };
        return root;
    }
};[/code]