二分查找

实现：递归思路实现二分查找,找到返回下标,否则返回-1. 思路：思路是将查找值与数组最中间值比较,若查找值相等数字最中间值就找到了,返回下标值;若查找值小于最中间值,则把最左边到中间作为一个数组再进行查找;若查找值大于最中间值,则把中间到最右边作为一个数组再进行查找. 1 public class ArrayDemo{ 2 　　//参数a 代表查找的数组,参数left代表数组的最左边值的下标,参数right代表数组的最右边值的下标,参数n代表的是查找值 3 　　public static int binarySearch(int[] a,int left,int right,int n){ 4 　　//若左边值的下标大于最右边的下标,即代表查找完毕,没有找到该值,返回-1 5 　　　　if(left>right){ 6 　　　　　　return -1; 7 　　　　} 8 　　　　int mid = (left+right)/2; 9 　　　　if(a[mid] == n){ 10 　　　　　　return mid; 11 　　　　}else if(a[mid] > n){ 12 　　　　　　return binarySearch(a,left,mid-1,n); 13 　　　　}else{ 14 　　　　　　return binarySearch(a,mid+1,right,n)

1 #include <stdlib.h> 2 #include <stdio.h> 3 #include <string.h> 4 5 #define ARRAY_SIZE 10 6 7 int binarySearch(int *arr, int size, int target) 8 { 9 int low = 0; 10 int high = size - 1; 11 while (low < high) 12 { 13 int mid = low + (high - low) / 2; 14 //当low+high超过整数范围会发生溢出，变为负数 15 //int mid = (low + high) / 2; 16 if (arr[mid] < target) 17 { 18 low = mid + 1; 19 } 20 else if (arr[mid] > target) 21 { 22 high = mid - 1; 23 } 24 else 25 { 26 return mid; 27 } 28 } 29 return -1; 30 } 31 int main(int argc, char **argv) 32 { 33 int array_unsort[ARRAY_SIZE] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 34 int

#include <iostream> #include <vector> #include <algorithm> using namespace std; void QSort(int a[], int low, int high) { if(low>=high) //关于这个终止条件， 在下边处理后，low可能会大于或等于high { return; } int first = low; int last = high; int key = a[first]; //use the first elements to be the key while(first<last) { while(first<last&&a[last]>=key) { last--; } a[first] = a[last]; while(first<last&&a[first]<=key) { first++; } a[last] = a[first]; a[first] = key; QSort(a, low, first-1); QSort(a, first+1, high); } } int NBinarySearch(vector<int> arr, int n, int target) { int low = 0, high = n - 1; //"low" is the low

1，定义 二分查找也称折半查找，前提是线性表中的记录必须是有序的(通常从小到大有序) ，线性表必须采用顺序存储，它是一种效率较高的查找方法。 2，基本思想 （1）在有序表中，取中间数据作为比较对象，若给定值与中间记录的关键字相 等，则查找成功； （2）若给定值小于中间记录的关键字，则在中阔记录的左半区继续查找； （3）若给定值大于中间记录的关键字，则在中间记录的右半区继续查找； （4）不断重复上述过程，直到查找成功，或所有查找区域元记录，查找失败为止。 3，实现代码 int BinarySearch ( int * a , int length , int key ) { int low = 1 ; int high = length ; int mid ; while ( low <= high ) { mid = ( low + high ) / 2 ; if ( key < a [ mid ] ) high = mid - 1 ; else if ( key > a [ mid ] ) low = mid + 1 ; else return mid ; } return 0 ; } 例题： 《切绳子》 描述： 有n条绳子，长度分别为L[i]。如果从他们中切割出k条长度相同的绳子的话，这k条绳子每条最长能有多长？（答案保留小数点后两位，规定1单位长度的绳子最多可以切割成100份

一：数组二分查找法 二分查找法又被称为折半查找，是一种效率较高的查找方法 二分查找法的原理：将数组分为三部分，中值（最中间的值），中值前，中值后，将要查找的值和数组的中值进行比较，若小于中值则在中值前面找，若大于中值则在中值后面找，等于中值时直接返回。 二分查找法的实例一 /* 需求一：运用二分查找法查找出在数组中{13,15,20,33,54,69,98,110};是否存在54这个数值？ 思路：1）先遍历一遍数组中的数据 2）利用角标便于记录数据的位置 3）将数组分为三个部分，中值（mid）,中值前（min）,中值后（max） 4）先用中值与要查找的那个数先进行比较，确定其位置。小于中值在前面找，反之则后面找。一次类推 5）需进行比较哟啊用到if语句 */ public class TestArrayDemo { public static void main ( String [ ] args ) { //int [] arr={45,5,6,23,33,56,22}; int [ ] arr = { 13 , 15 , 20 , 33 , 54 , 69 , 98 , 110 } ; //int index=getIndex(arr,33); //int index=halfSearch(arr,60); int index = halfSearch2 ( arr , 54

首先，我们来看一个笔者的拙作，一段二分查找代码 //返回值是key的下标，如果A中不存在key则返回-1 template <class T> int BinSearch(T* A, const T &key, int lo, int hi) { int mid; while(lo<hi) { mid = lo + (hi-lo)/2; if(key < A[mid]) hi = mid-1; else if(key > A[mid]) lo = mid+1; else return mid; if(lo==hi && A[lo]==key) return lo; } return -1; } 可以证明，算法的时间复杂度为O(nlogn)，考虑前面的系数的话，大致是O(1.5nlogn)。 但是，这一实现仍有改进的余地。注意到循环 只需要1次 判断来决定是否转进到左侧，但需要2次判断来决定是否转进到右侧。也就是进入左、右分支前的关键码比较次数不等。 而斐波那契查找正是优化了这点。利用斐波那契数来对传入的数组进行黄金分割，这样前半部分较多而后半部分较少。另外，进入前半部分继续搜索所需的判断只有一次，而进入后半部分继续搜索所需的判断却有两次。如此而来，我们人为造成的这种不平衡，反倒是助长了搜索成本的平衡。 template <class T> int FibSearch(T* A,

1、定义 二分查找又称 折半查找 ，它是一种效率较高的查找方法。 二分查找要求： 线性表是有序表 ，即表中 结点按关键字有序，并且要用向量作为表的存储结构 。不妨设有序表是递增有序的。 2、基本思想 二分查找的基本思想是： 设R[low..high]是当前的查找区间 （1）首先确定该区间的中点位置： （2）然后将待查的K值与R[mid].key比较：若相等，则查找成功并返回此位置，否则须确定新的查找区间，继续二分查找，具体方法如下： ① 若 R[mid].key>K ，则由表的有序性可知R[mid..n].keys均大于K，因此若表中存在关键字等于K的结点，则该结点必定是在位置mid左边的子表R[1..mid-1]中，故新的查找区间是左子表R[1..mid-1]。 ② 若 R[mid].key<K ，则要查找的K必在mid的右子表R[mid+1..n]中，即新的查找区间是右子表R[mid+1..n]。下一次查找是针对新的查找区间进行的。 因此，从初始的查找区间R[1..n]开始，每经过一次与当前查找区间的中点位置上的结点关键字的比较，就可确定查找是否成功，不成功则当前的查找区间就缩小一半。这一过程重复直至找到关键字为K的结点，或者直至当前的查找区间为空(即查找失败)时为止。 3、存储结构 二分查找只适用顺序存储结构 。 4、二分查找算法 /*折半查找*/ int Binary

1、定义 二叉排序树（Binary Sort Tree）又称 二叉查找(搜索)树 （Binary Search Tree）。其定义为：二叉排序树或者是空树，或者是满足如下性质的二叉树： ① 若它的左子树非空，则左子树上所有结点的值均小于根结点的值； ② 若它的右子树非空，则右子树上所有结点的值均大于根结点的值； ③ 左、右子树本身又各是一棵二叉排序树。 上述性质简称二叉排序树性质(BST性质)，故二叉排序树实际上是满足BST性质的二叉树。 注意： 当用线性表作为表的组织形式时，可以有三种查找法。其中以二分查找效率最高。但由于二分查找要求表中结点按关键字有序，且不能用链表作存储结构，因此，当表的插入或删除操作频繁时，为维护表的有序性，势必要移动表中很多结点。这种由移动结点引起的额外时间开销，就会抵消二分查找的优点。也就是说，二分查找只适用于静态查找表。若要对动态查找表进行高效率的查找，可采用下二叉树或树作为表的组织形式。不妨将它们统称为树表。 2、特点 由BST性质可得： （1） 二叉排序树中任一结点x，其左(右)子树中任一结点y(若存在)的关键字必小(大)于x的关键字。 （2） 二叉排序树中，各结点关键字是惟一的。 注意： 实际应用中，不能保证被查找的数据集中各元素的关键字互不相同，所以可将二叉排序树定义中BST性质(1)里的"小于"改为"大于等于"，或将BST性质(2)里的"大于

假设要在电话簿中找一个名字以K打头的人，（现在谁还用电话簿！）可以从头开始翻页，直到进入以K打头的部分。但你很可能不这样做，而是从中间开始，因为你知道以K打头的名字在电话簿中间。 又假设要在字典中找一个以O打头的单词，你也将从中间附近开始。 现在假设你登录Facebook。当你这样做时，Facebook必须核实你是否有其网站的账户，因此必须在其数据库中查找你的用户名。如果你的用户名为karlmageddon，Facebook可从以A打头的部分开始查找，但更合乎逻辑的做法是从中间开始查找。 这是一个查找问题，在前述所有情况下，都可使用同一种算法来解决问题，这种算法就是二分查找。 二分查找是一种算法，其输入是一个有序的元素列表（必须有序的原因稍后解释）。如果要 查找的元素包含在列表中，二分查找返回其位置；否则返回null。 随便猜想一个1-100的数字来分析二分查找与简单查找的区别： 简单查找 二分查找 方法 一个数字，一个数字的猜。若猜的数字过大，则再将数字猜小点；若猜的数字过大，则将数字猜大点，直至猜中目标数字 从100的一半50开始猜（无论大小都可排除一半的数字），接下来重复以上步骤，每次猜测的数字都是剩余数字的中间数，直至猜中目标数字 执行的最糟糕的次数 n次 二分查找的Python代码： 函数binary_search接受一个有序数组和一个元素。如果指定的元素包含在数组中

1.普通查找： 使用遍历从前往后一个一个找。 代码实现： public static void main ( String [ ] args ) { int [ ] arr = { 5 , 6 , 7 , 32 , 43 , 44 , 678 } ; int num = 47 ; //调用方法 int i = find ( arr , num ) ; System . out . println ( i ) ; } //定义方法 public static int find ( int [ ] arr , int num ) { //数组的遍历 for ( int i = 0 ; i < arr . length ; i ++ ) { if ( arr [ i ] == num ) { return i ; } } //使用-1来代表不存在这个元素 return - 1 ; } 2.二分查找 前提条件：数组必须是已经排序好的。 图解： 代码实现： public static void main ( String [ ] args ) { //准备数组 int [ ] arr = { 5 , 6 , 7 , 32 , 43 , 44 , 678 } ; int num = 46 ; //调用方法 int i = find ( arr , num ) ; System . out .