二分
2015-06-07 20:42
381 查看
要知道,只有一个算法的时间复杂度是log(n)
没错,那就是二分查找!
而想要应用二分查找法,这“一堆数”必须有一下特征:
存储在数组中
有序排列
所以如果是用链表存储的,就无法在其上应用二分查找法了。
至于是顺序递增排列还是递减排列,数组中是否存在相同的元素都不要紧。不过一般情况,我们还是希望并假设数组是递增排列,数组中的元素互不相同。
不过所有的递归都可以自行定义stack来解递归,所以二分查找法也可以不用递归实现,而且它的非递归实现甚至可以不用栈,因为二分的递归其实是尾递归,它不关心递归前的所有信息。
而实际上我们只需要一个小于比较(<)就可以。因为错逻辑上讲a>b和b<a应该是有相当的逻辑值;而a==b则是等价于 !((a<b)||(b<a)),也就是说a既不小于b,也不大于b。
当然在程序的世界里, 这种关系逻辑其实并不是完全正确。另外,C++还允许对对象进行运算符的重载,因此开发人员完全可以随意设计和实现这些关系运算符的逻辑值。
不过在整型数据面前,这些关系运算符之间的逻辑关系还是成立的,而且在开发过程中,我们还是会遵循这些逻辑等价关系来重载关系运算符。
干嘛要搞得那么羞涩,只用一个关系运算符呢?因为这样可以为二分查找法写一个template,又能减少对目标对象的要求。模板会是这样的:
我们需要求target的类型V有重载小于运算符就可以。而对于V的集合类型T,则需要有[]运算符的重载。当然其内部实现必须是O(1)的复杂度,否则也就失去了二分查找的效率。
用数学的表述方式就是:
在集合中找到一个大于(小于)目标数t的数x,使得集合中的任意数要么大于(小于)等于x,要么小于(大于)等于t。
举例来说:
给予数组和目标数
那么上界值应该是11,因为它“刚刚好”大于7;下届值则是5,因为它“刚刚好”小于7。
与精确查找不同之处在于,精确查找分成三类:大于,小于,等于(目标数)。而界限查找则分成了两类:大于和不大于。
如果当前找到的数大于目标数时,它可能就是我们要找的数,所以需要保留这个索引,也因此if (array[mid] > target)时 high=mid; 而没有减1。
下届寻找基本与上届相同,需要注意的是在取中间索引时,使用了向上取整。若同之前一样使用向下取整,那么当low == high-1,而array[low] 又小于 target时就会形成死循环。因为low无法往上爬超过high。
这两个实现都是找严格界限,也就是要大于或者小于。如果要找松散界限,也就是找到大于等于或者小于等于的值(即包含自身),只要对代码稍作修改就好了:
去掉判断数组边界的等号:
在与中间值的比较中加上等号:
此时,我们会希望知道有多少个目标数存在。或者说我们希望数组的区域。
结合前面的界限查找,我们只要找到目标数的严格上届和严格下届,那么界限之间(不包括界限)的数据就是目标数的区域了。
它的时间复杂度是两次二分查找所用时间的和,也就是O(log n) + O(log n),最后还是O(log n)。
不过还有一种特殊的数组上也同样可以应用,那就是“轮转后的有序数组(Rotated Sorted Array)”。它是有序数组,取期中某一个数为轴,将其之前的所有数都轮转到数组的末尾所得。比如{7, 11, 13, 17, 2, 3, 5}就是一个轮转后的有序数组。非严格意义上讲,有序数组也属于轮转后的有序数组——我们取首元素作为轴进行轮转。
下边就是二分查找法在轮转后的有序数组上的实现(假设数组中不存在相同的元素)
对比普通的二分查找法,为了确定目标数会落在二分后的那个部分,我们需要更多的判定条件。但是我们还是实现了O(log n)的目标。
必须有序,我们很难保证我们的数组都是有序的。当然可以在构建数组的时候进行排序,可是又落到了第二个瓶颈上:它必须是数组。
数组读取效率是O(1),可是它的插入和删除某个元素的效率却是O(n)。因而导致构建有序数组变成低效的事情。
解决这些缺陷问题更好的方法应该是使用二叉查找树了,最好自然是自平衡二叉查找树了,自能高效的(O(n log n))构建有序元素集合,又能如同二分查找法一样快速(O(log
n))的搜寻目标数。
下面是二叉查找树的基本算法,一块贴上了
没错,那就是二分查找!
关于二分查找法
二分查找法主要是解决在“一堆数中找出指定的数”这类问题。而想要应用二分查找法,这“一堆数”必须有一下特征:
存储在数组中
有序排列
所以如果是用链表存储的,就无法在其上应用二分查找法了。
至于是顺序递增排列还是递减排列,数组中是否存在相同的元素都不要紧。不过一般情况,我们还是希望并假设数组是递增排列,数组中的元素互不相同。
二分查找法的基本实现
二分查找法在算法家族大类中属于“分治法”,分治法基本都可以用递归来实现的,二分查找法的递归实现如下:int bsearch(int array[], int low, int high, int target) { if (low > high) return -1; int mid = (low + high)/2; if (array[mid]> target) return binarysearch(array, low, mid -1, target); if (array[mid]< target) return binarysearch(array, mid+1, high, target); //if (midValue == target) return mid; }
不过所有的递归都可以自行定义stack来解递归,所以二分查找法也可以不用递归实现,而且它的非递归实现甚至可以不用栈,因为二分的递归其实是尾递归,它不关心递归前的所有信息。
int bsearchWithoutRecursion(int array[], int low, int high, int target) { while(low <= high) { int mid = (low + high)/2; if (array[mid] > target) high = mid - 1; else if (array[mid] < target) low = mid + 1; else //find the target return mid; } //the array does not contain the target return -1; }
只用小于比较(<)实现二分查找法
在前面的二分查找实现中,我们既用到了小于比较(<)也用到了大于比较(>),也可能还需要相等比较(==)。而实际上我们只需要一个小于比较(<)就可以。因为错逻辑上讲a>b和b<a应该是有相当的逻辑值;而a==b则是等价于 !((a<b)||(b<a)),也就是说a既不小于b,也不大于b。
当然在程序的世界里, 这种关系逻辑其实并不是完全正确。另外,C++还允许对对象进行运算符的重载,因此开发人员完全可以随意设计和实现这些关系运算符的逻辑值。
不过在整型数据面前,这些关系运算符之间的逻辑关系还是成立的,而且在开发过程中,我们还是会遵循这些逻辑等价关系来重载关系运算符。
干嘛要搞得那么羞涩,只用一个关系运算符呢?因为这样可以为二分查找法写一个template,又能减少对目标对象的要求。模板会是这样的:
template <typename T, typename V> inline int BSearch(T& array, int low, int high, V& target) { while(!(high < low)) { int mid = (low + high)/2; if (target < array[mid]) high = mid - 1; else if (array[mid] < target) low = mid + 1; else //find the target return mid; } //the array does not contain the target return -1; }
我们需要求target的类型V有重载小于运算符就可以。而对于V的集合类型T,则需要有[]运算符的重载。当然其内部实现必须是O(1)的复杂度,否则也就失去了二分查找的效率。
用二分查找法找寻边界值
之前的都是在数组中找到一个数要与目标相等,如果不存在则返回-1。我们也可以用二分查找法找寻边界值,也就是说在有序数组中找到“正好大于(小于)目标数”的那个数。用数学的表述方式就是:
在集合中找到一个大于(小于)目标数t的数x,使得集合中的任意数要么大于(小于)等于x,要么小于(大于)等于t。
举例来说:
给予数组和目标数
int array = {2, 3, 5, 7, 11, 13, 17}; int target = 7;
那么上界值应该是11,因为它“刚刚好”大于7;下届值则是5,因为它“刚刚好”小于7。
用二分查找法找寻上届
//Find the fisrt element, whose value is larger than target, in a sorted array int BSearchUpperBound(int array[], int low, int high, int target) { //Array is empty or target is larger than any every element in array if(low > high || target >= array[high]) return -1; int mid = (low + high) / 2; while (high > low) { if (array[mid] > target) high = mid; else low = mid + 1; mid = (low + high) / 2; } return mid; }
与精确查找不同之处在于,精确查找分成三类:大于,小于,等于(目标数)。而界限查找则分成了两类:大于和不大于。
如果当前找到的数大于目标数时,它可能就是我们要找的数,所以需要保留这个索引,也因此if (array[mid] > target)时 high=mid; 而没有减1。
用二分查找法找寻下届
//Find the last element, whose value is less than target, in a sorted array int BSearchLowerBound(int array[], int low, int high, int target) { //Array is empty or target is less than any every element in array if(high < low || target <= array[low]) return -1; int mid = (low + high + 1) / 2; //make mid lean to large side while (low < high) { if (array[mid] < target) low = mid; else high = mid - 1; mid = (low + high + 1) / 2; } return mid; }
下届寻找基本与上届相同,需要注意的是在取中间索引时,使用了向上取整。若同之前一样使用向下取整,那么当low == high-1,而array[low] 又小于 target时就会形成死循环。因为low无法往上爬超过high。
这两个实现都是找严格界限,也就是要大于或者小于。如果要找松散界限,也就是找到大于等于或者小于等于的值(即包含自身),只要对代码稍作修改就好了:
去掉判断数组边界的等号:
target >= array[high]改为 target > array[high]
在与中间值的比较中加上等号:
array[mid] > target改为array[mid] >= target
用二分查找法找寻区域
之前我们使用二分查找法时,都是基于数组中的元素各不相同。假如存在重复数据,而数组依然有序,那么我们还是可以用二分查找法判别目标数是否存在。不过,返回的index就只能是随机的重复数据中的某一个。此时,我们会希望知道有多少个目标数存在。或者说我们希望数组的区域。
结合前面的界限查找,我们只要找到目标数的严格上届和严格下届,那么界限之间(不包括界限)的数据就是目标数的区域了。
//return type: pair<int, int> //the fisrt value indicate the begining of range, //the second value indicate the end of range. //If target is not find, (-1,-1) will be returned pair<int, int> SearchRange(int A[], int n, int target) { pair<int, int> r(-1, -1); if (n <= 0) return r; int lower = BSearchLowerBound(A, 0, n-1, target); lower = lower + 1; //move to next element if(A[lower] == target) r.first = lower; else //target is not in the array return r; int upper = BSearchUpperBound(A, 0, n-1, target); upper = upper < 0? (n-1):(upper - 1); //move to previous element //since in previous search we had check whether the target is //in the array or not, we do not need to check it here again r.second = upper; return r; }
它的时间复杂度是两次二分查找所用时间的和,也就是O(log n) + O(log n),最后还是O(log n)。
在轮转后的有序数组上应用二分查找法
之前我们说过二分法是要应用在有序的数组上,如果是无序的,那么比较和二分就没有意义了。不过还有一种特殊的数组上也同样可以应用,那就是“轮转后的有序数组(Rotated Sorted Array)”。它是有序数组,取期中某一个数为轴,将其之前的所有数都轮转到数组的末尾所得。比如{7, 11, 13, 17, 2, 3, 5}就是一个轮转后的有序数组。非严格意义上讲,有序数组也属于轮转后的有序数组——我们取首元素作为轴进行轮转。
下边就是二分查找法在轮转后的有序数组上的实现(假设数组中不存在相同的元素)
int SearchInRotatedSortedArray(int array[], int low, int high, int target) { while(low <= high) { int mid = (low + high) / 2; if (target < array[mid]) if (array[mid] < array[high])//the higher part is sorted high = mid - 1; //the target would only be in lower part else //the lower part is sorted if(target < array[low])//the target is less than all elements in low part low = mid + 1; else high = mid - 1; else if(array[mid] < target) if (array[low] < array[mid])// the lower part is sorted low = mid + 1; //the target would only be in higher part else //the higher part is sorted if (array[high] < target)//the target is larger than all elements in higher part high = mid - 1; else low = mid + 1; else //if(array[mid] == target) return mid; } return -1; }
对比普通的二分查找法,为了确定目标数会落在二分后的那个部分,我们需要更多的判定条件。但是我们还是实现了O(log n)的目标。
二分查找法的缺陷
二分查找法的O(log n)让它成为十分高效的算法。不过它的缺陷却也是那么明显的。就在它的限定之上:必须有序,我们很难保证我们的数组都是有序的。当然可以在构建数组的时候进行排序,可是又落到了第二个瓶颈上:它必须是数组。
数组读取效率是O(1),可是它的插入和删除某个元素的效率却是O(n)。因而导致构建有序数组变成低效的事情。
解决这些缺陷问题更好的方法应该是使用二叉查找树了,最好自然是自平衡二叉查找树了,自能高效的(O(n log n))构建有序元素集合,又能如同二分查找法一样快速(O(log
n))的搜寻目标数。
下面是二叉查找树的基本算法,一块贴上了
/************************************************************************* 这是一个二叉查找树,实现了以下操作:插入结点、构造二叉树、删除结点、查找、 查找最大值、查找最小值、查找指定结点的前驱和后继。上述所有操作时间复杂度 均为o(h),其中h是树的高度 注释很详细,具体内容就看代码吧 *************************************************************************/ #include<stdio.h> #include<stdlib.h> //二叉查找树结点描述 typedef int KeyType; typedef struct Node { KeyType key; //关键字 struct Node * left; //左孩子指针 struct Node * right; //右孩子指针 struct Node * parent; //指向父节点指针 }Node,*PNode; //往二叉查找树中插入结点 //插入的话,可能要改变根结点的地址,所以传的是二级指针 void inseart(PNode * root,KeyType key) { //初始化插入结点 PNode p=(PNode)malloc(sizeof(Node)); p->key=key; p->left=p->right=p->parent=NULL; //空树时,直接作为根结点 if((*root)==NULL){ *root=p; return; } //插入到当前结点(*root)的左孩子 if((*root)->left == NULL && (*root)->key > key){ p->parent=(*root); (*root)->left=p; return; } //插入到当前结点(*root)的右孩子 if((*root)->right == NULL && (*root)->key < key){ p->parent=(*root); (*root)->right=p; return; } if((*root)->key > key) inseart(&(*root)->left,key); else if((*root)->key < key) inseart(&(*root)->right,key); else return; } //查找元素,找到返回关键字的结点指针,没找到返回NULL PNode search(PNode root,KeyType key) { if(root == NULL) return NULL; if(key > root->key) //查找右子树 return search(root->right,key); else if(key < root->key) //查找左子树 return search(root->left,key); else return root; } //查找最小关键字,空树时返回NULL PNode searchMin(PNode root) { if(root == NULL) return NULL; if(root->left == NULL) return root; else //一直往左孩子找,直到没有左孩子的结点 return searchMin(root->left); } //查找最大关键字,空树时返回NULL PNode searchMax(PNode root) { if(root == NULL) return NULL; if(root->right == NULL) return root; else //一直往右孩子找,直到没有右孩子的结点 return searchMax(root->right); } //查找某个结点的前驱 PNode searchPredecessor(PNode p) { //空树 if(p==NULL) return p; //有左子树、左子树中最大的那个 if(p->left) return searchMax(p->left); //无左子树,查找某个结点的右子树遍历完了 else{ if(p->parent == NULL) return NULL; //向上寻找前驱 while(p){ if(p->parent->right == p) break; p=p->parent; } return p->parent; } } //查找某个结点的后继 PNode searchSuccessor(PNode p) { //空树 if(p==NULL) return p; //有右子树、右子树中最小的那个 if(p->right) return searchMin(p->right); //无右子树,查找某个结点的左子树遍历完了 else{ if(p->parent == NULL) return NULL; //向上寻找后继 while(p){ if(p->parent->left == p) break; p=p->parent; } return p->parent; } } //根据关键字删除某个结点,删除成功返回1,否则返回0 //如果把根结点删掉,那么要改变根结点的地址,所以传二级指针 int deleteNode(PNode* root,KeyType key) { PNode q; //查找到要删除的结点 PNode p=search(*root,key); KeyType temp; //暂存后继结点的值 //没查到此关键字 if(!p) return 0; //1.被删结点是叶子结点,直接删除 if(p->left == NULL && p->right == NULL){ //只有一个元素,删完之后变成一颗空树 if(p->parent == NULL){ free(p); (*root)=NULL; }else{ //删除的结点是父节点的左孩子 if(p->parent->left == p) p->parent->left=NULL; else //删除的结点是父节点的右孩子 p->parent->right=NULL; free(p); } } //2.被删结点只有左子树 else if(p->left && !(p->right)){ p->left->parent=p->parent; //如果删除是父结点,要改变父节点指针 if(p->parent == NULL) *root=p->left; //删除的结点是父节点的左孩子 else if(p->parent->left == p) p->parent->left=p->left; else //删除的结点是父节点的右孩子 p->parent->right=p->left; free(p); } //3.被删结点只有右孩子 else if(p->right && !(p->left)){ p->right->parent=p->parent; //如果删除是父结点,要改变父节点指针 if(p->parent == NULL) *root=p->right; //删除的结点是父节点的左孩子 else if(p->parent->left == p) p->parent->left=p->right; else //删除的结点是父节点的右孩子 p->parent->right=p->right; free(p); } //4.被删除的结点既有左孩子,又有右孩子 //该结点的后继结点肯定无左子树(参考上面查找后继结点函数) //删掉后继结点,后继结点的值代替该结点 else{ //找到要删除结点的后继 q=searchSuccessor(p); temp=q->key; //删除后继结点 deleteNode(root,q->key); p->key=temp; } return 1; } //创建一棵二叉查找树 void create(PNode* root,KeyType *keyArray,int length) { int i; //逐个结点插入二叉树中 for(i=0;i<length;i++) inseart(root,keyArray[i]); } int main(void) { int i; PNode root=NULL; KeyType nodeArray[11]={15,6,18,3,7,17,20,2,4,13,9}; create(&root,nodeArray,11); for(i=0;i<2;i++) deleteNode(&root,nodeArray[i]); printf("%d\n",searchPredecessor(root)->key); printf("%d\n",searchSuccessor(root)->key); printf("%d\n",searchMin(root)->key); printf("%d\n",searchMax(root)->key); printf("%d\n",search(root,13)->key); return 0; }
相关文章推荐
- 【VB与数据库】——机房收费系统总览
- Varnish 学习笔记总结
- wordpress中表单插件加载缓慢如何解决
- 【吾日三省吾身】2015.6.07-涅槃行动第二十天
- AcousticScorer API 声学打分
- C++对C的实用性增强
- [架构] ZeroMQ 深度探索(一)
- C++对C的实用性增强
- 路由器安全测试工具 – Router Scan v2.51
- 大三了,我还是喜欢《青春派》
- 数据库进程间通信解决方案之MQ
- 日期时间
- 'A previous installation of Qt5 Visual Studio Add-in was detected'解决方案
- [.net 面向对象编程基础] (15) 抽象类
- iOS中的单例
- 前端知识的一些总结
- TTL生存时间
- 摩托车继承自行车和机动车
- 5月底acm训练解题报告(简单字符串)
- 2-SAT问题