二叉搜索树

二叉搜索树
1.概念
二叉搜索树又称二叉排序树，它或者是一棵空树**，或者是具有以下性质的二叉树:
若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
它的左右子树也分别为二叉搜索树。

2.查找

3.插入

4.删除
设待删除结点为 cur, 待删除结点的双亲结点为 parent

1. cur.left == null
   1.cur 是 root，则 root = cur.right
   2.cur 不是 root，cur 是 parent.left，则 parent.left = cur.right
   3.cur 不是 root，cur 是 parent.right，则 parent.right = cur.right
2. cur.right == null
   1.cur 是 root，则 root = cur.left
   2.cur 不是 root，cur 是 parent.left，则 parent.left = cur.left
   3.cur 不是 root，cur 是 parent.right，则 parent.right = cur.left
3. cur.left != null && cur.right != null 需要使用替换法进行删除，即在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题。
   示例：

//和类关联的方法用static
public class BinarySearchTree {
    public static class Node{
        int key;
        Node left;
        Node right;
        public Node(int key){
            this.key=key;
        }
    }
    private Node root=null;
    
    /**
     * 查找
     * 在搜索树中查找key，如果找到则返回key所在的节点，否则返回null
     * @param key
     * @return null
     */
    public Node search(int key){
        Node cur=root;
        while(cur!=null){
            if(key==cur.key){
                return cur;
            }else if(key<cur.key){
                return cur.left;
            }else if(key>cur.key){
                return cur.right;
            }
        }
        return null;
    }
    
    /**
     * 插入
     * @param key
     * @return true表示插入成功，false表示插入失败
     */
    public boolean insert(int key){
        if(root==null){
            root=new Node(key);
            return true;
        }
        Node cur=root;
        Node parent=null;
        while(cur!=null){
            if(key==cur.key){
                return false;
            }else if(key<cur.key){
                parent=cur;
                cur=cur.left;
            }else if(key>cur.key){
                parent=cur;
                cur=cur.right;
            }
        }
        Node node=new Node(key);
        if(key<parent.key){
            parent.left=node;
        }else if(key>parent.key){
            parent.right=node;
        }
        return true;
    }
    
    /**
     * 删除成功返回true，删除失败返回false
     * @param key
     * @return
     */
    public boolean remove(int key){
        Node cur=root;
        Node parent=null;
        while(cur!=null){
            if(key==cur.key){
                removeNode(parent,cur);
                return true;
            }else if(key<cur.key){
                parent=cur;
                cur=cur.left;
            }else if(key>cur.key){
                parent=cur;
                cur=cur.right;
            }
        }
        return false;
    }

    private void removeNode(Node parent,Node cur){
        if(cur.left==null){
            if(cur==root){
                root=cur.right;
            }else if(parent.left==null){
                parent.right=cur.right;
            }else if(parent.right==null){
                parent.left=cur.right;
            }
        }else if(cur.right==null){
            if(cur==root){
                root=cur.left;
            }else if(parent.left==null){
                parent.right=cur.left;
            }else if(parent.right==null){
                parent.left=cur.left;
            }
        }else{
            Node goatParent=cur;
            Node goat=cur.right;
            while(goat.left!=null){
                goatParent=goat;
                goat=goat.left;
            }
            cur.key=goat.key;
            if(goat==goatParent.left){
                goatParent.left=goat.right;
            }else{
                goatParent.right=goat.right;
            }
        }
    }

    public static void main(String[] args) {
        //1.创建搜索树
        //2.随机插入一些数据
        //3.打印前序+中序遍历
        //4.查找
        BinarySearchTree tree=new BinarySearchTree();
        int[] keys={3,9,7,4,1,6,2,8,5};
        for(int key:keys){
            System.out.println(tree.insert(key));
        }
        System.out.println("插入重复数据");
        System.out.println(tree.insert(7));

        System.out.println("前序遍历：");
        preOrder(tree.root);
        System.out.println();
        System.out.println("中序遍历:");
        inOrder(tree.root);
        System.out.println();

        System.out.println(tree.search(7).key);
        System.out.println(tree.search(8).key);
        System.out.println(tree.search(5).key);
    }

    private static void preOrder(Node node){
        if(node!=null){
            System.out.print(node.key);
            preOrder(node.left);
            preOrder(node.right);
        }
    }

    private static void inOrder(Node node){
        if(node!=null){
            inOrder(node.left);
            System.out.print(node.key);
            inOrder(node.right);
        }
    }
}

运行结果：