数据查找算法---顺序查找、二分法查找、二叉树查找、hash查找

两个概念：
时间复杂度：与时间频度T(n)有关，时间频度就是一个算法中语句执行的次数，时间复杂度就是算法中语句执行次数函数（辅助函数f(n)）的函数，T(n)=O(f（n）)。时间频度不同，时间复杂度可能相同。
空间复杂度：就是一个算法运行所需的内存空间。

1.顺序查找
代码思路：我们并不知道要查找的数据在哪个位置，所以只能遍历这组n个数据，最少需要一次就可以查找成功，最多需要n次，平均下来需要（1+n）/2次，我们把这种比较次数和n成正比的算法时间复杂度记为O(n)。
代码:

#include <stdio.h>
#include <stdlib.h>
注意：在C语言中变量不能直接使用，必须先声明再使用；
int arraySortFind(int *array,int len,int num){
    int i;
    if(array != NULL && len != 0){
        for(i = 0;i < len;i++){
            if(array[i] == num){
                printf("第%d次找到了\n",i);
                return i;
            }       
        }
    }
}
int main(){
    int array[10] = {0,1,2,3,4,5,6,7,8,9};
    int num = arraySortFind(array,10,2);
    printf("找到的得数在数据的第%d位\n",num);
    getchar();
}

2.二分法查找
代码思路：在1024个数中找一个数如果用顺序查找的话最少需要一次最多需要1024次，这样代码的可执行时间太长，如果先将1024个数从中间分为两份，如果在第一份就去第一份继续从中间分为两份查找，一次继续。
代码：

#include<stdio.h>
#include<stdlib.h>


/*现有一组有序数从小到大，在其中查找一个数*/
int arrayDivisionFind(int *array,int num,int len){
    if(array != NULL && len != 0){
        int start = 0;
        int end = len;
        while(start < end){
            int mid = (start + end)/2;
            if(array[mid] == num){
                return mid;
            }
            else if(array[mid] > num){
                end = mid - 1;
            }
            else if(array[mid] < num){
                start = mid + 1;
            }
            else 
            {
                printf("数据输入有误，请重新输入");
            }
            }
            }
        }

注意：二分法适用于数据量大的有序数据查找。

3.二叉树查找
上面的查找是建立在连续内存基础之上的，那么如果是指针类型的数据呢？怎么办呢？那么就需要引入排序二叉树了。
排序二叉树的定义很简单：（1）非叶子节点至少一边的分支非NULL；（2）叶子节点左右分支都为NULL；（3）每一个节点记录一个数据，同时左分支的数据都小于右分支的数据。可以看看下面的定义：

typedef struct _NODE{  
    int data;  
    struct _NODE* left;  
    struct _NODE* right;  
}NODE; 

/*查询代码*/
NODE* binarytree_find(NODE* pNode,int value)  
{  
    if(NULL == pNode)  
        return NULL;  

    if(value == pNode->data)  
        return pNode;  
    else if(data < pNode->data)  
        return binarytree_find(pNode->left,value);  
    else  
        return binarytree_find(pNode->right,value);  
}  

4.hash排序
代码思路：
方法（2）、（3）都是建立在完全排序的基础上，那么在没有建立折中基础上的排序呢？就是hash表。
哈希表的定义如下：1）每个数据按照某种聚类运算归到某一大类，然后所有数据链成一个链表；2）所有链表的头指针形成一个指针数组。这种方法因为不需要完整排序，所以在处理中等规模数据的时候很有效。其中节点的定义如下：

typedef struct _NODE  
{  
    int data;  
    struct _NODE* next;  
}NODE; 
/*查询代码*/
NODE* hash_find(NODE* arr[],int mod,int value)  
{  
    int index= data % mod;  
    if(NULL == arr[index])  
        return NULL;  

    NODE* pNode = arr[index];  
    while(pNode){  
        if(value == pNode->data)  
            return pNode;  
        pNode = pNode->next;  
    }  
    return pNode;  
}  

分析：
hash表因为不需要排序，只进行简单的归类，在数据查找的时候特别方便。查找时间的大小取决于mod的大小。mod越小，那么hash查找就越接近于普通查找；那么hash越大呢，那么hash一次查找成功的概率就大大增加。