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);
}