查詢功能是資料處理的一個基本功能。資料查詢並不複雜，但是如何實現資料又快又好地查詢呢？前人在實踐中積累的一些方法，值得我們好好學些一下。我們假定查詢的資料唯一存在，陣列中沒有重複的資料存在。

（1）順序查詢（普通的資料查詢）          

        設想有一個1M的資料，我們如何在裡面找到我們想要的那個資料。此時資料本身沒有特徵，所以我們需要的那個資料可能出現在陣列的各個位置，可能在資料的開頭位置，也可能在資料的結束位置。這種性質要求我們必須對資料進行遍歷之後才能獲取到對應的資料。

1. int find(int *arr,int num,int value)  
2. {  
3.     if
   (NULL == arr || 0 == num)  
4.         return -1;  
5.     for(int index = 0;index < num;index++){  
6.         if(value == arr[index])  
7.             return index;  
8.     }  
9.     return -1;  
10. }  

分析與總結：
         由於我們不清楚這個資料判斷究竟需要多少次。但是，我們知道，這樣一個數據查詢最少需要1次，那麼最多需要n次，平均下來可以看成是（1+n）/2，差不多是n的一半。我們把這種比較次數和n成正比的演算法時間複雜度記為o（n）。
(2)二分法查詢                                                    上面的資料沒有任何特徵，這導致我們的資料排列地雜亂無章。試想一下，如果資料排列地非常整齊，那結果會是什麼樣的呢？就像在生活中，如果平時不注意收拾整齊，那麼找東西的時候非常麻煩，效率很低；但是一旦東西放的位置固定下來，所有東西都歸類放好，那麼結果就不一樣了，我們就會形成思維定勢，這樣查詢東西的效率就會非常高。
             那麼，對一個有序的陣列，我們應該怎麼查詢呢？二分法就是最好的方法。

1. int binary_find(int *arr,int num,
   int value)  
2. {  
3.     if(NULL == arr || 0 == num)  
4.         return -1;  
5.     int start = 0;  
6.     int end = num - 1;  
7.     while(start <= end){  
8.         int middle = start +((end - start)  >> 1);  
9.         if(value == arr[middle])  
10.             return middle;  
11.         elseif(value > arr[middle])  
12.             start = middle + 1;  
13.         else
14.             end = middle - 1;  
15.     }  
16.     return -1;  
17. }  

分析：
    上面我們說到普通的資料查詢演算法複雜度是o（n），那麼我們可以用上面一樣的方法判斷一下演算法複雜度。這種方法最少是1次，那麼最多需要多少次呢？我們發現最多需要log（n+1）/log（2）即可。大家可以找個例子自己算一下，比如說7個數據，我們發現最多3次；如果是15個數據呢，那麼最多4次，以此類推。明顯，這種資料查詢的效率要比前面的查詢方法高很多。優點：效率高，時間複雜度為O(logN)；缺點：資料要是有序的，順序儲存。

（3）二叉樹查詢                                              上面的查詢是建立在連續記憶體基礎之上的，那麼如果是指標型別的資料呢？怎麼辦呢？那麼就需要引入排序二叉樹了。         排序二叉樹的定義很簡單：（1）非葉子節點至少一邊的分支非NULL；（2）葉子節點左右分支都為NULL；（3）每一個節點記錄一個數據，同時左分支的資料都小於右分支的資料。可以看看下面的定義：

1. typedefstruct _NODE{  
2.     int data;  
3.     struct _NODE* left;  
4.     struct _NODE* right;  
5. }NODE;  

程式碼：

1. NODE* binarytree_find(NODE* pNode,int value)  
2. {  
3.     if(NULL == pNode)  
4.         return NULL;  
5.     if(value == pNode->data)  
6.         return pNode;  
7.     elseif(data < pNode->data)  
8.         return binarytree_find(pNode->left,value);  
9.     else
10.         return binarytree_find(pNode->right,value);  
11. }  

（4）hash排序                                                方法（2）、（3）都是建立在完全排序的基礎上，那麼在沒有建立折中基礎上的排序呢？就是hash表。         雜湊表的定義如下：1）每個資料按照某種聚類運算歸到某一大類，然後所有資料鏈成一個連結串列；2）所有連結串列的頭指標形成一個指標陣列。這種方法因為不需要完整排序，所以在處理中等規模資料的時候很有效。其中節點的定義如下：

1. typedefstruct _NODE  
2. {  
3.     int data;  
4.     struct _NODE* next;  
5. }NODE;  

查詢程式碼：

1. NODE* hash_find(NODE* arr[],int mod,int value)  
2. {  
3.     int index= data % mod;  
4.     if(NULL == arr[index])  
5.         return NULL;  
6.     NODE* pNode = arr[index];  
7.     while(pNode){  
8.         if(value == pNode->data)  
9.             return pNode;  
10.         pNode = pNode->next;  
11.     }  
12.     return pNode;  
13. }  

分析：
      hash表因為不需要排序，只進行簡單的歸類，在資料查詢的時候特別方便。查詢時間的大小取決於mod的大小。mod越小，那麼hash查詢就越接近於普通查詢；那麼hash越大呢，那麼hash一次查詢成功的概率就大大增加。