数据结构 插值查找 斐波那契查找

数据结构 插值查找 斐波那契查找

二分查找(折半查找):
1、它属于有序查找算法, 元素必须是有序的，如果是无序的则要先进行排序操作。
2、基本思想：
用给定值k先与中间结点的关键字比较，中间结点把线形表分成两个子表，若相等则查找成功；若不相等，再根据k与该中间结点关键字的比较结果确定下一步查找哪个子表，
这样递归进行，直到查找到或查找结束发现表中没有这样的结点。
3、复杂度分析：
最坏情况下，关键词比较次数为log2(n+1)，且期望时间复杂度为O(log2n)；

插值查找算法：
1、基于二分查找算法，属于有序查找，它将查找点的选择改进为自适应选择，从而提高查找效率
二分查找的查找点计算：
mid=(low+high)/2
插值查找的查找点：
mid=low+(key-a[low])/(a[high]-a[low])*(high-low)
它根据关键字在整个有序表中所处的位置，让mid值的变化更靠近关键字key，间接地减少了比较次数，提高查找效率。
2、插值查找算法适合于表长较大，而关键字分布又比较均匀的查找表
3、复杂度分析：
查找成功或者失败的时间复杂度均为O(log2(log2n))

斐波那契数列(递归方法定义)：
数学定义上满足F(1)=1，F(2)=1，F(n)=F(n-1)+F(n-2) （n>=2）—从第三个数开始，后边每一个数都是前两个数的和，该数列越往后相邻的两个数的比值越趋向于黄金比例值（0.618）的数列。

斐波那契查找：
它与二分查找相似（是二分查找的一种提升算法），也属于一种有序查找算法，它是根据斐波那契序列的特点对有序表进行分割的，通过在数列中选择查找点进行查找，提高查找效率。

算法思想：
在斐波那契数列找一个等于略大于查找表中元素个数的数F[k]，将原查找表扩展为长度为Fk，完成后进行斐波那契分割，
即F[k]个元素分割为前半部分F[k-1]个元素，后半部分F[k-2]个元素，找出要查找的元素在那一部分并递归，直到找到该元素。

算法描述：
开始将key值与第F(k-1)位置的记录进行比较(即mid=low+F(k-1)-1),比较结果也分为三种
1、key == 查找表a[mid]，mid位置的元素即为所求
2、key > 查找表a[mid]，low=mid+1,k-=2;
　 low=mid+1说明待查找的元素在[mid+1,high]范围内，k-=2 说明范围[mid+1,high]内的元素个数为n-(F(k-1))= Fk-1-F(k-1)=Fk-F(k-1)-1=F(k-2)-1个，可递归应用斐波那契查找。
3、key < 查找表a[mid]，high=mid-1,k-=1。
　 low=mid+1说明待查找的元素在[low,mid-1]范围内，k-=1 说明范围[low,mid-1]内的元素个数为F(k-1)-1个，可递归应用斐波那契查找。

复杂度分析：
最坏情况下，时间复杂度为O(log2n)，且其期望复杂度也为O(log2n)

public class fbsearch {    public final static int MAXSIZE = 10;    public static boolean runFlag = true;    //斐波那契数列    public static int[] fibonacci() {        int[] f = new int[10];        int i = 0;        f[0] = 1;        f[1] = 1;        for (i = 2; i < MAXSIZE; i++) {            f[i] = f[i - 1] + f[i - 2];         }        return f;    }    public static int fibonacciSearch(int[] data, int key) {        int low = 0;        int high = data.length - 1;        int mid = 0;        int k = 0;  // 斐波那契分割数值下标        int i = 0;          int[] f = fibonacci(); // 构造查找所需的斐波那契数列        // 获取斐波那契分割数值下标        while (data.length > f[k] - 1) {             k++;        }        int[] temp = new int[f[k] - 1]; // 创建临时扩展表        for (int j = 0; j < data.length; j++) {            temp[j] = data[j];        }        // 补充表满足表长度等于f[k] - 1        for (i = data.length; i < f[k] - 1; i++) {            temp[i] = temp[high];  // 以原表的最后一个元素的值扩充表        }        if(runFlag){            runFlag = false;            System.out.print("斐波那契 数列：\n");            for (int j : f) {                System.out.print(j + " ");            }            System.out.println();            System.out.println("查找表：");            for (int j : data) {                System.out.print(j + " ");            }            System.out.println();            System.out.println("扩充后查找表：");            for (int j : temp) {                System.out.print(j + " ");            }            System.out.println();        }        // 表的全部元素 = 表的前半部分 + 表的后半部分        // f[k] = f[k-1] + f[k-2]        while (low <= high) {            mid = low + f[k - 1] - 1; //获取表的中间点            if (temp[mid] > key) {//查找前半部分f[k-1]                high = mid - 1;                k = k - 1; //更新斐波那契数列k            } else if (temp[mid] < key) {//查找后半部分f[k-2]                low = mid + 1;                k = k - 2; //更新斐波那契数列k            } else {                // 如果为真则找到相应的位置                if (mid <= high) {                    return mid;                } else {                    // 查找到补充的元素，返回high位置的元素                    return high;                }            }        }        return -1;    }    //二分查找, 非递归版本    public static int BinarySearch1(int a[], int value, int n)    {        int low, high, mid;        low = 0;        high = n-1;        while(low<=high)        {            mid = (low+high)/2;            if(a[mid]==value)                return mid;            if(a[mid]>value)                high = mid-1;            if(a[mid]<value)                low = mid+1;        }        return -1;    }    //二分查找，递归版本    public static int BinarySearch2(int a[], int value, int low, int high)    {        int mid = low+(high-low)/2;        if(a[mid]==value)            return mid;        if(a[mid]>value)            return BinarySearch2(a, value, low, mid-1);        if(a[mid]<value)            return BinarySearch2(a, value, mid+1, high);        return mid;    }    //插值查找    public static int InsertionSearch(int a[], int value, int low, int high)    {        int mid = low+(value-a[low])/(a[high]-a[low])*(high-low);        if(a[mid]==value)            return mid;        if(a[mid]>value)            return InsertionSearch(a, value, low, mid-1);        if(a[mid]<value)            return InsertionSearch(a, value, mid+1, high);        return mid;    }    public static void main(String[] args) {        // TODO Auto-generated method stub        int[] data = { 5, 15, 22, 25, 31, 39, 42, 45 };        int search = 31;        System.out.println("查找表：");        for (int j : data) {            System.out.print(j + " ");        }        System.out.println();        int position = InsertionSearch(data, search, 0, data.length-1);        System.out.println("插值查找：" + search + " 该元素的位置：" + position);        System.out.println();        position = fibonacciSearch(data, search);        System.out.println("斐波那契查找：" + search + " 该元素的位置：" + position);        search = 55;        position = fibonacciSearch(data, search);        System.out.println("斐波那契查找：" + search + " 该元素的位置：" + position);    }}

程序输出：

查找表：
5 15 22 25 31 39 42 45
插值查找：31 该元素的位置：4

斐波那契 数列：
1 1 2 3 5 8 13 21 34 55
查找表：
5 15 22 25 31 39 42 45
扩充后查找表：
5 15 22 25 31 39 42 45 45 45 45 45
斐波那契查找：31 该元素的位置：4
斐波那契查找：55 该元素的位置：-1