查找

查找的算法主要有几种：二分查找，插入查找，斐波那契查找。注：所有的查找算法都是在有序数组中

二分查找：顾名思义，先从中间值开始查找，然后不断逼近，类似高中的二分法

二分查找完整代码如下：

 

public static int BinarySearch(int[] arr, int left, int right, int value)
        {
            if (left == right)
            {
                return -1;
            }
            int mid = (left + right) / 2;
            int midVal = arr[mid];
            if (value > midVal)
            {
                return BinarySearch(arr, mid + 1, right, value);
            }
            else if (value < midVal)
            {
                return BinarySearch(arr, left, mid - 1, value);
            }
            else
            {
                return mid;
            }
        }

 

二分查找还有个改进算法，可以找到重复的元素，代码如下：

 

public static List<int> BinarySearch2(int[] arr, int left, int right, int value)
        {
            if (left == right)
            {
                return new List<int>();
            }
            int mid = (left + right) / 2;
            int midVal = arr[mid];
            if (value > midVal)
            {
                return BinarySearch2(arr, mid + 1, right, value);
            }
            else if (value < midVal)
            {
                return BinarySearch2(arr, left, mid - 1, value);
            }
            else
            {
                List<int> list = new List<int>();
                list.Add(mid);
                int temp = mid - 1;
                while (true)
                {
                    //因为二分查找为有序数组 所以在arr[temp]!=value时之间跳出循环
                    if (temp < 0 || arr[temp] != value)
                    {
                        break;
                    }
                    list.Add(temp);
                    temp -= 1;
                }
                temp = mid + 1;
                while (true)
                {
                    if (temp > arr.Length - 1 || arr[temp] != value)
                    {
                        break;
                    }
                    list.Add(temp);
                    temp += 1;
                }
                return list;
            }
        }

 

 

插入查找也可以认为是二分查找的改进，其改进之处在于插入查找插入点不再是中点，而是随着查找值改变(自适应查找)

插入查找适用于均匀分布的数组，原因很简单 其本质是等比例缩放法 value/mid=arr[右]-arr[左]/arr.Length

插入查找完整代码如下：

 

public static int InsertSearch(int[] arr, int left, int right, int value)
        {
            if (left > right || value < arr[0] || value > arr[arr.Length - 1])
            {
                return -1;
            }
            int mid = left + (right - left) * (value - arr[left]) / (arr[right] - arr[left]);
            int midVal = arr[mid];
            if (value > midVal)
            {
                return InsertSearch(arr, mid + 1, right, value);
            }
            else if (value < midVal)
            {
                return InsertSearch(arr, left, mid - 1, value);
            }
            else
            {
                return mid;
            }
        }

 

斐波那契查找本质也和二分查找类似，其插入点是接近黄金分割点（虽然不知道有什么意义，但人家这么搞跟着搞就对了^^）

完整代码如下：

 //构建斐波那契数列
        public static int[] fib()
        {
            int[] f = new int[20];
            f[0] = 1;
            f[1] = 1;
            for (int i = 2; i < f.Length; i++)
            {
                f[i] = f[i - 1] + f[i - 2];
            }
            return f;
        }

        public static int fibSearch(int[] a, int key)
        {
            int low = 0;
            int high = a.Length - 1;
            int k = 0;//表示斐波那契分割数值的下标
            int mid = 0;//存放mid值
            int[] f = fib();
            //获取到斐波那契分割数值的下标
            while (high > f[k] - 1)
            {
                k++;
            }
            //因为k值可能大于a长度 构建一个数组temp 将a的值全部放入temp 不足用0补
            int[] temp = new int[f[k]];
            a.CopyTo(temp, 0);
            //实际中用a最后的元素填充temp的0部分
            for (int i = high + 1; i < temp.Length; i++)
            {
                temp[i] = a[high];
            }
            //用while循环处理 
            while (low <= high)
            {
                mid = low + f[k - 1] - 1;
                //如果要找到的值在左边
                if (key < temp[mid])
                {
                    high = mid - 1;
                    //f[k]=f[k-1]+f[k-2] 左边数组为f[k-1] 该数组斐波那契为f[k-1]=f[k-2]+f[k-3]
                    k--;
                }
                else if (key > temp[mid])//要找的值在右边
                {
                    low = mid + 1;
                    k -= 2;
                }
                else //要找的值就是mid 因为是在temp中找的 可能长度大于a.length 所以返回小一点的
                {
                    if (mid <= high)//没有超出a
                    {
                        return mid;
                    }
                    else//超出了a
                    {
                        return high;
                    }
                }
            }
            //找不到 返回-1
            return -1;
        }