算法-查找(C++)

查找和排序硬件是计算机界基本的算法，毋容置疑。下面分析查找

定义：根据给定的某个值，在查找表中确定一个其关键字等于给定值的数据元素（或记录）。
 
　　查找分类：
　　1）静态查找和动态查找；
　　　　静态或者动态都是针对查找表而言的。动态表指查找表中有删除和插入操作的表。
　　2）无序查找和有序查找。
　　　　无序查找：被查找数列有序无序均可；
　　　　有序查找：被查找数列必须为有序数列。

　　平均查找长度（Average Search Length，ASL）：需和指定key进行比较的关键字的个数的期望值，称为查找算法在查找成功时的平均查找长度。
　　对于含有n个数据元素的查找表，查找成功的平均查找长度为：ASL = Pi*Ci的和。
　　Pi：查找表中第i个数据元素的概率。
　　Ci：找到第i个数据元素时已经比较过的次数

顺序查找

 顺序查找适合于存储结构为顺序存储或链接存储的线性表；
 思想：顺序查找也称为线形查找，属于无序查找算法。从数据结构线形表的一端开始，顺序扫描，依次将扫描到的结点关键字与给定值k相比较，若相等则表示查找成功；若扫描结束仍没有找到关键字等于k的结点，表示查找失败
分析：　
　　查找成功时的平均查找长度为：（假设每个数据元素的概率相等） ASL = 1/n(1+2+3+…+n) = (n+1)/2 ;
　　当查找不成功时，需要n+1次比较，时间复杂度为O(n);
　　所以，顺序查找的时间复杂度为O(n)。

     空间复杂度：无

顺序查找算法代码：

#include <iostream>
using namespace std;

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

int main()
{
  int a[5] = {10,20,30,40,50};
  int v1=SequenceSearch(a,30,5);
  cout<<v1;
}

二分查找

也称折半查找，前提是查找的序列有序，顾名思义，就是查找中间元素，对比，满足条件返回，否则查找另外两个序列。

复杂度分析：最坏情况下，关键词比较次数为log2(n+1)，且期望时间复杂度为O(log2n)

代码：

#include <iostream>
using namespace std;

int BinarySearch1(int array[],int value,int n)
{
  int low,high,mid;
  low=0;
  high=n-1;
  while(low<=high)
  {
    mid=(low+high)/2;
    if(array[mid]==value)
      return mid;
    else if(array[mid]<value)
      low=mid+1;
    else
      high=mid-1;
  }
  return -1;
}

int BinarySearch2(int array[],int value,int low,int high)
{
 // int mid=(low+high)/2;
  while(low<=high)
  {
  int mid=(high+low)/2;
  if(array[mid]=value)
    return mid;
  if(array[mid]<value)
    return BinarySearch2(array,value,mid+1,high);
  if(array[mid]>value)  
    return BinarySearch2(array,value,low,mid-1);
  }
}

int main()
{
  int a[5] = {10,20,30,40,50};
  int v1=BinarySearch1(a,20,5);
  int v2=BinarySearch2(a,20,0,4);
  cout<<v1<<endl;
  cout<<v2<<endl;
}

插值查找

折半查找比较傻瓜，每次都从一个序列的中间查找，但是可以更进一步选择更接近于数据的查找点，比如折半查找查找点每次是
mid=(low+high)/2=low+(high-low)/2=low+1/2*(high-low);优化后的差之差找为 mid=low+(key-array[low])/(array[high]-array[low])*(high-low)
对于表长较大，而关键字分布又比较均匀的查找表来说，插值查找算法的平均性能比折半查找要好的多。反之，数组中如果分布非常不均匀，那么插值查找未必是很合适的选择。

复杂度分析：查找成功或者失败的时间复杂度均为O(log2(log2n))

#include <iostream>
using namespace std;

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

int main()
{
  int a[5] = {10,20,30,40,50};
  int v=InsertionSearch(a,20,0,4);
  cout<<v<<endl;
}

斐波纳挈数列查找算法

在介绍斐波那契查找算法之前，我们先介绍一下很它紧密相连并且大家都熟知的一个概念——黄金分割。

　　黄金比例又称黄金分割，是指事物各部分间一定的数学比例关系，即将整体一分为二，较大部分与较小部分之比等于整体与较大部分之比，其比值约为1:0.618或1.618:1。

　　0.618被公认为最具有审美意义的比例数字，这个数值的作用不仅仅体现在诸如绘画、雕塑、音乐、建筑等艺术领域，而且在管理、工程设计等方面也有着不可忽视的作用。因此被称为黄金分割。

　　大家记不记得斐波那契数列：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 <string.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,10,24,30,41,59,66,78,88,99};
    int key=100;
    int index=FibonacciSearch(a,sizeof(a)/sizeof(int),key);
    cout<<key<<" is located at:"<<index;
    return 0;
}

待续。。