请教算法

[bto310]

问题描述:
现有一有序数列｛-56，-23，0，8，10，12，26，38，65，98｝,给定一特定值37，求该序列中等于该值，或小于该值并最接近该值的数。如上面的结果就是26。
大家有什么思路?

[bto310]

请详细说明，谢谢。

[pkd]

#include <iostream.h>

int main(int argc, char* argv[])
{
int num[] = {-56, -23, 0, 8, 10, 12, 26, 38, 65, 98 };
int count = sizeof(num) / sizeof(int);
int value_to_find = 37;
int index = 0;
unsigned int last_diff = value_to_find - num[0];
unsigned int now_diff ;
for(int i = 0;i<count; ++i){
now_diff = value_to_find - num[i] ;
if(now_diff < last_diff){
index = i;
if(num[i] == value_to_find) break;
}
}
cout<<"The "<< index << "th number : "<< num[index] << " match your case! \n";
return 0;
}

[jp1984]

二叉搜索树效率比较高O(n*logn)
直接做两次遍历即可效率O(n^2)

[pkd]

我的算法是O(N),还有更小的吗？

[zengwujun]

#include <iostream>
using namespace std;

void main()
{
int num[] = {-56, -23, 0, 8, 10, 12, 26, 38, 65, 98 };
int nLen = sizeof(num) / sizeof(int);
int value = 37;

int left=0,right=nLen-1;
int index;

while(left<=right)
{
index=(left+right)/2;
if(value == num[index])
break;
else
if(value<num[index])
right=index-1;
else
if(num[index+1]>value)
break;
else
left=index+1;
}
cout<<index<<endl;
}

二分查找，O(logn)

[zengwujun]

再给个统计比较次数的
#include <iostream>
using namespace std;

void main()
{
int nCount=0;//统计次数
int num[] = {-56, -23, 0, 8, 10, 12, 26, 38, 65, 98 };
int nLen = sizeof(num) / sizeof(int);
int value = 37;

int left=0,right=nLen-1;
int index;

while(left<=right)
{
index=(left+right)/2;
if(value == num[index])
{
nCount++;
break;
}
else
{
if(value<num[index])
{
nCount++;
right=index-1;
}
else
{
if(num[index+1]>value)
{
nCount++;
break;
}
else
{
nCount++;
left=index+1;
}
}
}
}
cout<<index<<','<<nCount<<endl;
}

[Yaka]

用二杈樹!

[arrowcy]

其实就是对这个序列中的每个数减去那个特定值37后求绝对值，然后求这个绝对值的最小值就可以了
这个算法就是O(N)的。另外由于要求是小于37，所以在每次找到一个更小的值的时候都判断一下是大于还是小于，大于就不管就行了

[chenyec]

我看这个是有序表！
while ( value < a[i] ) {
if ( value == a[i] ) return a[i];
i++;
}
return a[i-1];

[MagicCarmack]

如果是有序数组，就用二分法比较高效！

无序数组就有些复杂！

[xiaohaiyan]

无序数组可以用quickselect, 算法效率O(n*logn )

[gofor]

直接用二分法查找特定值，如果最后比较的元素不比它大，则就是该元素，否则就是其前面一个元素。算法复杂度O(logN)。