二分查找与搜索树

1.常见的二分查找

1.1循环方式的二分查找

/**
     * 二分查找法
     * @param array 目标元素的数组
     * @param low 指定的左区间
     * @param high 指定的有区间
     * @param target 目标元素
     * @return
     */
    public static int binarySearch(int[] array,int low,int high,int target){
        while (low <=  high){
            int middle = low +((high - low) >> 1);
            if (array[middle] == target){
                return middle;
            }
            else if (array[middle] > target){
              high = middle -1 ;
            }
            else {
              low = middle +1 ;
            }
        }
        return -1;
    }

1.2递归方式的二分查找

   public static int binarySearchRecursion(int[] array,int low,int high,int target){
        while (low <= high){
            int middle = low + ((high - low) >> 1);
            if (array[middle] == target){
                return middle;
            }
            else if (array[middle] > target){
               return binarySearch(array,low,middle-1,target);
            }
            else {
               return binarySearch(array,middle + 1 ,high ,target);
            }
        }
        return -1;
    }

1.3元素中有重复的二分查找

与普通的二分查找区别在于：找到元素之后的处理？

本题题意：返回的是目标元素的最左侧的索引

/**
     * 在有重复元素的数组中，二分查找目标target元素,返回的是目标target的最左侧元素的下标
     * @param array
     * @param target
     * @return
     */
    public static int binarySearchHasRepeat(int[] array,int target){
        if (array == null || array.length == 0){
            return -1;
        }
        int left = 0;
        int right = array.length - 1;
        while (left <= right){
            int middle = left + ((right - left) >> 1);
            if (array[middle] > target){
                right = middle - 1 ;
            }
            else if (array[middle] < target){
                left = middle +1 ;
            }
            else {
                //找到目标元素
                while (middle != 0 && array[middle] == target){
                    middle --;
                    //数组的首个元素即target
                    if (middle == 0 && array[middle] == target){
                        return middle;
                    }
                    //下标middle不等于目标元素跳出循环，此时要找的元素下标是middle+ 1
                    if (middle != 0 && array[middle] != target){
                        return middle + 1;
                    }
                }
            }
        }
        return -1;
    }

2.二分查找的扩展问题

2.1山脉数组的峰顶索引

题意：数组"array[]"从0到i是递增的，i到尾部的递减的，找出i的索引

思路：array[i] 峰顶元素 必须大于 array[i-1] 及之前的元素，且小于array[i+1]之后的元素

思路① 遍历数组元素，array[i] > array[i+1]  FALSE ,即峰顶元素索引为 i

思路② 二分查找 根据mid元素的值 调整 left，right

 public static int getTopIndex(int[] array){
       //数组长度小于3，不存在峰顶元素
        if (array.length < 3){
            return -1;
        }
        int right = array.length - 1;
        int left = 0;
        while (left < right){
            int middle = left + ((right - left) >> 1);
            //峰顶
            if (array[middle] > array[middle-1] && array[middle] > array[middle + 1]){
                return middle;
            }
            //递增阶段
            else if (array[middle] > array[middle-1] && array[middle] <array[middle + 1]{
                left = middle + 1;
            }
            //递减阶段
            else {
                right = middle -1 ;
            }
        }
      return left;
    }

2.2有序数组的缺失元素的索引

题意：一个长度n-1的数组是递增，且数组内元素唯一，每个范围都在0-n之中，找出数组内不在

0-n的范围的元素（缺失的元素)

思路：二分查找，在缺失元素前，array[i] == i ，在缺失元素之后，array[i] ！== i

 public static  int getMissingIndex(int[] array){
        if (array == null){
            return -1;
        }
        int left = 0;
        int right = array.length - 1;
        while (left <= right){
            int middle = left + ((right-left) >> 1);
            if (array[middle] == middle){
                left = middle + 1;
            }else {
             right = middle - 1;
            }
        }
        return left;
    }

3.搜索树

3.1二叉树中搜索特定值

题意：给定二叉树及目标target，若存在则返回以节点为根的子树，否则返回NULL

例题：----------------------------------------------------------------------------------------------------

若target值 不等于 根节点，则需要dfs ，若target值 小于 根节点值，往根节点左子树查找目标target节点，反之查找右子树......

     /**
     * 在搜索树中查找值为target的节点
     * @param root 二叉搜索树
     * @param target 目标节点的值
     * @return 找到返回该节点，找不到返回-1
     */
    public static TreeNode getTreeNodeByBinarySearch(TreeNode root,int target){
        if (root == null || root.val == target){
            return root;
        }
        //若target值小于根节点,往根节点左子树继续查找;反之亦然
        return target < root.val ? getTreeNodeByBinarySearch(root.leftNode,target) : getTreeNodeByBinarySearch(root.rightNode,target);
        }

3.2验证是否是二叉搜索树

首先明白什么是二叉搜索树？

对于二叉树的每一个节点，都存在以下条件：节点值大于左子树节点值，小于右子树节点的值

二叉搜索树：按中序遍历节点的值，是递增！

 /**
     * 给定二叉树，判断是否为二叉搜索树
     * @param root
     * @return
     */
//pre变量 ： 当前节点的前一个结点的值
    Long pre = Long.MIN_VALUE;
    public  boolean isBinarySearchTree(TreeNode root){
        //pre变量指当前根节点的前节点
        if (root == null){
            return true;
        }
        //判断根节点的左子树
        if (!isBinarySearchTree(root.leftNode)){
            return false;
        }
        //访问当前节点
        if (root.val <= pre){
            return false;
        }
        pre = Long.valueOf(root.val);
        //判断根节点的右子树
        return isBinarySearchTree(root.rightNode);
    }