查找算法的比较

查找，最天真无邪的方法就是linearSearch：将给定的数组arr从头至尾扫描一遍

int linearSearch(int arr[],int n,int x)

{

    int i;

    for(i=0;i<n;i++)

    {

        if(x==arr[i])

            return i;

    }

    return -1;

}

毫无疑问，该算法的时间复杂度为O(n).

另外，倘若所给的是一个有序的数组arr，那么我们可以考虑折半查找：

1) 将待查找元素x与arr中间元素比较

2) 相等则返回index

3) 小于则抛弃右半部分

4) 大于则抛弃左半部分

 

这是递归实现的版本

int binarySearch(int arr[],int l,int r,int x)

{

    if(l<=r)

    {

        int mid=(l+r)/2;

        if(x==arr[mid])

        {

            return mid;

        }else if(x<arr[mid])

        {

            return binarySearch(arr,l,mid-1,x);

        }else{

            return binarySearch(arr,mid+1,r,x);

        }

    }

    return -1;

 }

这是循环迭代实现的版本

int binarySearch2(int arr[],int l,int r,int x)

{

    int mid;

    while(l<=r)

    {

        mid=(l+r)/2;

        if(x==arr[mid])

        {

            return mid;

        }else if(x<arr[mid])

        {

            r=mid-1;

        }else{

            l=mid+1;

        }

    }

    return -1;

}

 

折半查找的时间复杂度为O（Logn）.

 

还有一种内插搜索算法,它的平均时间复杂度为O(LogLogn)，但最坏情况是O(n).

int interpolationSearch(int arr[],int n,int x)

{

    int l=0;

    int r=n-1;

    int m;

    while(arr[r]!=arr[l]&&x>=arr[l]&&x<=arr[r])

    {

        m=l+((x-arr[l])*(r-l)/(arr[r]-arr[l]));   /*这里应该是数学家讨论的问题*/

        if(arr[m]<x)

        {

            l=m+1;

        }

        else if(x<arr[m])

        {

            r=m-1;

        }

        else

        {

            return m;

        }

    }

    if(x==arr[l])

    {

        return l;

    }

    else{

        return -1;

    }

}

<!--EndFragment-->