二叉搜索树

二分查找法

对于有序数列，才能使用二分查找法

    public int binarySearch(int[] array,int n,int target){
        int l=0,r=n-1;
        while (l<=r){
            //优化：如果l和r都是很大的整数时，会出现溢出问题
//            int mid=(l+r)/2;
            int mid=l+(r-l)/2;
            if(array[mid]==target){
                return array[mid];
            }else if(array[mid]<target){
                r=mid-1;
            }else {
                l=mid+1;
            }
        }
        return Integer.MIN_VALUE;
    }
    //使用递归进行二分查找
    public int binarySearch(int[] array,int l,int r,int target) {
        int mid = l + (r - 1) / 2;
        if (l >= r) {
            return Integer.MIN_VALUE;
        }

        if (array[mid] == target) {
            return array[mid];
        }else if (array[mid] < target) {
            return binarySearch(array, l, mid - 1);
        } else {
            return binarySearch(array, mid + 1, r);
        }


    }

二分搜索树

查找表的实现，字典数据结构

二分搜索树的插入与查找

public class Node {
     public int key;
     public int Value;
     public Node left;
     public Node right;

    public Node(int key, int value) {
        this.key = key;
        this.Value = value;
        this.left=this.right=null;
    }


}

class BST{
    private Node root; //根节点
    private int count; //元素个数

    public BST() {
        root=null;
        count=0;
    }

    public int size(){
        return count;
    }

    public boolean isEmpty(){
        return count==0;
    }

    public void insert(int key,int value){
        root=toinsert(root,key,value);
    }

    private Node toinsert(Node node, int key, int value) {

        if(node==null){
            count++;
            return new Node(key,value);
        }

        if(node.key==key){
            node.Value=value;
        }else if(node.key<key){
            node.left=toinsert(node.left,key,value);
        }else {
            node.right=toinsert(node.right,key,value);
        }
        return node;

    }

    //查找是否包含某一个key
    public boolean contain(int key){
        return isContain(root,key);
    }

    //查找并返回某一个数
    public int search(int key){
        return tosearch(root,key);
    }

    private int tosearch(Node node, int key) {

        if(node==null){
            return Integer.MIN_VALUE;
        }

        if(node.key==key){
            return node.Value;
        }else if(node.key>key){
            return tosearch(node.left,key);
        }else {
            return tosearch(node.right,key);
        }
    }

    private boolean isContain(Node node,int key) {
        if(node==null){
            return false;
        }

        if(node.key==key){
            return true;
        }else if (node.key>key){
            return isContain(node.left,key);
        }else {
            return isContain(node.right,key);
        }
    }

非递归插入

//插入节点
    public void insert(int data){
        TreeNode newNode = new TreeNode(data);
        if (this.root==null){
            this.root=newNode;
        }else {
            TreeNode current=root;
            TreeNode parent;
            while (true){
                parent=current;
                if (data<current.data){
                    current=current.left;
                    if (current==null){
                        parent.left=newNode;
                        return;
                    }
                }else {
                    current=current.right;
                    if (current==null){
                        parent.right=newNode;
                        return;
                    }
                }
            }
        }
    }

二分搜索树的遍历

前序遍历：先访问当前节点，再依次递归访问左右子树；
中序遍历：先访问左子树，在访问当前节点，最后访问右子数；
后序遍历：先访问左子树，在访问右子树，最后访问当前节点；

    public void preOrder(){
        preOrder(root);
    }
    public void midOrder(){
        midOrder(root);
    }
    public void afterOrder(){
        afterOrder(root);
    }

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

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


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

层序遍历

public void levelOrder(){
        //队列
        Queue<Node> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()){
            //将父节点弹出队列
            Node front=queue.poll();
            System.out.print(front.key+" ");
             
            //放入左右节点
            if(front.left!=null){
                queue.offer(front.left);
            }
            if(front.right!=null){
                queue.offer(front.right);
            }

        }

删除结点

特性：最小结点只有右孩子；最大结点只有左孩子；

查找最大最小结点

public int findMin(){
        assert count==0;
        Node node=root;
        while (node.left!=null){
            node=node.left;
        }
        return node.key;
    }

    public int findMax(){
        assert count==0;
        Node node=root;
        while (node.right!=null){
            node=node.right;
        }
        return node.key;
    }

删除最大最小结点

public void deleteMin(){
        if(root!=null){
            root=deleteMin(root);
        }
    }

    private Node deleteMin(Node node) {
        if(node.left==null){ //如果左孩子为空、
            //如果右孩子不为空则将右孩子赋给要删除节点的父节点来替换被删除节点  将右孩子节点返回
            //如果为空，则说明左右孩子都为空  当前节点就是最小节点直接返回null给父节点 表示被删除
            Node leftnode=node.right;
            count--;
            return leftnode;
        }
            //如果左孩子不为空 则将处理左孩子作为根节点的树
        //如果递归最后返回的是null  则说明node没有左右孩子  直接将null赋值给node的左子树
        //这里的node和上面的node不是一级的 这里的node是上面node的父节点
            node.left=deleteMin(node.left);
        return node;

    }
    public void deleteMax(){
        if(root!=null){
            root=deleteMax(root);
        }

    }

    private Node deleteMax(Node node) {

        if(node.right==null){
            Node rightNode=node.left;
            count--;
            return rightNode;
        }
        node.right=deleteMax(node.right);
        return node;
    }

删除有左右孩子的结点

比如想要删除58代表的结点，但是删除之后以什么来代替58呢？

要满足二叉搜索树的特征，得找到一个数，比58左边的孩子大，比58右边的孩子小。

可以找在右子树中最小的那个结点，满足比当前节点右子数小，比当前节点左子树大。同样的也可以选择左子树中最大的那个结点来代替当前结点。

    //在二叉搜索树中删除任意结点
    public void remove(int key){
        //删除以root作为根节点的树中的node
        root=remove(root,key);
    }

//    删除以node做为根结点的树的指定结点
//    返回删除节点后新的二分搜索树的根
    private Node remove(Node node, int key) {
        if (node==null){
            return null;
        }

        //如果key的值小于当前节点的key 则在以当前结点左子树为根的树中寻找删除
        if(node.key>key){
            node.left=remove(node.left,key);
            return node;
        }else if(node.key<key){
            node.right=remove(node.right,key);
            return node;
        //重头戏：如果当前结点等于key  则说明当前结点就是要删除的结点
        }else {
            //如果要删除的结点 左子树为空 则说明它是最小值可以直接使用前面定义的删除最小值的方法
            if(node.left==null){
                return deleteMin(node);
                //如果要删除的结点 右子树为空 则说明它是最大值可以直接使用前面定义的删除最大值的方法
            }else if(node.right==null){
                return deleteMax(node);

                //如果左子树和右子数都不为空 需要寻找用来代替当前要删除节点的子节点
                // 选择右子数中最小的结点 或者左子树中最大的结点来代替都能满足二叉搜索树的特性  这里用的是前者
            }else {
                //先找到以node为根的右子数中的最小值  并需要删除它
                //这里需要在复制一份 因为删除后就不能在引用了
                Node replaceNode=findMin(node.right);
                Node newNode=new Node(replaceNode);
                count++;

                //将新复制的node放入合适的位置
                //新结点的左孩子就是node的左孩子
                newNode.left=node.left;
                //新结点得右孩子就是删除替换节点后返回的根节点
                newNode.right=deleteMin(node.right);

                //将新替换的结点作为根节点返回
                return newNode;
            }
        }
    }

这里复用了前面的findMIn和findMax方法，但是需要传入一个根节点，返回这个根节点的树的最大最小结点，所以这里修改了这两个方法的逻辑；

   public Node findMin(){
        assert count==0;
        return findMin(root);
    }

    //寻找以node结点为根的最小节点
    private Node findMin(Node node) {
        if(node.left!=null){
            node=findMin(node.left);
        }
        return node;
    }

    public Node findMax(){
        assert count==0;
        return findMax(root);
    }

    private Node findMax(Node node) {
        //如果当前结点右子树不为空  则最大值一定在右子树里
        if(node.right!=null){
            node=findMax(node.right);
        }
        return node;
    }

复制一个node的构造方法

 public Node(Node node){
        this.key=node.key;
        this.Value=node.Value;
        this.left=node.left;
        this.right=node.right;
    }

二分搜索树的顺序性

前驱和后继的概念
是指在中序遍历后，线程表中元素的前面一个元素和后面一个元素；

比如在这个树中，中序遍历结果为
13，15，22，33，37，41，42，50，53，58，63

对于41这个元素 它的前驱是37 后继是42

floor和ceil的概念

在上面的树中，对于不存在的结点如45 它的floor和ceil就是最接近它的前后两个元素
如 45的floor就是42 ceil就是50

如果树中存在该元素如 42 它的floor和ceil就是它自身；
也有一种元素 它不存在floor和ceil
如64 它比树中所有元素都大所以不存在它的ceil
如11 不存在它的floor