查找算法总结

1.   顺序查找算法

      优点：算法简单且对结构无任何要求。无论是用向量还是用链表来存放结点，而且不管结点之间是否有序，它都同样适用

      缺点：查找效率低，因此，当数据量较大时不宜采用顺序查找

      实现：

  1 //顺序查找算法
  2 #include<stdio.h>
  3 int search(int *a,int n,int x)
  4 {
  5         int i,f=-1;
  6         for(i=0;i<n;i++)
  7         {
  8                 if(x==a[i])
  9                 {
 10                         f=i+1;
 11                         break;
 12                 }
 13         }
 14         return f;
 15 }
 16 int main()
 17 {
 18         int a[10];
 19         int i,x;
 20         int n;
 21         printf("请输入10个数：\n");
 22         for(i=0;i<10;i++)
 23                 scanf("%d",&a[i]);
 24         printf("请输入要查找的数： ");
 25         scanf("%d",&x);
 26         n=search(a,10,x);
 27         if(n<0)
 28                 printf("没有你要找的数，你要找的数可能不在数组中。\n");
 29         else
 30                 printf("你要找的数%d在数组中第%d个元素处。\n",x,n);
 31         return 0;
 32 }

2.     折半查找算法

        折半查找是一种高效的查找算法，可以明显的减少比较的次数，提高查找效率，但是，折半查找的先决条件是查找表中的数据元素必须是有序的。

  1 //折半查找算法
  2 #include<stdio.h>
  3 int search(int *a,int n,int x)
  4 {
  5         int low,mid,high;
  6         low=0;
  7         high=n-1;
  8         while(low<=high)
  9         {
 10                 mid=(low+high)/2;
 11                 if(a[mid]==x)
 12                         return mid+1;
 13                 else if(a[mid]>x)
 14                         high=mid-1;
 15                 else
 16                         low=mid+1;
 17         }
 18         return -1;
 19 }
 20 int main()
 21 {
 22         int a[10];
 23         int i,x,n;
 24         printf("请输入10个有序数：\n");
 25         for(i=0;i<10;i++)
 26                 scanf("%d",&a[i]);
 27         printf("请输入你要查找的数： ");
 28         scanf("%d",&x);
 29         n=search(a,10,x);
 30         if(n<0)
 31                 printf("你要查找的数%d不在数组中！\n",x);
 32         else
 33                 printf("你要查找的数%d在数组中的位置是第%d个元素\n",x,n);
 34         return 0;
 35 }

3.         分块查找算法：

            又称索引查找，是介于顺序查找和折半查找之间的查找算法，是顺序查找算法的一种改进算法。

            分块查找算法的描述是将n个数据元素“按块有序”划分为m块（m<=n）。每一块中的结点不必有序，但块与块之间必须“按块有序”；即第一块中任意元素的关键字都必须小于第二块中任意元素的关键字；而第二块中任意元素的关键字又都必须小于第三块中任意元素的关键字.......

            操作步骤：先取各块中的最大关键字构成一个索引表。查找分为两部分，先对索引表进行二分查找或顺序查找，以确定待查记录在哪一块中。然后，在已确定的块中用顺序查找

  1 //分块查找算法
  2 #include<stdio.h>
  3 struct //定义块的结构
  4 {
  5         int key;
  6         int start;
  7         int end;
  8 }inde[4];
  9 
 10 int search(int *a,int key)
 11 {
 12         int i,j;
 13         i=0;
 14         while(i<3&&key>inde[i].key)//确定在哪个块中
 15                 i++;
 16         if(i>=3)
 17                 return -1;
 18         j=inde[i].start;
 19         while(j<inde[i].end&&a[j]!=key)
 20                 j++;
 21         if(j>inde[i].end)
 22                 return -1;
 23         return j;
 24 }
 25 
 26 int main()
 27 {
 28         int i,j=-1;
 29         int k,key;
 30         int a[]={42,63,82,89,111,146,219,254,325,336,348,795,876,951,998};
 31         printf("已知有一组数组：\n");
 32         for(i=0;i<15;i++)
 33                 printf("%d ",a[i]);
 34         printf("\n");
 35         for(i=0;i<3;i++)
 36         {
 37                 inde[i].start=j+1;//确定每个块范围的起始值
 38                 j=j+1;
 39                 inde[i].end=j+4;//确定每个块范围的结束值
 40                 j=j+4;
 41                 inde[i].key=a[j];//确定每个块范围中元素的最大值
 42         }
 43         printf("请输入你想要查找的数： ");
 44         scanf("%d",&key);
 45         k=search(a,key);
 46         if(k<0)
 47                 printf("查找失败，你要找的数不在数组中。\n");
 48         else
 49                 printf("查找成功，你要找的数%d在数组中的位置是第%d个元素\n",key,k+1);
 50         return 0;
 51 }

4.        哈希查找算法

           哈希查找是使用给定数据构造哈希表，然后在哈希表上进行查找的一种算法。

  1 //哈希查找算法
  2 #include<stdio.h>
  3 #include<malloc.h>
  4 #define MAX 10
  5 //定义查找的结点元素
  6 typedef struct
  7 {
  8         int num;
  9         char name[20];
 10 }ElemType;
 11 //定义哈希表
 12 typedef struct
 13 {
 14         ElemType *elem;
 15         int count;
 16         int sizeindex;
 17 }HashTable;
 18 //定义哈希函数
 19 int Hash(int num)
 20 {
 21         int p;
 22         p=num%5;
 23         return p;
 24 }
 25 //创建哈希表
 26 void InitHash(HashTable *H)
 27 {
 28         int i;
 29         H->elem=(ElemType*)malloc(MAX*sizeof(ElemType));
 30         H->count=0;
 31         H->sizeindex=MAX;
 32         for(i=0;i<MAX;i++)
 33                 H->elem[i].num=0;//初始化，使SearHash()函数能判断到底有没有元素在里面
 34 }
 35 //查找函数
 36 int SearHash(HashTable H,int key,int *p)
 37 {
 38         int c=0;
 39         *p=Hash(key);
 40         while(H.elem[*p].num!=key&&H.elem[*p].num!=0)//通过二次探测再散列解决冲突
 41         {
 42                 c=c+1;
 43                 if(c%2==1)
 44                         *p=*p+(c+1)*(c+1)/4;
 45                 else
 46                         *p=*p-(c*c)/4;
 47         }
 48         if(H.elem[*p].num==key)
 49                 return 1;
 50         else
 51                 return 0;
 52 }
 53 //插入函数
 54 void InsertHash(HashTable *H,ElemType e)//如果找不到就插入元素
 55 {
 56         int p;
 57         SearHash(*H,e.num,&p);
 58         H->elem[p]=e;
 59         ++H->count;
 60 }
 61 int main()
 62 {
 63         HashTable H;
 64         int p,key,i;
 65         ElemType e;
 66         InitHash(&H);
 67         for(i=0;i<3;i++)
 68         {
 69                 loop:printf("输入第%d个学生的学号\n",i+1);
 70                 scanf("%d",&e.num);
 71                 if(!SearHash(H,e.num,&p))
 72                 {
 73                         printf("输入第%d个学生的姓名\n",i+1);
 74                         scanf("%s",e.name);
 75                         InsertHash(&H,e);
 76                 }
 77                 else
 78                 {
 79                         printf("该学号已经存在\n");
 80                         goto loop;
 81                 }
 82         }
 83         printf("请输入你要查找的学生学号:\n");
 84         scanf("%d",&key);
 85         if(SearHash(H,key,&p))
 86         {
 87                 printf("查找成功！学生的姓名是%s\n",H.elem[p].name);
 88                 printf("学生所在表中的位置是%d\n",p);
 89         }
 90         else
 91                 printf("查找失败！你要查找的学生不存在！\n");
 92         return 0;
 93 }