【450. 删除二叉搜索树中的节点】二叉树遍历

import java.util.HashMap;
import java.util.Map;

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public static void main(String[] args) {
        TreeNode root = new TreeNode(5);
        root.left = new TreeNode(3);
        root.right = new TreeNode(6);
        root.left.left = new TreeNode(2);
        root.left.right = new TreeNode(4);
        root.right.right = new TreeNode(7);

        TreeNode ans = new Solution().deleteNode(root,7);
        System.out.println(ans.val);
    }
    public TreeNode deleteNode(TreeNode root, int key) {
        Map<Integer,TreeNode> map = new HashMap<>();
        travel(root,map);
        TreeNode searchNode = map.get(key);
        if( searchNode == null){
            return root;
        }
        TreeNode rightMin = rightDfs(searchNode.right);

        if( rightMin != null){
            TreeNode parent = searchNode(root, null, rightMin);
            searchNode.val  = rightMin.val;
            if(parent.right != null && parent.right.val == rightMin.val){
                parent.right = rightMin.right;
            }else{
                parent.left = rightMin.right;
            }
            return root;
        }
        TreeNode leftMax = leftDfs(searchNode.left);

        if( leftMax != null){
            TreeNode parent = searchNode(root,null,leftMax);
            searchNode.val = leftMax.val;
            if(parent.right != null &&parent.right.val == leftMax.val){
                parent.right = leftMax.left;
            }else{
                parent.left = leftMax.left;
            }
            return root;
        }
        TreeNode parent = searchNode(root, null, searchNode);
        if(parent == null){
            return null;
        }
        if(parent.right != null && parent.right.val == searchNode.val){
            parent.right = null;
        }else{
            parent.left = null;
        }
        return root;
    }

    public TreeNode searchNode(TreeNode root,TreeNode parent,TreeNode node){
        if( root == null){
            return null;
        }
        if( root.val == node.val){
            return parent;
        }
        TreeNode parentNode = searchNode(root.left,root,node);
        if( parentNode != null){
            return parentNode;
        }
        parentNode = searchNode(root.right,root,node);
        if( parentNode != null){
            return parentNode;
        }
        return null;
    }

    public void travel(TreeNode root,Map<Integer,TreeNode> map){
        if( root == null){
            return;
        }
        travel(root.left,map);
        map.put(root.val,root);
        travel(root.right,map);
    }

    public TreeNode rightDfs(TreeNode root){
        if( root == null){
            return null;
        }
        if( root.left == null){
            return root;
        }
        TreeNode node = rightDfs(root.left);
        if( node == null){
            return root;
        }
        return node;
    }

    public TreeNode leftDfs(TreeNode root){
        if( root == null){
            return null;
        }
        if( root.right == null){
            return root;
        }
        TreeNode node = leftDfs(root.right);
        if( node == null){
            return root;
        }
        return node;

    }
}