最快查找算法

㈠ 一个无序的数组，有什么高效的查找算法

无序的序列，如果只进行极少量的查找，最快也是最简单的算法是从顺序地扫描查找；
如果是大量地查找，先用快排排序，再用二分查找 ！

㈡ 最好的查找算法是什么

没有最好只有更好
对不同特征的数据也有不同的查找算法，所有的查找算法都是针对某一特征的数据进行优化的，比如用散列表查找很快的数据用二分发就不一定快，散列表用不同的哈希算法查找性能也大不相同。

㈢ 数据快速查找的算法(asp.net)

在要查询的字段上建立聚集索引，查询的字段越少，速度越快。

不要使用NOT关键字

㈣ 对100万个排好序的数，查找某一个数，最快的方法是什么，效率是多少

算法如下：根据快速排序划分的思想
(1) 递归对所有数据分成[a,b）b（b,d]两个区间，(b,d]区间内的数都是大于[a,b)区间内的数
(2) 对(b,d]重复(1)操作，直到最右边的区间个数小于100个。注意[a,b)区间不用划分
(3) 返回上一个区间，并返回此区间的数字数目。接着方法仍然是对上一区间的左边进行划分，分为[a2,b2）b2（b2,d2]两个区间，取（b2,d2]区间。如果个数不够，继续(3)操作，如果个数超过100的就重复1操作，直到最后右边只有100个数为止。
2.先取出前100个数，维护一个100个数的最小堆，遍历一遍剩余的元素，在此过程中维护堆就可以了。具体步骤如下：
step1：取前m个元素（例如m=100），建立一个小顶堆。保持一个小顶堆得性质的步骤，运行时间为O（lgm);建立一个小顶堆运行时间为m*O（lgm）=O(m lgm);
step2:顺序读取后续元素，直到结束。每次读取一个元素，如果该元素比堆顶元素小，直接丢弃
如果大于堆顶元素，则用该元素替换堆顶元素，然后保持最小堆性质。最坏情况是每次都需要替换掉堆顶的最小元素，因此需要维护堆的代价为(N-m)*O(lgm);
最后这个堆中的元素就是前最大的10W个。时间复杂度为O(N lgm）。
3.分块查找
先把100w个数分成100份，每份1w个数。先分别找出每1w个数里面的最大的数，然后比较。找出100个最大的数中的最大的数和最小的数，取最大数的这组的第二大的数，与最小的数比较。。。。

㈤ 各种查找算法的比较

二分法平均查找效率是O(logn)，但是需要数组是排序的。如果没有排过序，就只好先用O（nlogn)的预处理为它排个序了。而且它的插入比较困难，经常需要移动整个数组，所以动态的情况下比较慢。

哈希查找理想的插入和查找效率是O(1)，但条件是需要找到一个良好的散列函数，使得分配较为平均。另外，哈希表需要较大的空间，至少要比O(n)大几倍，否则产生冲突的概率很高。

二叉排序树查找也是O(logn)的，关键是插入值时需要做一些处理使得它较为平衡（否则容易出现轻重的不平衡，查找效率最坏会降到O(n)），而且写起来稍微麻烦一些，具体的算法你可以随便找一本介绍数据结构的书看看。当然，如果你用的是c语言，直接利用它的库类型map、multimap就可以了,它是用红黑树实现的，理论上插入、查找时间都是O(logn)，很方便，不过一般会比自己实现的二叉平衡树稍微慢一些。

㈥ C# 最快查找算法是那个

简单写了一下。其实用C++应该会更快，不存在生成新字符串的开销(比如下面对每一个单词都ToLower了一遍，因此会生成很多个新串).

static Dictionary<string, string> dict = new Dictionary<string, string>();

public static void InitDict()
{
dict.Add("yang", "YAng"); //将每个关键字都小写化，作为Dictionary的key。使用Dictionary可以在O(1)的时间内判断出单词是不是关键字
dict.Add("xu", "Xu");
//Add other key words...
}

public static string Replace(string content)
{
StringBuilder sb = new StringBuilder();
int start = 0, position = 0;
while (start < content.Length)
{
position = content.IndexOf(' ', start); // 假设文本只包含字母和空格，否则还需要考虑逗号句号等情况
if (position <= 0) //可能搜索到达了文本末端，而末端不是空格
{
position = content.Length; //取最后一个单词
}
string word = content.Substring(start, position - 1);
if (dict.ContainsKey(word.ToLower()))
{
sb.Append(dict[word.ToLower()]);
}
else
{
sb.Append(word);
}
sb.Append(' ');
start = position + 1;
}
return sb.ToString();
}
}

㈦ 怎样才能快速搜索路由表有哪些着名的搜索算法

有三个路由器，a，b和c。路由器a的两个网络接口f0和s0
分别连接在
10.1.0.0和10.2.0.0网段上；路由器b的两个网络接口s0和s1
分别连接在
10.2.0.0和10.3.0.0网段上；路由器c的两个网络接口s0和e0
分别连接在
10.3.0.0和10.4.0.0网段上；
如上图中各路由表的前两行所示，通过路由表的网络接口到与之直接相连的网
络的网络连接，其向量距离设置为0。这即是最初的路由表。
当路由器b和a以及b和c之间相互交换路由信息后，它们会更新各自的路由表。
例如，路由器b通过网络端口s1收到路由器c的路由信息（10.3.0.0,s0,0）和(10.4.0.0,e0,0)后，在自己的路由表中增加一条(10.4.0.0,s1,1)路由信息。该信息表示：通过路由器b的网络接
口s1可以访问到10.4.0.0网段，其向量距离为1,该向量距离是在路由器c的基础上加1获得的。
同样道理，路由器b还会产生一条(10.1.0.0,s0,1)路由，这条路由是通过网络端口s0从路由器a
获得的。如此反复，直到最终收敛，形成图中所示的路由表。
概括地说，距离向量算法要求每一个路由器把它的整个路由表发送给与它直接连接的其它路由
器。路由表中的每一条记录都包括目标逻辑地址、相应的网络接口和该条路由的向量距离。当一个路
由器从它的相邻处收到更新信息时，它会将更新信息与本身的路由表相比较。如果该路由器比较出一条
新路由或是找到一条比当前路由更好的路由时，它会对路由表进行更新：将从该路由器到邻居之间的
向量距离与更新信息中的向量距离相加作为新路由的向量距离。

㈧ 快速查找算法 具体文字描述 附java程序更好 拜托各位了

快速查找算法 有叫做二分发，前提是必须对有序数组中的元素进行递归查找， 首先假设目标在数组中中间位置，与中间位置比较，如大于，则重左侧开始查找，如小于，则右侧开始查找，这样每次查找都能排除当前的一半，

㈨ python快速查找算法应用实例

python快速查找算法应用实例
文实例讲述了Python快速查找算法的应用，分享给大家供大家参考。
具体实现方法如下：
import random
def partition(list_object,start,end):
random_choice = start
#random.choice(range(start,end+1))
#把这里的start改成random()效率会更高些
x = list_object[random_choice]
i = start
j = end
while True:
while list_object[i] < x and i < end:
i += 1
while list_object[j] > x:
j -= 1
if i >= j:
break
list_object[i],list_object[j] = list_object[j],list_object[i]
print list_object
#list_object[random_choice] = list_object[j]
#list_object[j] = random_choice
return j

def quick_sort(list_object,start,end):
if start < end:
temp = partition(list_object,start,end)
quick_sort(list_object,start,temp-1)
quick_sort(list_object,temp + 1 ,end)

a_list = [69,65,90,37,92,6,28,54]
quick_sort(a_list,0,7)
print a_list

程序测试环境为Python2.7.6

输出结果如下：

[54, 65, 28, 37, 6, 69, 92, 90]
[6, 37, 28, 54, 65, 69, 92, 90]
[6, 37, 28, 54, 65, 69, 92, 90]
[6, 28, 37, 54, 65, 69, 92, 90]
[6, 28, 37, 54, 65, 69, 90, 92]
[6, 28, 37, 54, 65, 69, 90, 92]

希望本文所述对大家的Python程序设计有所帮助。

㈩ 如何实现十几万条数据的最快查找

你说的是算法吧，具体是什么样的数据？
分几种情况：
1、只需要查找一次，那就直接遍历一次。
2、需要多次查找，查找次数可以与数据总数相比，那就可以先排序后二分查找（如果可排序的话）。也可以建立一个哈希表（如果是整数、字符串等等），实现O(1)的查找。
实际情况是，不需要你自己造轮子，多数编程语言有封装好的数据结构拿来直接用。比如C++ STL的 set 和 unordered_set 存储不重复的数据；map 和 unordered_map 存储有重复的数据（数据为键，出现次数为值），这都比你自己写要快。