查找算法(二分查找，插值查找，斐波那契查找)

二分查找

思路

1. 首先确定该数组中间的下标。 mid = (left + right) / 2
2. 然后让需要查找的数 findVal 和 arr[mid] 进行比较，
   如果findVal > arr[mid]，说明要查找的数在mid的右边，递归向右；
   如果findVal < arr[mid]，说明要查找的数在mid的左边，递归向左；
   如果findVal == arr[mid]，返回下标。
3. 结束条件 left > right 返回-1

代码

static int BinarySearch(int[] arr, int left, int right, int findVal)
{
    if (left > right)
        return -1;

    int mid = (left + right) / 2;
    int midVal = arr[mid];

    if (findVal > midVal)
        return BinarySearch(arr, mid + 1, right, findVal);
    else if (findVal < midVal)
        return BinarySearch(arr, left, mid - 1, findVal);
    else
        return mid;
}

插值查找

思路

1. 类似于二分查找，不同的是插值查找每次从自适应mid处开始查找。
2. low 代表左边索引，high代表右边索引，求mid的公式为
   mid = low+(high - low) * (key - arr[low]) / (arr[high] - arr[low])
   即通过值的差值来大致预测下标的插值。

代码

/// <summary>
/// 
/// </summary>
/// <param name="arr">数组</param>
/// <param name="left">左边索引</param>
/// <param name="right">右边索引</param>
/// <param name="findVal">带查找值</param>
/// <returns>返回查找到的下标,如果未查到返回-1</returns>
static int InsertValueSearch(int[] arr, int left, int right, int findVal)
{
    //findVal < arr[0] || findVal > arr[arr.Length - 1] 必须有，否则可能越界
    if (left > right || findVal < arr[0] || findVal > arr[arr.Length - 1])
        return -1;

    //求出mid
    int mid = left + (right - left) * (findVal - arr[left]) / (arr[right] - arr[left]);
    int midVal = arr[mid];

    if (findVal > midVal)
        return InsertValueSearch(arr, mid + 1, right, findVal);
    else if (findVal < midVal)
        return InsertValueSearch(arr, left, mid - 1, findVal);
    else
        return mid;
}

斐波那契查找(黄金分割法查找)

思路

1. 原理与前两种相似，仅仅改变了中间索引mid的位置，mid不再是中间或插值得到，而是位于黄金分割点附近，即 mid = low + F[k-1] -1 (F 代表斐波那契数列)。
2. 由斐波那契数列 F[k] = F[k-1] + F[k-2] 的性质可以得到， F[k]-1 = (F[k-1] -1) + (F[k-2] -1) +1，从而中间位置为 mid = low + F[k-1] -1
3. 类似的，每一子段也可以用相同的方式分割
4. 由于顺序表的长度不一定刚好等于 F[k] - 1，故需要将原来的顺序表长度 n 增加至 F[k]-1 这里的 k 只要能使 F[k]-1 恰好大于等于 n 即可，由一下代码得到新增长度后，新增的位置都赋予数组最后一个值即可。

while(n > fib[k] - 1)
{
	k++;
}

代码

//获取斐波那契数列
static int[] Fib()
{
	//maxSize = 20
    int[] f = new int[maxSize];
    f[0] = 1;
    f[1] = 1;
    for (int i = 2; i < maxSize; i++)
    {
        f[i] = f[i - 1] + f[i - 2];
    }
    return f;
}

//查找算法
/// <summary>
/// 
/// </summary>
/// <param name="arr"></param>
/// <param name="key">查找数</param>
/// <returns>返回下标</returns>
static int FibonacciSearch(int[] arr, int key)
{
    int low = 0;
    int high = arr.Length - 1;
    int k = 0;  //分割数值的下标
    int mid = 0;

    int[] f = Fib();

    //获取k
    while (high > f[k] - 1)
    {
        k++;
    }

    //用第一个大于等于数组长度的值作为一个新数组的长度
    int[] temp = new int[f[k]];
    arr.CopyTo(temp, 0);


    //将新数组中多余的部分全部填充成原数组最后一个值
    for (int i = high + 1; i < temp.Length; i++)
    {
        temp[i] = arr[high];
    }

    //查找key
    while (low <= high)
    {
        mid = low + f[k - 1] - 1;

        //key小于当前值,向左查找
        if (key < temp[mid])
        {
            high = mid - 1;

            //f(k) = f(k-1) + f(k-2)
            //前半部分的长度即f(k-1)
            k--;
        }
        else if (key > temp[mid])//key > 当前值，向右查找
        {
            low = mid + 1;
            k -= 2;
        }
        else
        {
            //如果mid值大于数组的最大索引,则返回最大索引
            if (mid <= high)
                return mid;
            else
                return high;
        }

    }

    return -1;
}