折半查找算法的使用中防止溢出的问题

维基上的代码:

int binary_search(int A[], int key, int imin, int imax)
{
  // continue searching while [imin,imax] is not empty
  while (imax >= imin)
    {
      // calculate the midpoint for roughly equal partition
      int imid = midpoint(imin, imax);
      if(A[imid] == key)
        // key found at index imid
        return imid;
      // determine which subarray to search
      else if (A[imid] < key)
        // change min index to search upper subarray
        imin = imid + 1;
      else
        // change max index to search lower subarray
        imax = imid - 1;
    }
  // key was not found
  return KEY_NOT_FOUND;
}

下面使用了两个算法。


int binary_search()
{
    int size ;
    char keys[] = "9290";
    char words[][6] ={"1","2","21","22","222","3","5","66","90","900","91","929"};
	size = sizeof(words) / sizeof(words[0]);
	printf("第一个算法 sizeof = %d\n", size);
    int head    = 0;
    int tail    = size;
	int cursor = (head + tail) / 2;
	int result = 999;
	int count = 0;
	printf("keys= \"%s\"\n", keys);
	printf("words[i][] = \n");
	for (int i = 0; i < size; ++i) printf("[%d]=\"%s\" ", i, words[i]);

    do
    {
        result = strcmp(keys, words[cursor]);
		printf("\ncount = %d  cursor = %d head = %d , tail = %d , \n", count++ ,cursor, head, tail);
		printf("words[%d] = \"%s\" , result = %d \n\n ", cursor, words[cursor] ,result);
        if(result > 0)
        {
            head = cursor;
        }
        else if (result < 0)
        {
            tail = cursor;
        }
		else
		{
			break;//找到匹配的key按键组合
		}
		cursor = (head + tail) / 2;

    }
    while((head < cursor) && (cursor <= tail)); //((head <= cursor) && (cursor < tail))

	printf("\n------------------\ncursor = %d head = %d , tail = %d , \n", cursor, head, tail);
	printf("words[%d] = \"%s\" , result = %d \n\n", cursor, words[cursor], result);

	printf("====================\n");

	int left = 0, right = size - 1, middle = 0; //, result = 0;

	count = 0;
	printf("第二个算法 sizeof = %d\n", size);
	printf("keys= \"%s\"\n", keys);
	printf("words[i][] = \n");
	for (int i = 0; i < size; ++i) printf("[%d]=\"%s\" ", i, words[i]);

	printf("\nmiddle = %d, left = %d , right = %d , \n", middle, left, right);
	while (left <= right)
	{
		middle = (left + right) >> 1;
		result = strcmp(keys, words[middle]);
		printf("count = %d middle = %d, left = %d , right = %d , \n", count++, middle , left, right);
		printf("words[%d] = \"%s\" , result = %d \n\n", middle , words[middle], result);
		if (result > 0)
		{
			left = middle + 1;
		}
		else if (result < 0) right = middle - 1;
		else break;
	}
	printf("---------------------\nmiddle = %d, left = %d , right = %d , \n", middle, left, right);
	printf("words[%d] = \"%s\" , result = %d \n ", middle , words[middle], result);

    return cursor;

}

第一个算法 sizeof = 12

keys= "9290"

words[i][] =

[0]="1" [1]="2" [2]="21" [3]="22" [4]="222" [5]="3" [6]="5" [7]="66" [8]="90" [9

]="900" [10]="91" [11]="929"

count = 0  cursor = 6 head = 0 , tail = 12 ,

words[6] = "5" , result = 1

count = 1  cursor = 9 head = 6 , tail = 12 ,

words[9] = "900" , result = 1

count = 2  cursor = 10 head = 9 , tail = 12 ,

words[10] = "91" , result = 1

count = 3  cursor = 11 head = 10 , tail = 12 ,

words[11] = "929" , result = 1

------------------

cursor = 11 head = 11 , tail = 12 ,

words[11] = "929" , result = 1

====================

第二个算法 sizeof = 12

keys= "9290"

words[i][] =

[0]="1" [1]="2" [2]="21" [3]="22" [4]="222" [5]="3" [6]="5" [7]="66" [8]="90" [9

]="900" [10]="91" [11]="929"

middle = 0, left = 0 , right = 12 ,

count = 0 middle = 6, left = 0 , right = 12 ,

words[6] = "5" , result = 1

count = 1 middle = 9, left = 7 , right = 12 ,

words[9] = "900" , result = 1

count = 2 middle = 11, left = 10 , right = 12 ,

words[11] = "929" , result = 1

---------------------

middle = 12, left = 12 , right = 12 ,

words[12] = "烫烫烫烫9290" , result = 1

请按任意键继续. . .

忙于工作,有机会再研究效率的问题。

时间: 2024-08-02 06:17:56

折半查找算法的使用中防止溢出的问题的相关文章

java 二分查找 - 折半查找算法

二分查找: 这个算法是比较简单的,容易理解的.这个算法是对有序的数组进行查找,所以想要使用这个算法那么 首先先要对数组进行排序. 其实有三个指针,开始指针,末尾指针,中间指针,来开始.折半查找. 步骤如下: 1.确定三个指针,start,end,middleIndex. 2.判断start<=end,如果满足,就执行这个方法,不满足,就返回,找不到. 3.在2的前提下,我们对其折半查找,middleIndex = start+end >> 1,取中间值. 4.判断中间位置的值和目标值是否

二分查找/折半查找算法

二分查找又称折半查找,优点是比较次数少,查找速度快,平均性能好:其缺点是要求待查表为有序表,且插入删除困难.因此,折半查找方法适用于不经常变动而查找频繁的有序列表.首先,假设表中元素是按升序排列,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功:否则利用中间位置记录将表分成前.后两个子表,如果中间位置记录的关键字大于查找关键字,则进一步查找前一子表,否则进一步查找后一子表.重复以上过程,直到找到满足条件的记录,使查找成功,或直到子表不存在为止,此时查找不成功. class Pr

折半查找算法实现

折半查找是一种比较高效的查找方式,其基本思想是:在某个有序表中,取出中间的记录作为比较对象,如果要查找记录的关键码等于中间记录的关键码,则查找成功:若要查找记录的关键码小于中间记录的关键码,则在中间记录的左半区继续查找:若查找记录的关键码大于中间记录的关键码,则在中间记录的右半区继续查找.不断重复上述查找过程,直到查找成功,或有序表没有所要查找的记录,查找失败.实现过程有两种方式递归法和非递归法. 1.非递归法:查找成功则返回位置,查找失败则范围-1. /////////////////////

折半查找算法

package algorithm; public class BinarySearch { public static int search(int a[], int key) {        int low = 0;         int high = a.length - 1;        int mid = 0;        while (low <= high) {            mid = (low + high)/2;            if (a[mid] =

算法:顺序查找与折半查找

资料摘自:<数据结构c++语言描述> typedef int DataType; //顺序查找算法 //用顺序查找在n元数组list中查找与key等值的元素,返回该数组元素的下标 //若未找到,则返回-1 int SeqSearch(DataType List[], int n, DataType key) { for(int i = 0; i < n; i++) { if(List[i] == key) { return i; } } return -1; } /* *顺序查找的复杂度

程序员,你应该知道的二分查找算法

原理 二分查找(Binary Search)算法,也叫折半查找算法.二分查找的思想非常简单,有点类似分治的思想.二分查找针对的是一个有序的数据集合,每次都通过跟区间的中间元素对比,将待查找的区间缩小为之前的一半,直到找到要查找的元素,或者区间被缩小为 0. 为了方便理解,我们以数组1, 2, 4, 5, 6, 7, 9, 12, 15, 19, 23, 26, 29, 34, 39,在数组中查找26为例,制作了一张查找过程图,其中low标示左下标,high标示右下标,mid标示中间值下标 二分查

快速排序及折半查找

数据结构与算法---快速排序及折半查找: 1)编程实现数据序列的输入2)实现快速排序算法,并对输入的序列排序后输出: 3)实现折半查找算法,并在步骤(2)排序后的序列上,进行任意地查找,并输出查询结果.(查找成功/不成功:等于关键值的元素个数=1或>1) 1 #include <stdio.h> 2 #define N 100 3 4 //快速排序算法并输出 5 void Quick_Partition(double *r, int i, int j) 6 { 7 double x =

查找与排序02,折半查找

折半查找,也叫二分查找,当在一个数组或集合中查找某个元素时,先定位出中间位置元素,如果要查找的元素正好和该中间位置元素相等,通过一次查找,就能找到匹配元素:如果要查找的元素小于该中间位置元素,就抛弃后面一半的元素,在前面一半的元素中再定位出中间位置元素,如此反复,直到找到匹配元素:如果要查找的元素大于该中间位置元素,就抛弃前面一半的元素,在后面一半的元素中定位出中间位置元素,如此反复. 面临的第一个问题是:中间位置元素如何定位?在折半查找中规定:当元素个数是奇数,比如有3个元素,中间位置元素是索

对分查找法(二分查找法,折半查找法)

二分查找法是针对已经排好序的序列进行查找 每次折半查找 算法时间复杂度,对于长度为N的序列,每次执行N/2,假设k次结束,最后到第一个N/2^k=0,所以k=logN 时间复杂度logN int binarysearch(const int array[], int x, int N) { int low, mid, high; low = 0, high = N - 1; while (low <= high) { mid = (low + high) / 2; if(array[mid] <