二分搜索

最新推荐文章于 2021-07-21 01:41:18 发布
最新推荐文章于 2021-07-21 01:41:18 发布
阅读量429 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010141928/article/details/74586966
版权

二分搜索的应用和考察点：

二分搜索常见的应用场景：

1. 在有序序列中查找一个数

如果范围缩小到0也没有查找到这个数，则返回false。

整个过程的时间复杂度为o(log N).

并不一定非要在有序序列中才能用二分搜索，凡是可以在二分搜索过程中，可以留下一半，扔掉一半都可以用二分搜索。


二分搜索的思想并不难，难的是能否快速写出正确的代码。

1. 对于边界条件的考察以及代码实现的能力。

对中间划分点的逻辑判断，以及设置循环的终止条件，防止陷入死循环，

2. 二分搜索常见题目的变化

给定处理或查找的对象不同。（有重复值的数组和无重复值的数组）

判断条件不同。

要求返回的内容不同。

3. 在有序循环数组中进行二分搜索。

比如：

1,2,3,4,5循环之后可以是

2,3,4,5,1

3,4,5,1,2

4,5,1,2,3

5,1,2,3,4

4. 二分搜索的重要提醒！！

经典写法是：

mid=(left+right)/2

但是有些情况下爱left+right有可能会溢出；

所以更安全的写法是：
mid=left+(right-left)/2

案例1：

给定一个无序数组arr，已知任意相邻的两个元素，值都不重复，请返回任意一个局部最小的位置。

所谓局部最小的位置是指，如果arr[0]<arr[1],那么位置0就是一个局部最小的位置，如果arr[N-1](也就是arr最右的数)小于arr[N-2]，那么位置N-1也是局部最小的位置。

如果位置i既不是最左位置也不是最右位置，那么只要满足arr[i]同时小于它左右两侧的值即（arr[i-1]和arr[i+1]），那么位置i也是一个局部最小的位置。

本题依然可以用二分搜索来实现。时间复杂度为o(logn).

这里可以利用任意相邻的两个元素值都不重复这个特点，用二分搜索的方式来实现。

1. arr为空或长度为0，返回-1，表示局部最位置不存在。

2. 如果arr长度为1，返回0；因为此时0是局部最小位置。

3. 如果arr长度大于1，可以按照下面的顺序进行：

如果arr0<arr1,那么可以直接返回位置0；

如果arrn-1<arrn-2，那么可以直接返回位置n-1；

如果上面都不满足，也就是两头的位置都不是局部最小位置，说明arr0>arr1,并且arrn-1>arrn-2.

因为数组中任意相邻的两个数，都是不相等的，所以，从最左的位置向右看，趋势是向下的；从最右的位置向左看，趋势也是向下的；

这时候可以查看中间位置middle处的值：

如果middle的值小于其左边数同时小于其右边数，说明middle本身就是一个局部最小位置，直接返回middle即可；

如果middle比右边的数小，比左边的数大，说明从middle向左看趋势也是向下的，所以知道middle左边一定存在局部最小的位置，所以可以对middle的左边继续做二分搜索；

如果middle比右边的数大，比左边的数小，说明从middle向右看趋势也是向下的，所以知道middle右边一定存在局部最小的位置，所以可以对middle的右边继续做二分搜索；

如果middle上的数既大于它的左边又大于它的右边，说明middle左右都可以进行二分搜索。

从上面的例子可知，二分搜索并不一定只能在有序的数组上面才能进行，只要在查找的时候发现可以查找一半，淘汰另外一半，这样的是都可以进行二分搜索的。

class Solution {
public:
    int getLessIndex(vector<int> arr) {
         int n=arr.size();
        if(n==0)
            return -1;
         if(n==1)
             return 0;
         if(arr[0]<arr[1])
             return 0;
         if(arr[n-1]<arr[n-2])
             return n-1;
         return partition(arr,1,n-2);
    }
    int partition(vector<int>& arr,int left,int right){
        
        if(left==right)
            return left;
        else{
            int middle=left+(right-left)/2;
            if(arr[middle]>=arr[middle-1])
                return partition(arr,left,middle-1);//这里之所以为left到middle-1是因为middle位置的一定不是局部最小值了，所以不需要包括middle。
            else if(arr[middle]>=arr[middle+1])
                return partition(arr,middle+1,right);
            else
                return middle;
        }
    }
};

案例二：给定给一个有序数组arr，再给定一个整数num，请在arr中找到num这个数出现的最左边的位置。

变量res初始化为-1，如果最后仍然为-1，说明没有找到num这个数；

否则res就是最左边的num的位置；

因为数组有有可能存在相同的数，所以在查找的时候如果查找到了num，那么res就要更新称为查找到的num的位置；

不停的做二分搜索，一直到查找到最左边的num的位置；

class LeftMostAppearance {
public:
    int findPos(vector<int> arr, int n, int num) {
        // write code here
        //这道题的解法有两种，分别为递归的方式和循环的方式！
        int res=-1;
        int right=n-1;
        int left=0;
        int middle;
        while(left<=right){
            middle=left+(right-left)/2;
            if(arr[middle]>num)
                right=middle-1;
            else if(arr[middle]<num)
                left=middle+1;
            else{
                res=middle;
                right=middle-1;
            }
        }
        return res;
    }
       
};

这道题的解决方式可以采用循环，也可以采用递归的方式。但是需要注意的是，在进行递归的时候，一定更要注意边界条件，也就是每次调用递归函数的时候，left，right等参数的设置，非常重要！！

class LeftMostAppearance {
public:
    int findPos(vector<int> arr, int n, int num) {
        // write code here
        //这道题的解法有两种，分别为递归的方式和循环的方式！
        int right=n-1;
        int left=0;
        return getpos(arr,0,n-1,num);
        
    }
    int getpos(vector<int>& arr, int left,int right, int num)
    {
        if(left==right){
            if(arr[left]==num)
                return left;
            else
                return -1;
        }else{
            int middle=left+(right-left)/2;
            if(arr[middle]>=num){
                return getpos(arr,left,middle,num);//一定更要注意这里！！！因为这里面包含了arr[middle]==num的情况，所以左边一定要包含middle进去！！！！
            }else{
                return getpos(arr,middle+1,right,num);
            }
        }        
    }
       
};

上面就是采用递归方式实现的额！

案例三：给定给一个有序循环数组arr，返回arr中的最小值，有序循环数组是指，有序数组左边任意长度的部分放到右边去，右边的部分拿到左边来，比如数组[1,2,3,3,4]，是有序循环数组，[4,1,2,3,3]也是。

循环有序数组有这么一个性质：以数组中间元素将循环有序数组划分为两部分，则一部分为一个严格有序数组，而另一部分为一个更小的循环有序数组。以循环递增数组为例，当中间元素大于首元素时，前半部分为严格递增数组，后半部分为循环递增数组；当中间元素小于首元素时，前半部分为循环递增数组；后半部分为严格递增数组。

长度不超过2的循环有序数组其实就是有序数组。

具体的解法为：
假设在数组L到R的范围上查找整个数组的最小值；

开始时，如果arr[L]<arr[R]，那么这一段数组整体是有序的，说明最小值就是最左边的arr[L];

如果arr[L]>=arr[R]说明L和R之间包含了循环的部分，这时候查看L到R范围上处于中间位置M的数：

如果arr[L]>arr[M],说明最小值位于L和M之间的位置，此时就在左部分进行二分查找；

如果arr[M]>arr[R],说明最小值位置M和R之间的位置，此时就在右部分进行二分查找；

如果arr[L]>arr[M]不满足，同时arr[M]>arr[R]也不满足，那么就有

arr[L]<=arr[M],并且arr[M]<=arr[R]，同时我们还知道arr[L]>=arr[R]，所以根据这三个式子我们可以知道

arr[L]=arr[M]=arr[R]，面对这种情况是无法用二分的方式来进行查找的。比如下面的例子：

2 2 ... ... 2 1 2 ... ... 2 2

对于上面的例子来说，无论1出现在哪个位置都是满足有序循环数组这个要求的，所以无法用二分查找的方式找到最小值的位置，只能用遍历的方式来寻找。

class MinValue {
public:
    int getMin(vector<int> arr, int n) {
        // write code here
        return getmin(arr,0,n-1);
        
    }
    int getmin(vector<int>& arr,int left,int right){
        
        if(arr[left]<arr[right])
            return arr[left];
        else{
            int middle=left+(right-left)/2;
            if(arr[left]>arr[middle])
                return getmin(arr,left+1,middle);
            else if(arr[right]<arr[middle])
                return getmin(arr,middle+1,right);
            else{
                  int i=left;
                  int min=arr[left];
                  while(i!=right){
                     i++;
                    if(arr[i]<min)
                      min=arr[i];
                   }
                  return min;
            }
        }
    }


};

具体的代码如上面所示！


案例四：

给定一个有序数组arr，其中不含有重复元素，请找到满足arr[i]==i条件的最左的位置。如果所有位置上的数都不满足条件，返回-1.

,首先生成全局变量res=-1，记录最后一次arr[i]=i的位置；

然后判断arr[0]>n-1，如果是的话，就知道，因为整个数组中元素的值是有序的，所以0到n-1上所有的值都是大于n-1的，而arr中位置的取值只能是0到n-1,所以肯定不存在arr[i]=i这种情况，所以返回-1；

然后考察arr[n-1]<0，如果是的话，也返回-1；

然后如果arr[middle]>middle.因为数组既没有重复值，又是递增的，而递增的量最小为1，而位置的增量则严格是1，那么就考察arr[0]到arr[middle-1]这一范围就可以了、因为从middle到n这个范围内不会出现arr[i]=i的情况。

然后如果arr[middle]<middle，同理0到middle被排除，只能对middle+1到n这个范围继续二分。

如果arr[middle]==middle，则更新res=middle，然后因为我们要找的是最左位置，所以继续对0到middle-1上继续二分搜索。

class Find {
public:
    int findPos(vector<int> arr, int n) {
        // write code here
        if(n==0||arr==NULL)
            return -1;//这里一定要注意边界条件
        if(arr[0]>n-1)
            return -1;
        if(arr[n-1]<0)
            return -1;
        return findposition(arr,0,n-1);
    }
    int findposition(vector<int>& arr,int left,int right){
        int middle=left+(right-left)/2;
        int res=INT_MAX;
        if(left<=right){//递归终止条件，是非常重要的！！！
        if(arr[middle]>middle)
                return findposition(arr,left,middle-1);
            else if(arr[middle]<middle)
                return findposition(arr,middle+1,right);
            else{
                res=middle;
                if(res<findposition(arr,left,middle-1))
                    return res;
                else 
                    return findposition(arr,left,middle-1);
            }
        }else{
            return res;
        }
    }
};

上面的代码是利用递归编写的，同时用循环也可以实现：

import java.util.*;

public class Find {
	public int findPos(int[] arr, int n) {
		if (arr == null || n == 0) {
			return -1;
		}
		int left = 0;
		int right = n - 1;
		int res = -1;
		while (left <= right) {
			if (arr[left] > left || arr[right] < right) {
				break;
			}
			int mid = (left + right) / 2;
			if (arr[mid] < mid) {
				left = mid + 1;
			} else if (arr[mid] > mid) {
				right = mid - 1;
			} else {
				res = mid;
				right = mid - 1;
			}
		}
		return res;
	}
}

递归方式还有一种写法如下：

class  Find {
public :
     int  findPos(vector< int > arr,  int  n) {
         // write code here
         if (n ==  0  || arr[ 0 ]>n- 1  || arr[n- 1 ]< 0 )  return  - 1 ;
         int  pos = findPos(arr, 0 ,n- 1 );
         if (pos != - 1 )  return  arr[pos];
         else  return  pos;
     }
     int  findPos(vector< int > arr,  int  left,  int  right){
        int  mid = left + (right - left) /  2 ;
         if (right - left ==  0 ){
             if (arr[left] == left)  return  left;
             else  return  - 1 ;
         }
         else  if (arr[mid] >= mid)  return  findPos(arr,left,mid);
         else  if (arr[mid] < mid)  return  findPos(arr,mid+ 1 ,right);
         else  return  - 1 ;
     }
};

案例五：给定一棵完全二叉树的头节点head，返回这棵树的节点个数。如果完全二叉树的节点数为N，请实现时间复杂度低于o（n）的解法。

可以借助于二分搜索的思想：

完全二叉树添加节点总是从最后一层添加，并且是从左到右依次添加；而删除过程是从最后一层开始从右到左依次删除。

首先找到二叉树最左的节点，目的是想统计完全二叉树的高度，根据完全二叉树的性质，最左的节点一定位于完全二叉树的最后一层上，假如计算出的二叉树的高度为H；

然后找到二叉树头节点的右子树的最左节点，如果这个左节点位于整个二叉树的最后一层，说明头节点的左子树一定是一个满的二叉树，因此可以根据满二叉树计算公式计算出左子树的节点个数，然后加上头节点，再利用递归的方式计算出头节点的右子树的节点个数；但是如果头节点的右子树的最左节点并不是位于整个二叉树最后一层，说明头节点的右子树也是一个满二叉树，但是他的高度比左子树少一层，因此可以利用满二叉树的公式计算出头节点右子树的节点个数再加上头节点，再对头节点左子树进行递归就可以了。

上面的方式比遍历方式快很多。遍历方式，时间复杂度为o(n).；而上面最优解的过程，时间复杂度为o(logH2),H代表整棵树二叉树的高度。

上面的算法的总体思想就是查看右子树的最左节点位于什么位置！！！


根据http://www.cnblogs.com/jmliao/p/6706333.html可知如下特性：

1. 二叉树的基本性质

  • 二叉树的第i层至多有2i-1个结点（i>=1）

证明：（归纳法）

　　　归纳基：i=1时，只有一个结点，2i-1=20=1；

　　　归纳假设：假设对所有的i命题成立；

　　　归纳证明：二叉树中每个结点最多有两个子树，则第i层的结点数为2*2i-2=2i-1.

  • 深度为h的二叉树至多有2h-1个结点，一共1，...  ,h层（h>=1）

　　　　证明：n=20+21+...+2h-1=2h-1.（等比数列）

  • 对于一棵二叉树，若含有n0个叶子结点，n2个度为2的结点，则必存在关系式：n2=n0-1

　　　　证明：设二叉树的结点总数为n=n0+n1+n2;

　　　　　　　二叉树上的分支总数为b=n1+2n2;

　　　　        又b=n-1;

　　　　        故：n2=n0-1.

  • 具有n个结点的完全二叉树的深度为[log2n]+1.[]表示向下取整

　　　　证明：设完全二叉树的深度为k，则：2k-1<=n<2k

　　　　　　　即k-1<=log2n<k

　　　　　　　因为k只能取整数，所以k=[log2n]+1.这里的取整是向下取整！！！！这里的深度最小为1，此时只有一个根节点。

  • 若对含n个结点的完全二叉树从上到下且从左至右进行1至n的编号，则对完全二叉树中任意一个编号为i的结点：

　　　　若i=1，则该结点是二叉树的根，无双亲，否则，编号为[i/2]的结点为其双亲结点；

　　　　若2i>n，则该结点无左孩子结点，否则，编号为2i的结点为其左孩子结点；

　　　　若2i+1>n，则该结点无右孩子结点，否则，编号为2i+1的结点为其右孩子结点。

　　　　证明：设完全二叉树中第i个结点的位置为第k层第j个结点，即i=2k-1-1+j;

　　　　　　　则左孩子结点的索引为：l=2k-1+2(j-1)+1=2*(2k-1-1+j)=2*i;

　　　　　　　左孩子结点的索引为：r=2k-1+2(j-1)+2=2*(2k-1-1+j)+1=2*i+1;

 2. 二叉树中各种结点数目的计算

　　若一个完全二叉树的结点数目为n，求n0，n1，n2，数的高度h，左孩子结点数目nl和右孩子结点数目nr？

　　（n0为度为0的结点，n1为度为1的结点，n2为度为2的结点）

　　求解思路：

　　树的高度h=[log2n]+1;

　　因为是完全二叉树，所以1~h-1层全满；

　　前h-1层的结点数目为nh-1=2h-1-1;

　　第h层的叶子结点数目为nc1=n-nh-1（二叉树节点数目n减去前h-1层的节点数量）;

　　第h-1层的叶子结点数目为nc2=2h-2-ceil(nc1/2);（ceil为向上取整）

　　所以n0=nc1+nc2;

　　n2=n0-1;

　　n1=n-n0-n2;

　　左孩子结点数目nl=n2+n1;

　　右孩子结点数目nr=n2;


3. 对于二叉树而言，有一个公式：度为2的结点个数等于度为0的结点个数减去1。 即：n(2)=n(0)-1。

在c++中，#include <math.h>   log是e为底的对数   log10是10为底的对数   log2是2为底的对数  其他的用换底公式自己转换。

floor(x)返回的是小于或等于x的最大整数。ceil(x)返回的是大于x的最小整数。


1 << (h - l))这句代码的意思是将1向左移动h-1位，实际上就是pow(2,h-1)。
1.按位右移运算符(>>)
将数据除以2^n(2的n次方)：低位补0
2.按位左移运算符(<<)
将数据乘以2^n(2的n次方)：正数右移最高位补0，负数右移最高位补1！
C++中的int型一般都占四个字节，范围在-2147483648~2147483647之间。其中，非负整数的二进制表示范围是0x00000000~0x7FFFFFFF；负数的二进制是以补码的形式表示的，可以用对应的正数补码加1来表示，由此可得其范围为0xFFFFFFFF(表示-1)~0x80000001(表示-2147483647)，还有一个最小数-2147483648自然就表示为0x80000000。其中-2147483648是一个常量表达式，他不是一个常量，它是（-2147483637-1）。

 

 

正整数的补码是其二进制表示，与原码相同。

 

求负整数的补码，将其对应正数二进制表示所有位取反（包括符号位，0变1，1变0）后加1。

 


 
 

  
  数0的补码表示是
  
  唯一的。
 
 

 
 

  
  [+0]补=[+0]反=[+0]原=00000000
 
 

 
 

  
  [ -0]补=11111111+1=00000000
 
 

 
 

  
  已知一个数的补码，求原码的操作其实就是对该补码再求补码：
 
 

 
 

  
  ⑴如果补码的符号位为“0”，表示是一个正数，其原码就是补码。
 
 

 
 

  
  ⑵如果补码的符号位为“1”，表示是一个负数，那么求给定的这个补码的补码就是要求的原码。
 
 

 
 

  
  【例4】已知一个补码为11111001，则原码是10000111（-7）。
 
 

 
 

  
  因为符号位为“1”，表示是一个负数，所以该位不变，仍为“1”。
 
 

 
 

  
  其余七位1111001取反后为0000110；
 
 

 
 

  
  再加1，所以是10000111。
 
 

 
 

  
  
补码的绝对值

 
 

 
 

  
  【例5】-65的补码是10111111
 
 

 
 

  
  若直接将10111111转换成十进制，发现结果并不是-65，而是191。
 
 

 
 

  
  事实上，在计算机内，如果是一个
  
  二进制数，其最左边的位是1，则我们可以判定它为负数，并且是用补码表示。
 
 

 
 

  
  若要得到一个负二进制补码的数值，只要对补码全部取反并加1，就可得到其数值。
 
 

 
 

  
  如：二进制值：10111111（-65的补码）
 
 

 
 

  
  各位取反：01000000
 
 

 
 

  
  加1：01000001（+65）
 
 
 



 

 

这道题的代码实现如下所示：
 

/*
 struct TreeNode {
     int val;
     struct TreeNode *left;
     struct TreeNode *right;
     TreeNode(int x) :
             val(x), left(NULL), right(NULL) {
     }
 };*/
 
 
 class CountNodes {
 public:
     int count(TreeNode* root) {
         // write code here
       int result=getcount(root);
       return result;
         
    }
     int getcount(TreeNode* root){
         //这里面节点总数量是未知的，树的深度可以通过寻找最左节点来获得，因为这个二叉树时完全二叉树
         int result=1;
         if(root->right==NULL&&root->left==NULL)
             return result;
         int deepth=getdeepth(root);
         TreeNode* right=root->right;
         int rightdeepth=getdeepth(right);
         
        
         if(rightdeepth+1==deepth)//说明右子树的最左节点位于整颗树的最后一层，也就是说以root为根节点的左子树是满二叉树
         {
             //左子树节点数量加上一个根节点也就是加上1再加右子树节点数量
            result=(1<<rightdeepth)+getcount(root->right);
         }else{
             //说明右子树的最左节点并没有位于整棵树的最后一层，所以右子树是一个满二叉树，但是深度是deepth-2
             result=(1<<rightdeepth)+getcount(root->left);
         }
         return result;
     }
     int getdeepth(TreeNode* root)//计算以root为根节点的子树的深度，包括root节点在内。
         {
             TreeNode* left=root;
             int count=0;
             while(left!=NULL){
             left=left->left;
             count++;//count就是树的深度
         }
            return count;
         }
 };
 
 


 
 

案例六：如何更快的求一个整数k的N次方。如果两个整数相乘并得到结果的时间复杂度为O(1),得到整数k的N次方的过程请实现时间复杂度为O（logn）的方法。
 

典型做法是乘n-1次，时间复杂度为o(n);
 

这里，首先将N写成二进制的形式，这个二进制有多少位，就是用多少次的乘法，然后将二进制为1的部分的结果乘起来。这种做法的时间复杂度为o(logn).
 

这个方法的重点在于利用上次计算的结果，也就是说知道N的二进制形式之后，二进制后的N有多少位，就要对当前计算出的结果进行多少次的平方。假如说：
 

计算出的二进制N有10位，那么就要依次计算出k  k平方  （k平方）平方     （k（平方）平方）平方.....知道计算了10次为止，然后将对应二进制位置为1的计算出的值
 

拿出来进行相乘就可以啦！！重点就是中间计算平方的过程，因为利用了上一个计算结果，所以减少了计算次数！！
 


 
 

class QuickPower {
 public:
     int getPower(int k, int N) {
         // write code here
         //首先求N的二进制形式！
        
         int remainder;
         long result=1;//注意这里一定是长整型long
         long  temp;
         bool flag=false;
         while(N!=0){
            remainder=N%2;
            N=N/2;
             if(flag==false){
                 temp=k;
                 flag=true;
             }
             else{
                 temp=temp*temp%1000000007;//注意这里一定更要mod
             }
            if(remainder==1)
                result=result*temp%1000000007; //注意这里一定更要mod
         }
         return (int)result;
     }
 };
 
 

需要注意的是上面求N的余数和商的过程，实际上可以通过&和>>操作符来实现，具体实现如下面所示：
 

 

 
 class  
 QuickPower { 

 

 
 public 
 : 

 

 
      
 int  
 getPower( 
 int  
 k,  
 int  
 N) { 

 

 
          
 long  
 result =  
 1 
 ; 

 

 
          
 long  
 temp = k; 

 

 
          
 int  
 m =  
 1000000007 
 ; 

 

 
          
 for  
 (; N >  
 0 
 ; N >>=  
 1 
 ) {//这里通过>>操作将N除以2 

 

 
              
 if  
 ((N& 
 1 
 ) !=  
 0 
 ) {//确定余数是否为1，这里将N想象成他的二进制形式 

 

 
                  
 result *= temp; 

 

 
              
 } 

 

 
              
 temp = (temp * temp) % m; 

 

 
              
 result %= m; 

 

 
          
 } 

 

 
          
 return  
 ( 
 int 
 )result; 

 

 
      
 } 

 

 
 }; 

 

 

 

注意上面的程序中之所以要mod  1000000007这个数是10位的整数，而int型数据最大是10位的整数，实际上通常有符号的long和int范围是一样的，无符号long和int范围也是一样的，但是也有例外，具体要看编译器
 

。C语言只规定short <= int <=long int。具体还得看具体的编译器，long int型并不能肯定就是64位的，很多时候long int和int表示的范围是一致的。
 

因此上面的程序中为了防止最后的计算结果为long long类型，超过int，从而导致溢出，设置了mod  1000000007。一个保证两倍不爆int的足够大的好记的质数。1000000007*2=2000000014
 

这个数是小于int的最大值的。
 

最小的十位质数是：1000000007
 最大的十位质数是：9999999967 
 
 

 

 unsigned   int   0～4294967295   
 int   -2147483648～2147483647 
 unsigned long 0～4294967295
 long   -2147483648～2147483647
 long long的最大值：9223372036854775807
 long long的最小值：-9223372036854775808
 unsigned long long的最大值：1844674407370955161
 

 __int64的最大值：9223372036854775807
 __int64的最小值：-9223372036854775808
 unsigned __int64的最大值：18446744073709551615
 

 


 
 


 

                

        

        

    

  


    

      

        

            

              
                
                  yuerZ6
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
算法题总结之二分搜索

				
			

			

				

					Ezail的博客
				

				

					02-21
					
					388
					
				

			

		

		

			
				
二分搜索小记
二分查找法作为一种常见的查找方法，将原本是线性时间提升到了对数时间范围，大大缩短了搜索时间，具有很大的应用场景，博主这里对二分搜索进行了归类：
第一类： 需查找和目标值完全相等的数
这是最简单的一类，也是我们最开始学二分查找法需要解决的问题，比如我们有数组[2, 4, 5, 6, 9]，target = 6，那么我们可以写出二分查找法的代码如下：
int find(vector&amp;amp;lt...

			
		

	



                

            
              



	

		

			

				
					
二分搜索树（Binary Search Tree）

				
			

			

				

					qq_48019875的博客
				

				

					11-22
					
					2893
					
				

			

		

		

			
				
目录树结构一、为什么要有树结构二、二分搜索树的基础
树结构
一、为什么要有树结构
树结构本身是一种天然的组织结构
高效
二、二分搜索树的基础



			
		

	



              


  
              

                


	

		

			

				
					
二分搜索算法

				
			

			

				

					peabits' Web Log
				

				

					01-30
					
					333
					
				

			

		

		

			
				
二分搜索算法
在计算机科学中，二分搜索（binary search），也称折半搜索（half-interval search）、对数搜索（logarithmic search），是一种在有序数组中查找某一特定元素的搜索算法。
搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从...

			
		

	





	

		

			

				
					
F 学长的白日梦

				
			

			

				

					pioneer1
				

				

					10-27
					
					156
					
				

			

		

		

			
				
直接上快速幂就好了。只不过中间竟然有值爆long long了，余数p的范围是9999999967，那么在快速幂中就有可能有两个小于p的值相乘，达到接近10^20这么大。而long long的最小值为-9223372036854775808，最大值为9223372036854775808，接近10^19,显然不够。unsigned long long是无符号的，最大值为18446744073709551615，接近2*10^19,显然也不够(额，一想想，无符号果然是有符号的整型的两倍啊，怪不得unsign..

			
		

	



		

			
		



	

		

			

				
					
每日一练-----局部最小值位置

				
			

			

				

					扇扇来驰的博客
				

				

					05-03
					
					3055
					
				

			

		

		

			
				
题目：
定义局部最小的概念。arr长度为1时，arr[0]是局部最小。arr的长度为N(N>1)时，如果arr[0]
思想：
采用类似于二分查找算法，时间复杂度可以达到O(lgn)
(1)首先判断第一个元素和第二个元素的大小，如果第一个元素小于第二个元素的话，那么直接输出第一个元素的位置即可；
(2)如果(1)不成立的话，比较最后一个元素和次最后一个元素的大小，如果最后一个元素小于次最后

			
		

	





	

		

			

				
					
学长的白日梦(C++) --- 快速幂 + 快乘(模板) 解题

				
			

			

				

					努力学习的DS
				

				

					10-24
					
					396
					
				

			

		

		

			
				
链接：https://ac.nowcoder.com/acm/contest/7872/F
来源：牛客网


时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 131072K，其他语言262144K
64bit IO Format: %lld

题目描述

20级的学弟学妹们来了，实验室里可怜弱小又无助的wzc学弟终于变成了学长，可以压迫下一级了（？）。

但是wzc学长苦于自己的实力进步太慢，很担心自己在学弟学妹们面前丢人，所以天天熬夜在实验室里训练。

某一天wzc学长训练得实在太累了，.

			
		

	





	

		

			

				
					
二分搜索的MATLAB代码

				
			

			

				

					09-03
				

			

		

		

			
				
%BINARYSEARCH 二分搜索法查找，其中L是有序数列。代码包含递归法和迭代法两种实现方法

			
		

	





	

		

			

				
					
二分查找算法c语言伪代码,算法-二分搜索算法

				
			

			

				

					weixin_39747511的博客
				

				

					05-24
					
					3310
					
				

			

		

		

			
				
算法：二分搜索算法(折半查找算法)时间复杂度：二分搜索算法概述二分搜索算法伪代码二分搜索算法实现二分搜索算法概述二分搜索算法，也称折半查找算法，即在一个有序数组中查找某一个特定元素。整个搜索过程从中间开始，如果要查找的元素即中间元素，那么搜索过程结束；反之根据中间元素与要查找元素的关系在数组对应的那一半查找，例如查找元素大于中间元素，则在整个数组较大元素的那一半查找，反复进行这个过程，直到找到元素...

			
		

	





	

		

			

				
					
二分查找 (二分搜索)  最通俗易懂的图解与实现

				
			

			

				

					blowfire123的博客
				

				

					11-14
					
					8867
					
				

			

		

		

			
				
二分查找场景

二分搜索用于在一个单调或者局部单调有序数组中查找一个符合某些条件的值，时间复杂度为O(logN)



二分查找原理图解

拿升序数组为例子进行解释，假设我们需要再数组中找到目标值key的下标。

1、首先可以将数组按key所在下标划分为三个部分，左边是小于key的部分，然后中间是key值，右边为大于key的部分。

用left和right两个指针不断地缩小搜索区域。







2、取mid为left和right的中间值，如果mid在key的下标的左边（即nums[mid] <..

			
		

	





	

		

			

				
					
二分搜索相关算法题汇总

				
			

			

				

					泛泛之素
				

				

					06-07
					
					6164
					
				

			

		

		

			
				
二分搜索简介
在计算机科学中，二分搜索（binary search）也称折半搜索（half-interval search）、对数搜索（logarithmic search），是在有序数组中查找某一特定元素的搜索算法。
二分搜索是一种在每次比较之后将查找空间一分为二的算法。每次需要查找集合中的索引或元素时，都应该考虑二分搜索。如果集合是无序的，我们可以总是在应用二分搜索之前先对其进行排序。
二分搜索的时间复杂度是 O(log n)，空间复杂度为 O(1)。
如何判断是否需要使用二分搜索，当你看到时间复杂度是

			
		

	





	

		

			

				
					
二分搜索面试题C++

				
			

			

				

					开贰锤
				

				

					11-09
					
					372
					
				

			

		

		

			
				
二分搜索的常见考察点


对于边界条件的考察以及代码实现的能力，如果边界条件处理不当，可能会出现死循环或者漏掉某个数的情况。仔细设计中间划分点的逻辑判断以及循环的终止条件，防止出现循环永远不能终止的情况。
在有序循环数组中进行二分搜索 
循环数组是指，1,2,3,4,5的任意前部分放到数组后，例如，23451,34512,45123,51234.




二分搜索的重要提醒

一般的中点选取为mi...

			
		

	





	

		

			

				
					
6 质数因子

				
			

			

				

					DIAN123457的博客
				

				

					07-21
					
					195
					
				

			

		

		

			
				
描述
功能:输入一个正整数，按照从小到大的顺序输出它的所有质因子（重复的也要列举）（如180的质因子为2 2 3 3 5 ）
最后一个数后面也要有空格
输入描述：
输入一个long型整数
输出描述：
按照从小到大的顺序输出它的所有质数的因子，以空格隔开。最后一个数后面也要有空格。
示例1
输入：
180

输出：
2 2 3 3 5 

解X
import java.util.Scanner;

public class Main {
    public static void main(String[]

			
		

	





	

		

			

				
					
算法与数据结构复习 第八章 检索（详解）

					
热门推荐

				
			

			

				

					好学者的博客
				

				

					12-06
					
					1万+
					
				

			

		

		

			
				
第八章 检索
书面作业:
一、判断题
1、在散列表中，所谓同义词就是具有相同散列地址的两个元素。 (T)
解析：
具有相同函数值的关键字对该散列函数来说称作同义词。
散列表
2、在散列中，函数“插入”和“查找”具有同样的时间复杂度。 (T)
解析：
插入和查找具有同样的时间复杂度O(1)。
3、即使把 2 个元素散列到有 100 个单元的表中，仍然有可能发生冲突。 (T)
解析：
若2个元素的相同...

			
		

	





	

		

			

				
					
在数组中找到一个局部最小的位置

				
			

			

				

					zhou_209的博客
				

				

					03-05
					
					615
					
				

			

		

		

			
				
题目：定义局部最小的概念。arr长度为1时，arr[0]是局部最小。arr的长度为N(N&gt;1)时，如果arr[0]&lt;arr[1]，那么arr[0]为局部最小。如果arr[N-1]&lt;arr[N-2]，那么arr[N-1]是局部最小。如果0&lt;i&lt;N-1，arr[i]&lt;arr[i+1]&amp;&amp;arr[i]&lt;arr[i-1]，那么arr[i]是局部最小...

			
		

	





	

		

			

				
					
二分搜索的例子

				
			

			

				

					Miaoshuowen的博客
				

				

					09-14
					
					292
					
				

			

		

		

			
				
二分搜索常见的应用场景
1.在有序序列中查找一个数
2.并不一定非要在有序序列中才能得到应用
二分搜索常见的考察点
1.对于边界条件的考察以及代码实现的能力
2.在有序循环数组中进行二分搜索
二分搜索常见题目的变化
1.给定处理或查找的对象不同
2.判断条件不同
3.要求返回的内容不同
二分搜索的重要提醒
mid= （left+right）/2  -->可能溢出
更安全的写法：mid=lef...

			
		

	





	

		

			

				
					
LightOJ 1289 LCM from 1 to n (节省空间的素数筛法+n个数的最小公倍数)

				
			

			

				

					whyorwhnt的专栏
				

				

					07-21
					
					4439
					
				

			

		

		

			
				
题目链接：http://lightoj.com/volume_showproblem.php?problem=1289
题意：给出n，求1到n的所有数的最小公倍数，模2^32.
思路：看到结果需要模2^32，瞬间想到要尝试用unsigned int来存储结果，它可以表示的数据范围是0~2^32-1，这样不用做任何操作，结果自然就是模2^32的。
接下来就是筛素数了，常用的方法学名是：埃拉托斯

			
		

	





	

		

			

				
					
牛客网算法学习记录-二分搜索

				
			

			

				

					u012656267的博客
				

				

					05-26
					
					374
					
				

			

		

		

			
				
定义局部最小的概念。arr长度为1时，arr[0]是局部最小。arr的长度为N(N>1)时，如果arr[0]<arr[1]，那么arr[0]是局部最小；如果arr[N-1]<arr[N-2]，那么arr[N-1]是局部最小；如果0<i<N-1，既有arr[i]<arr[i-1]又有arr[i]<arr[i+1]，那么arr[i]是局部最小。
 给定无序数组arr，已知arr中任意两个相邻的数都不

			
		

	





	

		

			

				
					
实验1：二分搜索算法

				
			

			

				

					Richard的专栏
				

				

					09-22
					
					2657
					
				

			

		

		

			
				

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值