Java——二叉搜索树（查找、插入、删除）

二叉搜索树是一种特殊的二叉树，保证了左子树的所有数据都小于根节点，右子树的所有数据都大于根节点，是比较常用的一种数据结构。类似于下图：

既然是一种特殊的二叉树，那么二叉树的一些性质都适用，但由于其数据的特殊性，经常会用于求最大值、最小值、上界、下界、第k个元素或者元素i所在的位置，复杂的题目练习下一篇文章中将介绍。
那么先对二叉搜索树的简单操作进行回顾：

（一）建立上图的搜索二叉树

public static TreeNode newTree(){
    TreeNode node1 = new TreeNode(1);
    TreeNode node2 = new TreeNode(2);
    TreeNode node3 = new TreeNode(3);
    TreeNode node4 = new TreeNode(4);
    TreeNode node5 = new TreeNode(5);
    node1.left = null;
    node1.right = null;
    node2.left = node1;
    node2.right = node5;
    node5.left = node3;
    node5.right = null;
    node3.right = node4;
    node3.left = null;
    node4.left = null;
    node4.left = null;
    return node2;
}

（二）查找：

二叉树的遍历方式都可用于二叉搜索树，而二叉搜索树的数据特殊性会简化二叉树的遍历。因为数据相对于root来说是有序的，所以只要根据数据与root的关系确定遍历左子树或者右子树即可。
1.root==key，返回
2.root<key,遍历右子树
3.root>key,返回左子树
4.无法查找到数据，返回-1
递归实现：

public static int search(TreeNode root,int key){
    if(root==null) return -1;
    if(key<root.val) return search(root.left,key);
    if(key>root.val) return search(root.right,key);
    return root.val;
}

非递归实现一
根据普通二叉树的遍历方式，我们可以写出如下的非递归遍历方式：

public static int search_n(TreeNode root,int key){
        if(root == null) return -1;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            if(key==node.val)
                return node.val;
            if(key<node.val&&node.left!=null)
                stack.push(node.left);
            if(key>node.val&&node.right!=null)
                stack.push(node.right);
        }
        return -1;
    }

非递归实现二
但是搜索二叉树数据的特殊性，我们可以通过以下方式完成：

public static int search_n_p(TreeNode root, int key){
    if(root == null) return -1;
    while(root!=null){
        if(root.val==key) return root.val;
        else if(key<root.val) root = root.left;
        else root = root.right;
    }
    return -1;
}

（三）插入

插入节点分为两种情况
1.树中存在该节点，那么直接返回就可以了；
2.树中不存在该节点，那么遍历找到相应的插入位置进行插入操作；
由于搜索树有数据大小的限制，所以其遍历的时候也要考虑数据的大小。
递归实现：
因为最后插入的节点要与其前驱节点相连接，所以返回时要注意连接当前节点的左右孩子。

public static TreeNode insert(TreeNode root, int key){
    if(root==null)
        return new TreeNode(key);
    if(root.val<key)
        root.right = insert(root.right,key);
    if(root.val>key)
        root.left = insert(root.left,key);
    if(root.val==key)
        root.val = key;
    return root;
}

非递归实现：
同样，要记录当前插入节点的位置，所以必须记录插入点的前驱。当前节点的大小<key，在其父节点的左边插入；<key，再起父节点的右边插入。

public static void insert_n(TreeNode root, int key){
        TreeNode pre;
        while(root!=null){
            if(root.val == key) return;
            else if(root.val<key){
                pre = root;
                root = root.right;
                if(root==null)
                    pre.right = new TreeNode(key);
            }
            else {
                pre = root;
                root = root.left;
                if(root==null)
                    pre.left = new TreeNode(key);
            }
        }
    }

（四）删除

对于二叉树的删除操作比较复杂，主要分为以下三种情况：
1.删除节点为叶子结点：直接删除
2.删除节点只有左子树或只有右子树：删除当前节点，并与唯一孩子连接
3.删除节点既包含左子树又包含右子树：找到右子树最小节点，替换当前节点（找到右子树最小节点，删除最小节点并保存，用删除的节点替换要删除的节点）。

 //查找最小节点,返回最小节点
    public static TreeNode findMin(TreeNode root){
        if(root==null) return null;
        while(root.left!=null){
            root = root.left;
        }
        return root;
    }
    //删除最小节点，返回的是删除节点后的树
    public static TreeNode deleteMin(TreeNode root){
        //找到最左边的节点，返回其右子树（null或者不为null的右子树）
        if(root.left == null)
            return root.right;
        //一直遍历结点的左边进行删除，所以用左子树承接剩下的(右子树)
        root.left = deleteMin(root.left);
        return root;
    }
    //删除节点,返回的是删除后的根节点
    public static TreeNode delete(TreeNode root, int key){
        if(root == null) return null;
        if(root.val<key)
            root.right =  delete(root.right,key);
        else if(root.val>key)
            root.left =  delete(root.left,key);
        else{//相等节点，进行删除
            //判断删除节点类型
            if(root.left==null) return root.right;
            if (root.right==null) return root.left;
            TreeNode right_min = root;
            root = findMin(right_min.right);
            root.right = deleteMin(right_min.right);
            root.left = right_min.left;
        }
        return root;
    }

下面给出上面的测试用例：

import com.sun.source.tree.Tree;

import java.util.Stack;

public class BinaryTreeOrder {
    public static void main(String args[]){
        TreeNode root = newTree();

        TreeNode nodemin = findMin(root);
        System.out.println("最小节点"+nodemin.val); //1

        deleteMin(root);
        TreeNode nodemin2 = findMin(root);
        System.out.println("进行一次删除最小节点操作后，当前最小节点"+nodemin2.val); //2

        System.out.println("递归查找节点值为6："+search(root,6));//-1
        insert(root,6);
        System.out.println("插入6后，查找6："+search_n_p(root,6));//6

        System.out.println("非递归方法一，查找节点值5："+search_n(root,5));//5
        delete(root,5);
        System.out.println("删除5后，非递归方法二查找节点值5："+search_n_p(root,5));//-1
    }
    //查找最小节点,返回最小节点
    public static TreeNode findMin(TreeNode root){
        if(root==null) return null;
        while(root.left!=null){
            root = root.left;
        }
        return root;
    }
    //删除最小节点，返回的是删除节点后的树
    public static TreeNode deleteMin(TreeNode root){
        //找到最左边的节点，返回其右子树（null或者不为null的右子树）
        if(root.left == null)
            return root.right;
        //一直遍历结点的左边进行删除，所以用左子树承接剩下的(右子树)
        root.left = deleteMin(root.left);
        return root;
    }
    //删除节点,返回的是删除后的根节点
    public static TreeNode delete(TreeNode root, int key){
        if(root == null) return null;
        if(root.val<key)
            root.right =  delete(root.right,key);
        else if(root.val>key)
            root.left =  delete(root.left,key);
        else{//相等节点，进行删除
            //判断删除节点类型
            if(root.left==null) return root.right;
            if (root.right==null) return root.left;
            TreeNode right_min = root;
            root = findMin(right_min.right);
            root.right = deleteMin(right_min.right);
            root.left = right_min.left;
        }
        return root;
    }


    public static void insert_n(TreeNode root, int key){
        TreeNode pre;
        while(root!=null){
            if(root.val == key) return;
            else if(root.val<key){
                pre = root;
                root = root.right;
                if(root==null)
                    pre.right = new TreeNode(key);
            }
            else {
                pre = root;
                root = root.left;
                if(root==null)
                    pre.left = new TreeNode(key);
            }
        }
    }
    public static TreeNode insert(TreeNode root, int key){
        if(root==null)
            return new TreeNode(key);
        if(root.val<key)
            root.right = insert(root.right,key);
        if(root.val>key)
            root.left = insert(root.left,key);
        if(root.val==key)
            root.val = key;
        return root;
    }


    public static int search(TreeNode root,int key){
        if(root==null) return -1;
        if(key<root.val) return search(root.left,key);
        if(key>root.val) return search(root.right,key);
        return root.val;
    }
    public static int search_n(TreeNode root,int key){
        if(root == null) return -1;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            if(key==node.val)
                return node.val;
            if(key<node.val&&node.left!=null)
                stack.push(node.left);
            if(key>node.val&&node.right!=null)
                stack.push(node.right);
        }
        return -1;
    }
    public static int search_n_p(TreeNode root, int key){
        if(root == null) return -1;
        TreeNode node = root;
        while(node!=null){
            if(node.val==key) return node.val;
            else if(key<node.val) node = node.left;
            else node = node.right;
        }
        return -1;
    }
    public static TreeNode newTree(){
        TreeNode node1 = new TreeNode(1);
        TreeNode node2 = new TreeNode(2);
        TreeNode node3 = new TreeNode(3);
        TreeNode node4 = new TreeNode(4);
        TreeNode node5 = new TreeNode(5);
        node1.left = null;
        node1.right = null;
        node2.left = node1;
        node2.right = node5;
        node5.left = node3;
        node5.right = null;
        node3.right = node4;
        node3.left = null;
        node4.left = null;
        node4.left = null;
        return node2;
    }
}