查找算法学习笔记

折半查找

基本过程：在有序表中取中间记录作为比较对象，若给定值与中间记录的关键字相等，则查找成功；若给定值小于中间记录的关键字，则在中间记录的左半区继续查找；若给定值大于中间记录的关键字，则在中间记录的右半区继续查找。不断重复上述过程，直到查找成功，或所有查找区域无记录，查找失败为止。

 

//arr为待查找的数组，key为要查找的关键字，low和high为需要查找的数组下标的范围        public static int find1(int[] arr, int key, int low, int high)        {            if (arr != null && arr.Length > 0)            {                if ((low >= 0 && low <= arr.Length - 1) && (high >= low && high <= arr.Length - 1))                {                    int mid;                    while (low <= high)                    {                        mid = (low + high) / 2;                        if (key < arr[mid])                        {                            high = mid - 1;                        }                        else if (key > arr[mid])                        {                            low = mid + 1;                        }                        else                        {                            return mid;                        }                    }                }            }            return -1;        }

 

插值查找

基本思想：如果一个有序的序列是均匀分布的，那么待查找的关键字的位置就可以计算出来，首先用待查找范围的最大值减去待查找范围的最小值，然后除以这个范围的大小，即为每个单位之间的差值（即两个相邻元素之间的差值），然后用待查找的关键字减去待查找范围的最小值，然后用这个差值除以每个单位之间的差值，即为元素的位置，适用于待查找元素的分布较均匀的情况

        public static int find2(int[] arr, int key, int low, int high)        {            if (arr != null && arr.Length > 0)            {                int mid = 0;                if ((low >= 0 && low <= arr.Length - 1) && (high >= low && high <= arr.Length - 1))                {                    while (low <= high)                    {                        if (arr[high] > arr[low]) //防止除零异常                           {                            mid = low + (key - arr[low]) * ((high - low) / (arr[high] - arr[low]));                                               }                        else if (arr[low] == arr[high] && arr[low] == key)                        {                            return low;                        }                        if (key < arr[mid])                        {                            high = mid - 1;                        }                        else if (key > arr[mid])                        {                            low = mid + 1;                        }                        else                        {                            return mid;                        }                    }                }            }            return -1;        }

 

斐波那契查找

说明：该算法同样要求待查找的序列有序，要想使用该算法，待查找序列的长度必须等于某个可以进行黄金分割的长度值，若不等于，则需要对序列的长度补齐；该算法需要用到斐波那契数列，该数列的特点是长度越长前一项与后一项的比值越接近黄金分割点

下面是一个斐波那契数列{1,1,2,3,5,8,13,21}，如果一个待查找序列的长度为13，那么这个序列的第一个黄金分割点的位置就为8，如果待查找序列的长度不等于斐波那契数列中的某个值，则需要向后补齐

 //参数为待查找序列的长度        //该方法用于根据待查找序列的长度生成斐波那契数组        public static List<int> productF(int len)        {            List<int> list = new List<int>();            list.Add(1);            list.Add(1);            while (len > list[list.Count - 1])            {                int n1 = list[list.Count - 2];                int n2 = list[list.Count - 1];                list.Add(n1 + n2);            }            return list;        }

        public static int find3(List<int> list, int key)        {            if (list != null && list.Count > 0)            {                int mid = 0, low = 0, k = 0;                int len = list.Count;                int high = len - 1;                List<int> listF = productF(len);                while (len > listF[k]) //寻找能够构成黄金分割的斐波那契数组的下标，目的是把数组的长度补到能够进行黄金分割的长度                {                    k++;                }                for (int i = list.Count; i < listF[k]; i++)                {                    list.Add(list[len - 1]); //补齐                }                while (low <= high)                {                    mid = low + listF[k - 1] - 1; //listF[k-1]即为list的黄金分割点的长度，因为下标从0开始所以减1后才为list黄金分割点的正确位置                    if (key < list[mid])                    {                        k--;                        high = mid - 1;                    }                    else if (key > list[mid])                    {                        low = mid + 1;                        k = k - 2;                    }                 else  //查找成功                    {                        if (mid <= len - 1) //位于原始长度之间                        {                            return mid;                        }                        else //位于不起长度之间,因此返回返回原始长度的最后一个位置                        {                            return len - 1;                        }                    }                }            }            return -1;        }