二分查找

/** * 循环实现二分查找算法 */ public static int binarySearch(int[] arr, int x){ int low = 0; int high = arr.length - 1; while(low <= high){ int middle = (low + high)/2; if (x == arr[middle]){ return middle; }else if(x < arr[middle]){ high = middle - 1; }else{ low = middle + 1; } } return -1; } /** * 递归查找 */ public static int binarySearchRecursive(int[] arr, int x, int startIndex, int endIndex){ int middle = (startIndex + endIndex) / 2; //三个终止条件 if(x < arr[startIndex] || x > arr[endIndex] || startIndex > endIndex){ return -1; } if (x < arr[middle]){ return binarySearchRecursive(arr, x, startIndex, middle

import bisect L = [1, 3, 3, 6, 8, 12, 15] x = 5 x_insert_point = bisect.bisect_left(L, x)# 在L中查找x，x存在时返回x左侧的位置，x不存在返回应该插入的位置..这是3存在于列表中，返回左侧位置１ print(x_insert_point) x_insert_point = bisect.bisect_right(L, x) # 在L中查找x，x存在时返回x右侧的位置，x不存在返回应该插入的位置..这是3存在于列表中，返回右侧位置３ print(x_insert_point) x_insort_left = bisect.insort_left(L, x) # 将x插入到列表L中，x存在时插入在左侧 print(L) x_insort_rigth = bisect.insort_right(L, x) # 将x插入到列表L中，x存在时插入在右侧　　　　 print(L) 二分法的实现方式 def binary_search(t,x): temp = t; temp.sort(); low = 0; mid = 0; high = len(temp)-1; while low < high: mid = (low+high)/2; if x<t[mid]: high = mid-1; elif

也叫折半查找。 优点：比较次数少，查找速度快，平均性能好。 缺点：查找的数组必须为排序好的数组。 时间复杂度：O(logN) 代码：（ 递归 ：用栈保存结果空间消耗严重） #include <iostream> using namespace std; // 二分查找 返回位置标号 时间复杂度O(logN) int binarySearch( int list[], int left, int right, int number) { if (list== NULL) return - 1 ; int index= 0 ; int mid=(right+left)/ 2 ; if (left> right) { return - 1 ; } if (number== list[mid]) { index = mid; return index; } else if (number> list[mid]) { binarySearch(list,mid + 1 ,right,number); } else { binarySearch(list,left,mid - 1 ,number); } } int main() { int a[]={ 1 , 3 , 5 , 7 , 9 , 11 , 14 , 16 , 17 , 20 }; int left = 0 ; int right

一、C 程序实现 /******************************************************************************************* *Description 二分查找算法 *Author liaoxiongxiong *Version 1.0 *Time 2018-04-28 *******************************************************************************************/ #include <stdio.h> //二分查找，版本1 int BinarySearch1(int a[], int value, int n) { int low, high, mid; low = 0; high = n-1; while(low<=high) { mid = (low+high)/2; if(a[mid] == value) return mid; if(a[mid]>value) high = mid-1; if(a[mid]<value) low = mid+1; } return -1; } //二分查找，版本2，递归版本 int BinarySearch2(int a[], int value, int low, int

1、二分查找 对于一个有序数组，我们通常采用二分查找的方式来定位某一元素，请编写二分查找的算法，在数组中查找指定元素。 给定一个整数数组 A 及它的大小 n ，同时给定要查找的元素 val ，请返回它在数组中的位置(从0开始)，若不存在该元素，返回-1。若该元素出现多次，请返回第一次出现的位置。 测试样例： [1,3,5,7,9],5,3 返回：1 class BinarySearch { public : int getPos(vector< int > A, int n, int val) { // write code here if (A.empty()) return - 1 ; int low = 0 ; int high = n- 1 ; while (low <= high) { int mid = (low + high)* 0.5 ; if (val < A[mid]) high = mid - 1 ; else if (val > A[mid]) low = mid + 1 ; else { while (mid >= 0 && A[mid] == val) mid -- ; return mid+ 1 ; } } return - 1 ; } }; 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中

一,递归函数 1,1初始递归 递归的最大深度 : 998 递归函数如果不受外力的阻止会一直执行下去,但是函数的每次调用都会产生一个属于自己的名称空间,如果一直调用下去的话,会出现名称空间过多导致的内存问题,所以为了避免这种现象,强制将递归层数控制在了997 def foo(n): print (n) n = n + 1 foo(n) foo( 1 1,2 ,递归示例 问alex多大了,告诉你alex比egon大两岁, 然后去问egon多大了,egon说我比wusir大两岁, 然后又去问wusir,wusir说他比太白大两岁, 然后去问太白,太白说他18,这样就可以计算出alex到底多大了 age(4) = age(3) + 2 age( 3) = age(2) + 2 age( 2) = age(1) + 2 age( 1) = 18 然后我们用函数表示 def age(n): if n == 1 : return 18 else : return age(n - 1) + 2 print (age(4 )) # 24 解析: def age(4): 　　if n == 1: 　　　　return 26 　　else: 　　　　return age(3) + 2 def age(3): 　　if n == 1: 　　　　return 26 　　else: 　　　　return

一、二分查找法的时间复杂度 int Er_Feng_Find( int arr[], int sz, int data) { int left = 0 ; int right = sz - 1 ; int mid = 0 ; while (left <= right) 2 ; if (data < arr[mid]) 1 ; if (data > arr[mid]) 1 ; if (data == arr[mid]) return mid; // 找到了返回下表 return - 1 ; // 找不到返回-1 } int main() { int arr[ 10 ] = { 1 , 5 , 7 , 13 , 16 , 18 , 19 , 21 , 25 , 27 }; int data = 18 ; int sz = sizeof (arr) / sizeof (arr[ 0 ]); int pos=Er_Feng_Find(arr,sz,data); if (pos != - 1 ) printf ( " 找到了，下表为：%d\n" , pos); "pause" ); return 0 ; } 因为辅助空间是常数，所以空间复杂度为O(1) 二、递归实现的斐波那契数列的时间复杂度和空间复杂度 代码如下： fibo( int n) if (n<= 2 ) return 1 else

Description L L N N D i D i L ). 　　To play the game, each cow in turn starts at the starting rock and tries to reach the finish at the ending rock, jumping only from rock to rock. Of course, less agile cows never make it to the final rock, ending up instead in the river. M N ). *before* M Input L N M N +1: Each line contains a single integer indicating how far some rock is away from the starting rock. No two rocks share the same position. Output M Sample Input 25 5 2 2 14 11 21 17 Sample Output 4 解题思路： 　　一开始题意并不太好理解。稍微转换一下思路，给定N＋2个石头，从中选出N+2－M个石头使他们之间最小的距离最大。 那么我们如何切入呢 我们利用二分查找 查找一个p是不是这个最短距离

二分查找是一种查询效率非常高的查找算法。又称折半查找。 二分查找算法思想 有序的序列，每次都是以序列的中间位置的数来与待查找的关键字进行比较，每次缩小一半的查找范围，直到匹配成功。 一个情景：将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。 二分查找图示说明 图片来源百度图片，感谢分享者 二分查找优缺点 优点是比较次数少，查找速度快，平均性能好； 其缺点是要求待查表为有序表，且插入删除困难。 因此，折半查找方法适用于不经常变动而查找频繁的有序列表。 使用条件：查找序列是顺序结构，有序。 public static void main(String[] args) { // write your code here System.out.print("二分法算法 :"); int[] arr = {1,3,5,7,9,11}; int value = 5; int index = binarySearch(arr,arr.length,value); System.out.print("算法 :"+ index); } //二分法排序 static

基本思想 首先将给定值K与表中中间位置的关键字比较，若相等，则查找成功，返回该元素的下标；若不等，则所查找的元素只能在中间数据以外前半部分或后半部分。然后在缩小的区间中继续进行同样的查找，如此重复直到找到为止，如果查找区间缩小到只有一个元素，其关键字仍不等于k，则查找失败 。 每进行一次键值与给定值的比较，查找区间的长度至少减少为原来的二分之一。 题目 用二分查找法对一个长度为10的有序表进行查找，填写每一元素需要比较次数，元素下表： 1 2 3 4 5 6 7 8 9 10 填写比较次数 Mid=(low+high)/2，在每次比较是可以根据区间查找，如果为奇数的是去最中间一个，若是偶数则向下取整。 第一次 Mid(1+9)/2=5 取第五个数，再此序列的值为5 1 low 2 3 4 5 mid 6 7 8 9 10 high 将此无序序列分成两组，即5之前为一组，5之后为一组。 第二次 ，先排左边 1 low 2 3 4 5 mid 6 7 8 9 10 high Mid(1+4)/2=2.5取2.即2的位置 1 low 2 mid 3 4 high 第三次 在第三趟的时候mid左边只有一个数，即low，high，mid都是这一个数，所以在第三趟的时候1的比较次数已经出来了，接下来就开始比较右边的。 Mid(1+2)/2=1.5 还是向下取整，为1 1 low Mid