常用查找算法总结

1、顺序查找

时间复杂度：O(n)
优点：算法简单，对查找表的记录没有任何要求
缺点：效率低下
适用：数据量较少时的查找

原理：

在一个已知无(或有序）序队列中找出与给定关键字相同的数的具体位置。原理是让关键字与队列中的数从最后一个开始逐个比较，直到找出与给定关键字相同的数为止。

int SequenceSearch(int *array, int size, int key)
{
    int i;

    for(i=0; i<size; i++)
    {
        if(array[i]==key)
        {
            return i;
        }
    }

    return -1;
}

int SequenceSearch(int *array, int size, int key)
{
    int i=size-1;
    array[0]=key;   //哨兵

    while(key != array[i])
    {
        i--;
    }

    return i;
}

2、二分查找/折半查找

时间复杂度：O(logn)
优点：比较次数少，查找速度快，平均性能好；
缺点：要求待查表为有序表，且插入删除困难。
适用：折半查找方法适用于不经常变动而查找频繁的有序列表。

原理：
首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

int BinarySearch(int *array, int size, int key)
{
    int first,last,middle;

    first=0;
    last =size;

    while(first<=last)
    {
        middle = (first+last)/2;

        if(array[middle] < key)
            first=middle+1;
        else if(array[middle] > key)
            last=middle-1;
        else
            return middle;
    }

    return -1;
}

3、插值查找

时间复杂度：O(logn)

适用：数据量较大，而关键字分布又比较均匀的查找表

原理：

英汉字典中寻找单词“worst”，我们决不会仿照对半查找那样，先查找字典中间的元素，然后查找字典四分之三处的元素等等. 事实上，我们是在所期望的地址(在字典的很靠后的地方)附近开始查找的。

int InsertSearch(int *array, int size, int key)
{
    int first,last,position;

    first=0;
    last =size-1;

    while(first<=last)
    {
        position = first+ (last-first)*(key-array[first])/(array[last]-array[first]);

        if(array[position] < key)
            first=position+1;
        else if(array[position] > key)
            last=position-1;
        else
            return position;
    }

    return -1;
}

4、斐波那契查找

时间复杂度：O(logn)
优点：平均性能要比折半查找好；
缺点：要求待查找的查找表必须顺序存储并且有序，且需满足条件：如果一个有序表的元素个数为n，并且n正好是（某个斐波那契数-1),时，才能用斐波那契查找法。

原理：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int F[100];

int FibonacciSearch(int *a,int n,int key)
{
    int low,high,mid,i,k=0;
    low=1;    /* 定义最低下标为记录首位 */
    high=n;    /* 定义最高下标为记录末位 */
    while(n>F[k]-1)
        k++;
    for (i=n;i<F[k]-1;i++)
        a[i]=a[n];

    while(low<=high)
    {
        mid=low+F[k-1]-1;
        if (key<a[mid])
        {
            high=mid-1;
            k=k-1;
        }
        else if (key>a[mid])
        {
            low=mid+1;
            k=k-2;
        }
        else
        {
            if (mid<=n)
                return mid;        /* 若相等则说明mid即为查找到的位置 */
            else
                return n;
        }

    }

    return -1;
}

int main()
{
    int i;
    int arr[]={0,1,16,24,35,47,59,62,73,88,99};

    F[0]=0;
    F[1]=1;
    for(i = 2;i < 100;i++)
    {
        F[i] = F[i-1] + F[i-2];
    }

    printf("%d
", FibonacciSearch(arr,sizeof(arr)/sizeof(int)-1,99));

    return 0;
}

5、哈希查找

时间复杂度：O(1)

适用：数据本身是无法排序、无法比较

原理：

通过记录数据元素与存储地址的关系，直接定位数据元素的一种方法。

#include "stdio.h"    
#include "stdlib.h"   
#include "io.h"  
#include "math.h"  
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 100 /* 存储空间初始分配量 */

#define SUCCESS 1
#define UNSUCCESS 0
#define HASHSIZE 12 /* 定义散列表长为数组的长度 */
#define NULLKEY -32768 

typedef int Status;    /* Status是函数的类型,其值是函数结果状态代码，如OK等 */ 

typedef struct
{
   int *elem; /* 数据元素存储基址，动态分配数组 */
   int count; /*  当前数据元素个数 */
}HashTable;

int m=0; /* 散列表表长，全局变量 */

/* 初始化散列表 */
Status InitHashTable(HashTable *H)
{
    int i;
    m=HASHSIZE;
    H->count=m;
    H->elem=(int *)malloc(m*sizeof(int));
    for(i=0;i<m;i++)
        H->elem[i]=NULLKEY; 
    return OK;
}

/* 散列函数 */
int Hash(int key)
{
    return key % m; /* 除留余数法 */
}

/* 插入关键字进散列表 */
void InsertHash(HashTable *H,int key)
{
    int addr = Hash(key); /* 求散列地址 */
    while (H->elem[addr] != NULLKEY) /* 如果不为空，则冲突 */
    {
        addr = (addr+1) % m; /* 开放定址法的线性探测 */
    }
    H->elem[addr] = key; /* 直到有空位后插入关键字 */
}

/* 散列表查找关键字 */
Status SearchHash(HashTable H,int key,int *addr)
{
    *addr = Hash(key);  /* 求散列地址 */
    while(H.elem[*addr] != key) /* 如果不为空，则冲突 */
    {
        *addr = (*addr+1) % m; /* 开放定址法的线性探测 */
        if (H.elem[*addr] == NULLKEY || *addr == Hash(key)) /* 如果循环回到原点 */
            return UNSUCCESS;    /* 则说明关键字不存在 */
    }
    return SUCCESS;
}

int main()
{
    int arr[HASHSIZE]={12,67,56,16,25,37,22,29,15,47,48,34};
    int i,p,key,result;
    HashTable H;

    key=39;

    InitHashTable(&H);
    for(i=0;i<m;i++)
         InsertHash(&H,arr[i]);
    
    result=SearchHash(H,key,&p);
    if (result)
        printf("查找 %d 的地址为：%d 
",key,p);
    else
        printf("查找 %d 失败。
",key);

    for(i=0;i<m;i++)
    {
        key=arr[i];
        SearchHash(H,key,&p);
        printf("查找 %d 的地址为：%d 
",key,p);
    }

    return 0;
}