lintcode(87)删除二叉查找树的节点

最新推荐文章于 2021-06-16 17:58:14 发布

原创最新推荐文章于 2021-06-16 17:58:14 发布 · 730 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #lintcode

本文介绍了一种从二叉查找树中删除指定值节点的方法。通过递归搜索找到目标节点，并根据节点的位置及子树情况调整树结构，确保删除操作后树仍保持二叉查找树特性。

Description:

给定一棵具有不同节点值的二叉查找树，删除树中与给定值相同的节点。如果树中没有相同值的节点，就不做任何处理。你应该保证处理之后的树仍是二叉查找树。

Explanation:

样例

给出如下二叉查找树：

/ \

3 6

/ \

2 4

删除节点3之后，你可以返回：

/ \

2 6

或者：

/ \

4 6

Solution:

觉得lintcode上数据量比较少，所以可能存在error没发现-_-||

需要讨论的情况比较多，先分当前节点是在前一个节点的左子树还是右子树，然后根据找到的节点左右子树是否为空，对当前节点进行修改。

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */
public class Solution {
    /**
     * @param root: The root of the binary search tree.
     * @param value: Remove the node with given value.
     * @return: The root of the binary search tree after removal.
     */
    public TreeNode removeNode(TreeNode root, int value) {
        // write your code here
        if(root == null) return root;
        
        if(root.val == value){
            if(root.left == null && root.right == null){
                return null;
            }else if(root.left != null){
                root.left.right = root.right;
                return root.left;
            }else{
                return root.right;
            }
        }
        
        TreeNode current = findCurrent(root , value);
        if(current != null){
            TreeNode previous = findPrevious(root , value);
            if(previous.val > value){
                if(current.left == null && current.right == null){
                    previous.left = null;
                }
                if(current.left != null && current.right == null){
                    previous.left = current.left;
                }
                if(current.left == null && current.right != null){
                    previous.left = current.right;
                }
                if(current.left != null && current.right != null){
                    previous.left = current.left;
                    previous.left.right = current.right;
                }
            }else{
                if(current.left == null && current.right == null){
                    previous.right = null;
                }
                if(current.left != null && current.right == null){
                    previous.right = current.left;
                }
                if(current.left == null && current.right != null){
                    previous.right = current.right;
                }
                if(current.left != null && current.right != null){
                    previous.right = current.right;
                    previous.right.left = current.left;
                }
            }
        }
        
        return root;
    }
    
    public TreeNode findCurrent(TreeNode root , int value){
        if(root == null) return root;
        if(root.val == value){
            return root;
        }
        if(root.val > value){
            return findCurrent(root.left , value);
        }
        if(root.val < value){
            return findCurrent(root.right , value);
        }
        return null;
    }
    
    public TreeNode findPrevious(TreeNode root , int value){
        if(root == null) return root;
        if(root.left != null && root.left.val == value){
            return root;
        }
        if(root.right != null && root.right.val == value){
            return root;
        }
        if(root.val > value){
            return findPrevious(root.left , value);
        }
        if(root.val < value){
            return findPrevious(root.right , value);
        }
        return null;
    }
}