查找算法

注：后续，继续补充。

1）顺序查找

> 1.适用：顺序表，链表。
> 2.方式：在某一个数据集合中从第一个元素开始，依次向后查找。

例：设有一数据集合{3,2,5,8,4,7,6,9}给定某个关键字key,在数据集合中查找key对应的元素。

①顺序表
int Search(int data[],int n,int key)
{
    int tag=-1;
    for(int i=0;i<n && data[i]-key;i++);
    if(i!=n)
        tag=i;
    return tag;
}

②链表
ElemSN * Search(ElemSN *h,int key)
{
    ElemSN *p;
    for(p=h;p && p->data !=key;p=p->next);
    return p;
}

分析：
- 平均查找长度（ASL）=(1+n)/2
- 缺点：不适合海量数据集合。时间复杂度大。

---

---

2）二分查找

条件：经过排序的数据集合。只适合顺序储存的数据集合。

例：设数据集合data={5,7,12,25,34,37,43,46};查找关键字key.
二叉查找树：


如:key=34
①
- (0+7)/2=3
- D[3]=25<34

②
- (4+7)/3=5
- D[5]=37>34

③
- (4+4)/3=4
- D[4]=34=34
结论：二分查找会生成，二叉查找树，

①int HalfSearch(int data[],int low,int high,int key)
{
    int mid,result=-1;
    while(low<high)
    {
        mid=(low+high)/2;
        if(data[mid]>key)
        {
            high=mid;
        }
        else if(data[mid]<key)
        {
            low=mid;
        }
        else
        {
            result=mid;
            break;
        }
    }
    return result;
}
②递归
int HalfSearch(int data[],int low,int high,int key)
{
        if(low>high)
            return -1;
        int mid=(low+high)/2;
        if(data[mid]>key)
            return HalfSearch(data,low,mid,key);
        else if(data[mid]<key)
            return HalfSearch(data,mid,high,key);
        else
            return mid;
}

分析：
- 时间复杂度O(log2n)

---

---

3）散列查找（哈希查找）

散列函数：用来计算存储，数据元素地址的函数。 H(k)=k%m (除留余法)

例：散列长度13，数据集合{5，13，17，42，46，55，70，82，94}

①线性探查法
    5%13=5 ， 13%13=0 ， 17%13=4 ， 42%13=3 ， 46%13=7 ， 55%13=3，4，5，6
    70%13=5，6，7，8  82%13=4，5，6，7，8，9
    94%13=3，4，5，6，7，8，9，10

②拉链法
    5%13=5 ， 13%13=0 ， 17%13=4 ， 42%13=3 ， 46%13=7 ， 55%13=3
    70%13=5  82%13=4
    94%13=3

//拉链法
#include<stdio.h>
#include<stdlib.h>
#define len 10

typedef struct node{
    int data;
    struct node * next;
}ElemSN;
//创建哈希表
void CreatHash(int Data[],ElemSN **H)
{
    ElemSN *newp,*t;
    int k;
    for(int i=0;i<len;i++)
    {
        newp=(ElemSN*)malloc(sizeof(ElemSN));
        newp->data=Data[i];
        newp->next=NULL;
        k=Data[i]%len;

        for(t=H[k];t && t->next;t=t->next);
        {
            if(t)
                t->next=newp;
            else
                H[k]=newp;

        }
    }
}
//输出哈希表
void PrintHash(ElemSN **H)
{
    for(int i=0;i<len;i++)
    {
        for(ElemSN *p=H[i];p;p=p->next)
            printf("%5d",p->data);
        printf("\n");
    }
}
//哈希查找
ElemSN * FindHashKey(ElemSN **H,int key)
{
    int k=key%len;
    for(ElemSN *p=H[k];p && p->data-key;p=p->next);

    return p;
}
int main(void)
{
    int Data[len]={3,5,8,0,6,9,13,14,13,23};
    int k;
    //创建指针数组
    ElemSN **H;
    H=(ElemSN**)malloc(len*(sizeof(ElemSN*)));
    for(int i=0;i<len;H[i++]=NULL);
    //创建哈希表
    CreatHash(Data,H);
    //输出哈希表
    PrintHash(H);
    //哈希查找
    printf("输入key");
    ElemSN *resoult;
    scanf("%d",&k);
    resoult=FindHashKey(H,k);
    if(resoult)
        printf("%5d\n",resoult->data);
    else
        printf("no find\n");
    return 0;
}