数据结构之查找

1，顺序查找:

时间复杂度：(1+…n)/n=(n+1)/2

int SequenceSearch(int a[], int value, int n)
{
    int i;
    for(i=0; i<n; i++)
        if(a[i]==value)
            return i;
    return -1;
}

2，折半查找：

时间复杂度：2^x = (n+1) —> log2(n+1)

//二分查找（折半查找），版本1
int BinarySearch1(int a[], int value, int n)
{
    int low, high, mid;
    low = 0;
    high = n-1;
    while(low<=high)
    {
        mid = (low+high)/2;
        if(a[mid]==value)
            return mid;
        if(a[mid]>value)
            high = mid-1;
        if(a[mid]<value)
            low = mid+1;
    }
    return -1;
}

//二分查找，递归版本
int BinarySearch2(int a[], int value, int low, int high)
{
    int mid = low+(high-low)/2;
    if(a[mid]==value)
        return mid;
    if(a[mid]>value)
        return BinarySearch2(a, value, low, mid-1);
    if(a[mid]<value)
        return BinarySearch2(a, value, mid+1, high);
}

3，插值查找
公式： 中间值确定：low+(value - a[low]) /(a[high]- a[low])*(high-low)
时间复杂度：log2(log2(n)

//插值查找
int InsertionSearch(int a[], int value, int low, int high)
{
    int mid = low+(value-a[low])/(a[high]-a[low])*(high-low);
    if(a[mid]==value)
        return mid;
    if(a[mid]>value)
        return InsertionSearch(a, value, low, mid-1);
    if(a[mid]<value)
        return InsertionSearch(a, value, mid+1, high);
}

4,斐波那契查找

大家记不记得斐波那契数列：1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89…….（从第三个数开始，后边每一个数都是前两个数的和）。然后我们会发现，随着斐波那契数列的递增，前后两个数的比值会越来越接近0.618。
　基本思想：也是二分查找的一种提升算法，通过运用黄金比例的概念在数列中选择查找点进行查找，提高查找效率。同样地，斐波那契查找也属于一种有序查找算法。
　　相对于折半查找，一般将待比较的key值与第mid=（low+high）/2位置的元素比较，比较结果分三种情况：
　　1）相等，mid位置的元素即为所求
　　2）>，low=mid+1;
3）<，high=mid-1。

斐波那契查找与折半查找很相似，他是根据斐波那契序列的特点对有序表进行分割的。他要求开始表中记录的个数为某个斐波那契数小1，及n=F(k)-1;

开始将k值与第F(k-1)位置的记录进行比较(及mid=low+F(k-1)-1),比较结果也分为三种
　　1）相等，mid位置的元素即为所求
　　2）>，low=mid+1,k-=2;
　　说明：low=mid+1说明待查找的元素在[mid+1,high]范围内，k-=2 说明范围[mid+1,high]内的元素个数为n-(F(k-1))= Fk-1-F(k-1)=Fk-F(k-1)-1=F(k-2)-1个，所以可以递归的应用斐波那契查找。
　　3）<，high=mid-1,k-=1。
　　说明：low=mid+1说明待查找的元素在[low,mid-1]范围内，k-=1 说明范围[low,mid-1]内的元素个数为F(k-1)-1个，所以可以递归 的应用斐波那契查找。
　　复杂度分析：最坏情况下，时间复杂度为O(log2n)，且其期望复杂度也为O(log2n)。

#include "stdafx.h"
#include <memory>
#include  <iostream>
using namespace std;

const int max_size=20;//斐波那契数组的长度

/*构造一个斐波那契数组*/ 
void Fibonacci(int * F)
{
    F[0]=0;
    F[1]=1;
    for(int i=2;i<max_size;++i)
        F[i]=F[i-1]+F[i-2];
}

/*定义斐波那契查找法*/  
int FibonacciSearch(int *a, int n, int key)  //a为要查找的数组,n为要查找的数组长度,key为要查找的关键字
{
  int low=0;
  int high=n-1;
  
  int F[max_size];
  Fibonacci(F);//构造一个斐波那契数组F 

  int k=0;
  while(n>F[k]-1)//计算n位于斐波那契数列的位置
      ++k;

  int  * temp;//将数组a扩展到F[k]-1的长度
  temp=new int [F[k]-1];
  memcpy(temp,a,n*sizeof(int));

  for(int i=n;i<F[k]-1;++i)
     temp[i]=a[n-1];
  
  while(low<=high)
  {
    int mid=low+F[k-1]-1;
    if(key<temp[mid])
    {
      high=mid-1;
      k-=1;
    }
    else if(key>temp[mid])
    {
     low=mid+1;
     k-=2;
    }
    else
    {
       if(mid<n)
           return mid; //若相等则说明mid即为查找到的位置
       else
           return n-1; //若mid>=n则说明是扩展的数值,返回n-1
    }
  }  
  delete [] temp;
  return -1;
}

int main()
{
    int a[] = {0,16,24,35,47,59,62,73,88,99};
    int key=100;
    int index=FibonacciSearch(a,sizeof(a)/sizeof(int),key);
    cout<<key<<" is located at:"<<index;
    return 0;
}

5，分块查找
分块：块中数字无序，但是整个块间要有序，前一个块的最大值必须比后一个块的最小值小
算法描述：首先确定在那个块中，其次在块中查找关键字。

#include <stdio.h>
struct number//结构体，定义每个分块中的数据结构，且每个分块的数据结构能相同
{
    int start; //块里面的起始数据
    int end; //块里面的末尾数据
    int key;  //块中最大值
}number_table[4];//结构体中这个分号一定要有。

int block(int key,int a[])
{
    int i,j;
    i=0;
    while( key>number_table[i].key  &&  i<4)//从一个块开始找（块间数据有序），可确定最后一个满足条件的块即是所求知道确定为哪个分的块中
        i++;
    if(i>4)
        return 0;
    j=number_table[i].start; //设置j为每个块中的首数据。
    while(key!=j && j<number_table[i].end)//在块中的什么位置。此时不能具体化为4.因为分块法最后一组不一定为4个
    {
        j++;
    }
    if(j>number_table[i].end)
        j=0;
    return j;
}

int main()
{
    int i,j,k;
    int iStars;

    int a[17];
    j=0;
    printf("please enter fifth numbers.\n");
    for(i=1;i<=16;i++)
    {
        scanf("%d",&a[i]);
    }
    //这个循环刚开始没写。
    for(i=1;i<=2;i++)//i的上限表示分组情况，但有个疑问为什么上限为2的时候依旧正确呢
    {
        number_table[i].start=j+1;//第一次循环 开始的下标为1     2循环，开始的下标为6
        j++;
        number_table[i].end=j+5;//第一次循环 结尾的下标为5 
        j=j+5;
        number_table[i].key=a[j];//限定了最大值为最后一位 为a[5].
    }
    printf("please enter the number that you want:\n");
    scanf("%d",&iStars);

    j=block(iStars,a);
    if(j==0)
        printf("Failed\n");
    else
        printf("success. the number on %d\n",j);
}

6，索引查找
索引表的类型可定义如下：

struct IndexItem
{
    IndexKeyType index;//IndexKeyType为事先定义的索引值类型
    int start;         //子表中第一个元素所在的下标位置
    int length;        //子表的长度
};
typedef struct IndexItem indexlist[ILMSize];//ILMSize为事先定义的整型常量，大于等于索引项数m

主表的类型可定义如下：

typedef struct ElemType mainlist[MaxSize];//MaxSize为事先定义的整型常量，大于等于主表中元素的个数n

注意：在索引表中的每个索引项对应多条记录，则称为稀疏索引，若每个索引项唯一对应一条记录，则称为稠密索引。

索引查找算法：
1，首先根据给定的索引值K1，在索引表上查找出索引值等于K1的索引项，以确定对应子表在主表中的开始位置和长度，然后再根据给定的关键字K2，在对应的子表中查找出关键字等于K2的元素。
2，设数组A是具有mainlist类型的一个主表，数组B是具有indexlist类型的在主表A上建立的一个索引表，m为索引表B的实际长度，即所含的索引项的个数，K1和K2分别为给定,带查找的索引值和关键字，并假定每个子表采用顺序存储，则索引查找的平均查找长度为：
ASL= (1+m)/2 + (1+s)/2 = 1 + (m+s)/2
索引查找算法为：

//利用主表A和大小为 m 的索引表B索引查找索引值为K1，关键字为K2的记录
int Indsch(mainlist A, indexlist B, int m, IndexKeyType K1, KeyType K2)
{ //返回该记录在主表中的下标位置，若查找失败则返回-1
    int i, j;
    for (i = 0; i < m; i++)
        if (K1 == B[i].index)
            break;
    if (i == m)
        return -1; //查找失败
    j = B[i].start;
    while (j < B[i].start + B[i].length)
    {
        if (K2 == A[j].key)
            break;
        else
            j++;
    }
    if (j < B[i].start + B[i].length)
        return j; //查找成功
    else
        return -1; //查找失败
}