int Search(int d,int a[],int n) 
　　{ 
　　/*在数组a[]中查找等于d的元素，若找到，则函数返回d在数组中的位置，否则为0。其中n为数组长度*/ 
　　int i ； 
　　/*从后往前查找*/ 
　　for(i=0;i<n-1;i++){ 
    if(a[i] ==  d) 
    return i; 
//如果找到则返回d在数组的位置 
} 
　　return 0; 
　　/*如果找不到，则返回0*/ 
　　}

NO2.二分查找编辑

int binary_find(int *arr,int num,int value)   
{   
    if(NULL == arr || 0 == num)   
        return -1;  //如果要查找的数组为空，则返回-1 
       
    int start = 0;   
    int end = num - 1;   
   
    while(start <= end){   
        int middle = start +((end - start)  >> 1);   
        if(value == arr[middle])   
            return middle;   
        else if(value > arr[middle])   
            start = middle + 1;   
        else   
            end = middle - 1;   
    }   
    return -1;  //未找到值，返回-1 
}  

NO3.hash查找

typedef struct _NODE   
{   
    int data;   
    struct _NODE* next;   
}NODE;  

NODE* hash_find(NODE* arr[],int mod,int value)   
{  //arr为要查找的序列，mod为模值，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;   
}  

1.顺序查找：

从表的一端开始，顺序扫描线性表，依次将扫描到的节点关键字和给定值k相比较。

等概率条件下…平均查找长度：ASL = (n+….+2+1)/n= (n+1)/2；

2.二分法查找：

前提是线性表是有序表。假设数据是按升序排序的，对于给定值x，从序列的中间位置开始比较，如果当前位置值等于x，则查找成功；若x小于当前位置值，则在数列的前半段中查找；若x大于当前位置值则在数列的后半段中继续查找，直到找到为止。

在等概率条件下…平均查找长度：ASL = log2(n+1)-1= log2(n+1) 

原因：设内部结点的总数为n=2^n-1,则判定树是深度为h=log2(n+1)的满二叉树（深度为h不计内部结点）。树中第k层上的结点个数为2^(k-1),查找他们所需的比较次数是k.因此在等概率假设下，二分查找成功时的平均查找长度为：ASL约等于log2(n+1)-1

例 一有序表的关键字序列是（11，16，37，51，55，76，88，90，101，105）采用折半查找求其等概率情况下，查找成功的平均查找长度。

解 按照折半查找算法，对序列中10个元素的查找过程如下：

这棵二叉树又称为折半查找判定树。

从判定树上可知，查找某一个元素所要进行的比较次数等于该元素结点在判定树中的层数。故：
ASL ＝ （3＋2＋3＋4＋1＋3＋4＋2＋3＋4） /10 = 2.9
从上例可以看出，折半查找成功的平均查找长度与序列中的具体元素无关，只取决于序列中元素的数目。所以，折半查找判定树只与查找表中元素的数目有关。

下面就用常用的hash表处理冲突的两种方法来举例，虽然hash表处理冲突的方法有很多种，但是这两种是较为常用的方式：

  首先，你要明白的是平均查找长度求的是期望，那么你就按照求期望的方法来求平均查找长度吧，千万记着期望怎么求平均查找长度就怎么求啊。

  题目：

在地址空间为0~16的散列区中，对以下关键字序列构造两个哈希表：
{Jan, Feb, Mar, Apr, May,  June, July, Aug, Sep, Oct, Nov, Dec}
（1） 用线性探测开放地址法处理冲突；
（2） 用链地址法（开散列存储）处理冲突 
并分别求这两个哈希表在等概率情况下查找成功和查找不成功时的平均查找长度。设哈希函数为 
H(key) = i/2,其中i为关键字中第一个字母在字母表中的序号,如下：
A B C D E F G H I  J    K   L  M  N  O   P   Q   R  S  T   U   V   W  X  Y   Z
1 2 3 4  5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

  解决如下：

(1) 线性探测进入散列区的次序如下，X 代表冲突，要找下一个空格
Jan -> 5
Feb -> 3
Mar -> 6
Apr -> 0
May -> 6X -> 7
June -> 5X -> 6X -> 7X -> 8
July -> 5X -> 6X -> 7X -> 8X -> 9
Aug -> 0X -> 1
Sep -> 9X -> 10
Oct -> 7X -> 8X -> 9X -> 10X -> 11
Nov -> 7X -> 8X -> 9X -> 10X -> 11X -> 12
Dec -> 2

  很明显，查找成功时，查找Jan、Feb、Mar等仅需要一次，其余的也可以由上面看出来
  所以查找成功时平均查找长度 (ASL) = (1 + 1 + 1 + 1 + 2 + 4 + 5 + 2 + 2 + 5 + 6 + 1) / 12 = 31/12 = 2.58 为什么是除以12呢？因为查找成功的情况总共有12种啊

  查找不成功时呢？什么是查找不成功呢？查找不成功就是从查找位置开始直到一个位置为空需要比较的次数。

  首先，26/2=13，也就是说查找不成功的情况也只能出现在0~13之间，只有这14种情况。

  举个例子来说，查找Aay吧，根据hash表，与Apr比较不匹配，接着与Aug比较又是不匹配，接着与Dec比较又是不匹配，又与Feb比较又是不匹配，到了4位置的时候为空了，即4上内容与nullkey比较，结果为空，所以查找Aay失败，查找长度为5。同理也能计算其他的。

  最终平均查找失败时平均查找长度为（5+4+3+2+1+9+8+7+6+5+4+3+2+1）/14=60/14。注意啊，这里是除以14啊。（这是求期望的方法啊）

(2) 链地址法
0 之下有 Apr, Aug
2 之下有 Dec
3 之下有 Feb
5 之下有 Jan, June, July
6 之下有 Mar, May
7 之下有 Oct, Nov
9 之下有 Sep
查找成功时候，查 Apr, Dec, Feb, Jan, Mar, Oct, Sep 各需 1 次，查 Aug, June, May, Nov 各需 2 次，查 July 需 3 次。

所以查找成功时平均查找长度 (ASL) = (1 * 7 + 2 * 4 + 3 * 1) / 12 = 18/12 = 1.5

查找失败时平均查找长度：举个例子吧，查找Boy,2/2=1，而1的地方的指针为空，就不用比较就可以知道不存在，查找产度为0。查找Aay，与Apr比较不匹配，与Aug比较不匹配，同时，Aug指向下一个节点的指针为空，就可以知道查找失败，查找长度为2。

 所以查找失败的平均查找长度：（2+1+1+3+2+2+1）/14=12/14。