最快查找演算法

㈠ 一個無序的數組，有什麼高效的查找演算法

無序的序列，如果只進行極少量的查找，最快也是最簡單的演算法是從順序地掃描查找；
如果是大量地查找，先用快排排序，再用二分查找 ！

㈡ 最好的查找演算法是什麼

沒有最好只有更好
對不同特徵的數據也有不同的查找演算法，所有的查找演算法都是針對某一特徵的數據進行優化的，比如用散列表查找很快的數據用二分發就不一定快，散列表用不同的哈希演算法查找性能也大不相同。

㈢ 數據快速查找的演算法(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 存儲有重復的數據（數據為鍵，出現次數為值），這都比你自己寫要快。