二分查找

二分查找(折半查找) 定义 ：二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。在C语言顺序存储结构中可更加快捷，时间复杂度更小的查找方式。 算法要求： 1. 必须采用顺序存储结构。 2.必须按关键字大小 有序排列 。 查找过程 首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。 举个栗子： //二分查找 //找到返回元素下标，找不到返回负一 # define _CRT_SECURE_NO_WARNINGS # include <stdio.h> # include <windows.h> int binarySearch ( int a [ ] , int key , int left , int right ) { //定义中间变量与要找元素作比较 while ( left <= right ) { int mid = left + ( right - left ) / 2 ; if ( a [ mid ] == key ) { return mid ; } else if ( a [

1.题目描述 实现 pow(x, n) ，即计算 x 的 n 次幂函数。 示例 1: 输入: 2.00000, 10 输出: 1024.00000 示例 2: 输入: 2.10000, 3 输出: 9.26100 示例 3: 输入: 2.00000, -2 输出: 0.25000 解释: 2-2 = 1/22 = 1/4 = 0.25 说明: -100.0 < x < 100.0 n 是 32 位有符号整数，其数值范围是 [−231, 231 − 1] 。 2. 思路 1.暴力法：暴力递归，累乘，o(n) 2. 采用二分查找+递归的思想，简化计算复杂度 o(logn) 利用二分查找: 将幂次n/2；计算A = pow(x,n/2)的结果： 若n为偶数，返回 A*A; 若n为奇数，返回A*A*x； 最后再用递归调用完成，递归的边界条件是 n=0,return 1.0; 还有一个注意是： 1.当n为复数时，将转换为正数后再计算并且将 x装换为 1/x； 3.代码实现 class Solution { public: double myPow(double x, int n) { /* 思路： 参考昨天的做法，将计算 平方的平方的平方。。。 1.特殊情况考虑 n<0，用1/n计算； */ long long N = n; if(N<0) { x = 1/x; N = -N; }

测试链接 总时间限制: 1000ms 内存限制: 65536kB 描述 有函数： f(x) = x5 - 15 * x4+ 85 * x3- 225 * x2+ 274 * x - 121 已知 f(1.5) > 0 , f(2.4) < 0 且方程 f(x) = 0 在区间 [1.5,2.4] 有且只有一个根，请用二分法求出该根。 输入 无。 输出 该方程在区间[1.5,2.4]中的根。要求四舍五入到小数点后6位。 样例输入 无 样例输出 不提供 # include <cstdio> # include <cmath> # include <iostream> using namespace std ; double cal ( double x ) { double y ; y = x * x * x * x * x - 15 * x * x * x * x + 85 * x * x * x - 225 * x * x + 274 * x - 121 ; return y ; } int main ( ) { double left = 1.5 , right = 2.40 , mid ; int can = mid ; while ( cal ( left ) >= cal ( right ) ) { mid = ( left + right ) / 2.0 ; if (

二分查找法 二分查找的基本思想是：将n个元素分成大致相等的两部分，取a[n/2]与x做比较，如果x=a[n/2],则找到x,算法中止；如果xa[n/2],则只要在数组a的右半部搜索x. 折半查找法也称为二分查找法，它充分利用了元素间的次序关系，采用分治策略，可在最坏的情况下用O(log n)完成搜索任务。它的基本思想是：（这里假设数组元素呈升序排列）将n个元素分成个数大致相同的两半，取a[n/2]与欲查找的x作比较，如果x=a[n/2]则找到x，算法终止；如 果xa[n/2]，则我们只要在数组a的右 半部继续搜索x。 /* * 使用二分查找法的前提：数列是有序的，顺序存储结构 * * * 满足条件后采用折半的方式进行判断、查找， * * 折半数列，拿数列下标对应的元素与查找对象比较（默认数列为升序 小-->大） * 个人总结：先折半，再判断， * * * * * * */ public class TwoFindWay { public static void main(String[] args) { int[]array =new int[] {1,5,7,9,11,20,29,99};//array.length=8 Boss boss =new Boss(array); System.out.println(boss.find(6)); System.out.println

算法思想 折半查找：又称二分查找，适用于有序的顺序表。 先将中间位置元素与Key进行比较 若相等，则返回中间位置下标 若不相等： ① key<中间值，在左半边继续查找 ② key>中间值，在右半边继续查找 算法实现 int BinarySearch ( sqList L , int key ) { int low = 0 , high = L . length - 1 ; while ( low <= high ) //'<='很关键 { int mid = ( low + high ) / 2 ; if ( L . data [ mid ] == key ) return mid + 1 ; else if ( key < L . data [ mid ] ) high = mid - 1 ; else low = mid + 1 ; } return - 1 ; } 运行代码 # include "stdafx.h" # include <iostream> using namespace std ; # define MaxSize 50 typedef struct { int data [ MaxSize ] ; int length ; } sqList ; void Creat ( sqList & L ) ; int Search ( sqList L , int

二分查找（Binary Search） 二分查找：又称折半查找，从有序列表候选区li[0: n]开始，通过对待查找的值与候选区中间值的比较，可以是候选区减少一半 二分查找的基本思想是将n个元素分成大致相等的两部分，取a[n/2]与x做比较，如果x=a[n/2],则找到x,算法中止；如果x<a[n/2],则只要在数组a的左半部分继续搜索x,如果x>a[n/2],则只要在数组a的右半部搜索x. 时间复杂度即是while循环的次数。 总共有n个元素， 渐渐跟下去就是n,n/2,n/4,…n/2^k（接下来操作元素的剩余个数），其中k就是循环的次数 由于你n/2^k取整后>=1 即令n/2^k=1 可得k=log2n,（是以2为底，n的对数） 所以时间复杂度可以表示O(h)=O(log2n) 在一串有序列表中检索 “3” 1.标记有序列表中最左侧与最右侧的值，取中间值为 mid 使列表折半 2.判断后使标记的最右边的值等于mid - 1 , 再折半区间 3.再次折半 代码如下 def Binary_search ( li , vol ) : left = 0 right = len ( li ) - 1 # 判断后选区有值 while left <= right : mid = ( left + right ) // 2 if li [ mid ] == vol : print ( mid

public static int bsearch(int[] a, int n, int value) {//a是查找目标数组,n是数组长度,value是查找的值 int low = 0; int high = n - 1; while (low <= high) { int mid = (low + high) / 2; if (a[mid] == value) { return mid; } else if (a[mid] < value) { low = mid + 1; } else { high = mid - 1; } } return -1; } @Test public void test1(){ int[] a={1,2,3,4,5,6,7,8,9}; int value=9; System.out.println(bsearch(a,a.length,value)); } 来源： https://www.cnblogs.com/zyf-yxm/p/11127551.html

递归实现： 自己写的递归：多一个赋值操作，虽然可以得到正确的结果。但是比较难以理解。 问题：没有深刻理解递归返回值。return会在递归调用到最后，在递归结束的地方，会将返回值一层一层返回给方法，直到返回最后一层也就是方法不进行递归演算的动作时。 总结：首先要记住递归有递归头和递归体，递归头可能有多重情况。递归体也可能有多重情况。 public static int binarySearch(int[] arr,int n){ int low=0; int high=arr.length-1; return binarySearch2(arr,low,high,n); } public static int binarySearch2(int[] arr,int low,int high,int n){ int z=(low+high)/2; int i=-1; if(low<=high){ if(arr[z]==n ){ return i=z; }else{ if(arr[z]>n){ high=z-1; }else if(arr[z]<n){ low=z+1; } return binarySearch2(arr,low,high,n); } } return i; } 网友的递归： 没有找到对应值，递归结束会走对应的递归头 找到对应值，递归结束走对应递归头 public

思路：两次二分查找。。第一次寻找该数字第一次出现的位置，第二次查找该数字最后一次出现的位置 做差并加1； #include<iostream> #include<algorithm> using namespace std; int arr[1003]; int main() { int n,k; cin>>n>>k;//n个数，查找k出现的次数 for(int i=0;i<n;i++){ cin>>arr[i]; } sort(arr,arr+n); int low=0; int high=n-1,mid; while(low<=high){ mid=(high-low)/2+low; if(arr[mid]>k) high=mid; else if(arr[mid]<k) low=mid; else { if(arr[mid-1]==k&&mid>=0) high=mid; else break; } } low=0,high=n-1; int mid1; while(low<=high){ mid1=(high-low)/2+low; if(arr[mid1]>k) high=mid1; else if(arr[mid1]<k) low=mid1; else { if(arr[mid1+1]==k&&mid1<n-1) low=mid1; else break; } }

一、二分查找 二分查找也叫折半查找，每次查找缩减当前元素量的一半，这种查找效率是很惊人的 时间复杂度 ： 假设我们有n个数据，查找一次，元素量变为：2/n；查找k次后的区间： n/2 k,等比数列，当n/2 k = 1时，k就是总的缩小次数，=> O(K) = logn 二、二分查找的递归，非递归，面试题 非递归： /** *二分查找非递归方式 * @param arr 查找的数组 * @param val 要查找的值 * @return */ public static int nBinarySearch(int[]arr,int val){ int low = 0;//第一个元素下标 int hight = arr.length-1;//最后一个元素下标 while (low<=hight){//不加等于号，会不判断low==hight所在元素 int mid = low + (hight-low)/2; //mid = (low + hight)>>1 low，hight之和可能超过int范围 if (arr[mid]>val){//查找元素小于中间值 hight = mid-1; }else if (arr[mid]<val){ low = mid + 1; }else { return mid; } } return -1; } 递归： /** * 二分查找递归方法 *