数据结构-二叉搜索树

概念：

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树：

1. 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值；
2. 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值；
3. 它的左右子树也分别为二叉搜索树。

int a [] = {5,3,4,1,7,8,2,6,0,9}; 

代码：

class BinarySearchTree {

    static class BSNode {
        public int val;
        public BSNode left;
        public BSNode right;
        public BSNode(int val) {
            this.val = val;
        }
    }
    public BSNode root = null;

    public BSNode search(int val) {
        if(root == null) return null;
        
        BSNode cur = root;
        while(cur!=null){
            if(cur.val==val){
                return cur;
            } else if(cur.val < val){
                cur = cur.right;
            }else{
                cur = cur.left;
            }
         }
         return null;
    }

    public boolean insert(int val) {
     BSNode bsNode = new BSNode(val);
     if(root == null){
         root = bsNode;
         return true;
     }
      BSNode cur = root;
      BSNode parent = null;
       while(cur!=null){
           if(cur.val == val){
               return false;
           }else if(cur.val < val){
            parent = cur;
            cur = cur.right;
           }else{
               parent = cur;
               cur = cur.left;
           }
       }
       if(parent.val < val){
           parent.right=bsNode;
       }else{
           parent.left=bsNode;
       }
       return true;
    }
   
}
    public void remove(int val) {
        if(root == null) return;
        BSNode cur = root;
        BSNode parent = null;
        while (cur != null) {
            if(cur.val == val) {
                removeNode(parent,cur,val);
                return;
            }else if(cur.val < val) {
                parent = cur;
                cur = cur.right;
            }else {
                parent = cur;
                cur = cur.left;
            }
        }
    }

    /**
     * 删除二叉搜索树的节点
     * @param parent
     * @param cur
     * @param val
     */
    public void removeNode(BSNode parent,BSNode cur,int val) {
        if(cur.left == null) {
            if(cur == root) {
                root = cur.right;
            }else if(parent.left == cur) {
                parent.left = cur.right;
            }else {
                parent.right = cur.right;
            }
        }else if(cur.right == null) {
            if(cur == root) {
                root = cur.left;
            }else if(parent.left == cur) {
                parent.left = cur.left;
            }else {
                parent.right = cur.left;
            }
        }else {
            //
            BSNode targetParent = cur;
            BSNode target = cur.right;
            while (target.left != null) {
                targetParent = target;
                target = target.left;
            }
            //target指向的节点就是 右边的最小值
            cur.val = target.val;
            if(target == targetParent.left) {
                targetParent.left = target.right;
            }else {
                targetParent.right = target.right;
            }
        }
    }
public class TestDemo {
     public void preOrder(BinarySearchTree.BSNode root){
        if(root==null){
            return;
        }
       System.out.print(root.val+" ");
        preOrder(root.left);
        preOrder(root.right);
    }
    public void inOrder(BinarySearchTree.BSNode root){
        if(root==null){
            return;
        }
        inOrder(root.left);
        System.out.print(root.val+" ");
        inOrder(root.right);
    }

    public static void main(String[] args) {
     BinarySearchTree binarySearchTree = new BinarySearchTree();
     binarySearchTree.insert(4);
     binarySearchTree.insert(5);
     binarySearchTree.insert(7);
     binarySearchTree.insert(13);

     preOrder(binarySearchTree.root);
     System.out.print();
     inOrder(binarySearchTree.root);
     System.out.print();
     try{
         BinarySearchTree.BSNode ret = binarySearchTree.search(14);
         System.out.println(ret.val);
     }catch (NullPointerException e) {
        System.out.println("没有找到当前的节点");
        e.printStackTrace();
     }
    }
}

注：其中删除操作为难点

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

1. cur.left == null
   1. cur 不是 root, cur 是 parent.left, 则parent.left = cur.right
   2. cur 不是 root, cur 是 parent.right, 则parent.right = 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
   1. 需要使用替换法进行删除，即在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被 删除节点中，再来处理该结点的删除问题