二叉搜索树

1.概念

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

2.查找

  若根节点不为空：
  如果根节点key==查找key 返回true；
  如果根节点key>查找key 在其左数查找
  如果根节点key<查找key 在其右树查找
  否则，返回false

3.插入

1.如果树为空树，即根==null，直接插入
2.如果不是空树按照二叉搜索树的性质，找到插入节点的为位置。

4.删除

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

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

public class BinarySearchTree {
    static class Node{
        public int data;
        public Node left;
        public Node right;
        public Node(int data) {
            this.data = data;
        }
    }
    public Node root=null;
    //
    public Node search(int val){
        Node cur=root;
        while(cur!=null){
            if(cur.data>val){
                cur=cur.left;
            }else if(cur.data<val){
                cur=cur.right;
            }else{
                return cur;
            }
        }
        return null;
    }
    //插入
    public boolean insert(int key){
        Node node =new Node(key);
        if(root==null){
            root=node;
            return true;
        }
        Node parent=null;
        Node cur=root;
        while(cur!=null){
            if(cur.data==key){
                return false;
            }else if(cur.data>key){
                parent=cur;
                cur=cur.left;
            }else{
                parent=cur;
                cur=cur.right;
            }
        }
        if(key==parent.data){
            return false;
        }else if(key>parent.data){
            parent.right=node;
        }else{
            parent.left=node;
        }
        return false;
    }
    //删除
    public void remove(int key){
       Node parent=null;
       Node cur=root;
       while(cur!=null){
           if(cur.data==key){
              removeNode(parent,cur);
              return;
           }else if(cur.data<key){
               parent=cur;
               cur=cur.right;
           }else{
               parent=cur;
               cur=cur.left;
           }
       }
    }
    private void removeNode(Node parent,Node cur){
        if(cur.left==null){
            //3种情况
            if(cur==root){
                root=cur.right;
            }else if(cur==parent.left){
                parent.left=cur.right;
            }else{
                parent.right=cur.right;
            }
        }else if(cur.right==null){
            if(cur==root){
                root=cur.left;
            }else if(cur==parent.left){
                parent.left=cur.left;
            }else{
                parent.right=cur.left;
            }
        }else{
                Node targetParent=cur;
                Node target= cur.right;
                while(target.left!=null){
                    targetParent=target;
                    target=target.left;
                }
                //并没有删除只是一个简单值的替换
                cur.data=target.data;
                //分为两种
                //1.因为是在右边找，找的是右边最小的数字，
                //又因为右边最小的数，肯定是左树为空
                //2.所以删除的时候分为两种情况
                //target是targetParent左
                if(target==targetParent.left){
                    targetParent.left=target.right;
                }else{
                //target是targetParent右    targetParent.right=target.right;
                }

        }
    }
    //二叉树的前序遍历
    public static void preOrder(BinarySearchTree.Node root){
        if(root==null){
           return;
        }
        System.out.print(root.data+" ");
        preOrder(root.left);
        preOrder(root.right);
    }
    //二叉树的中序遍历
    public static void inOrder(BinarySearchTree.Node root){
        if(root==null){
            return;
        }
        inOrder(root.left);
        System.out.print(root.data+" ");
        inOrder(root.right);
    }
    public static void main(String[] args) {
        int[] array={5,3,4,1,7,8,2,6,0,9};
        BinarySearchTree binarySearchTree=new BinarySearchTree();
        for(int val:array){
            binarySearchTree.insert(val);
        }
        binarySearchTree.insert(10);
        preOrder(binarySearchTree.root);
        System.out.println();
        inOrder(binarySearchTree.root);
        System.out.println();
        System.out.print(binarySearchTree.search(7).data);
        System.out.println();
        binarySearchTree.remove(7);
        preOrder(binarySearchTree.root);
        System.out.println();
        inOrder(binarySearchTree.root);
    }
    运行结果：0 1 2 3 4 5 6 7 8 9 10 
             7
             5 3 1 0 2 4 8 6 9 10 
             0 1 2 3 4 5 6 8 9 10
}

删除示意图：