查找算法学习笔记

折半查找

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

 

//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;

        }