本文作者:心月

斐波那契查找算法解析

心月IT博客 2019-02-27
摘要:相對于二分查找和差值查找,斐波那契查找的實現略顯復雜。但是在明白它的主體思想之后,掌握起來也并不太難。 既然叫斐波那契查找,首先得弄明白什么是斐波那契數列。相信大家對這個著名的數列也并不陌生,無論是C語言的循環、遞歸,還是高數的數列,斐波那契數列都是一個重要的存在。

相對于二分查找和差值查找,斐波那契查找的實現略顯復雜。但是在明白它的主體思想之后,掌握起來也并不太難。

既然叫斐波那契查找,首先得弄明白什么是斐波那契數列。相信大家對這個著名的數列也并不陌生,無論是C語言的循環、遞歸,還是高數的數列,斐波那契數列都是一個重要的存在。而此處主要是用到了它的一條性質:前一個數除以相鄰的后一個數,比值無限接近黃金分割。

就筆者而言,這種查找的精髓在于采用最接近查找長度的斐波那契數值來確定拆分點,初次接觸的童鞋,請在讀完下文后,自覺回過頭來仔細體會這句話。舉個例子來講,現有長度為9的數組,要對它進行拆分,對應的斐波那契數列(長度先隨便取,只要最大數大于9即可){1,1,2,3,5,8,13,21,34},不難發現,大于9且最接近9的斐波那契數值是f[6]=13,為了滿足所謂的黃金分割,所以它的第一個拆分點應該就是f[6]的前一個值f[5]=8,即待查找數組array的第8個數,對應到下標就是array[7],依次類推。

推演到一般情況,假設有待查找數組array[n]和斐波那契數組F[k],并且n滿足n>=F[k]-1&&n < F[k+1]-1,則它的第一個拆分點middle=F[k]-1。

這里得注意,如果n剛好等于F[k]-1,待查找數組剛好拆成F[k-1]和F[k-2]兩部分,那萬事大吉你好我好;然而大多數情況并不能盡人意,n會小于F[k]-1,這時候可以拆成完整F[k-1]和殘疾的F[k-2]兩部分,那怎么辦呢?

聰明的前輩們早已想好了解決辦法,對了,就是補齊,用最大的數來填充F[k-2]的殘缺部分,如果查找的位置落到補齊的部分,那就可以確定要找的那個數就是最后一個最大的了。

不妨來看張圖,更清楚一點。
斐波那契查找算法解析

條件:

(1)數據必須采用順序存儲結構;(2)數據必須有序。

原理:

(1)最接近查找長度的斐波那契值來確定拆分點;(2)黃金分割。

時間復雜度:

與拆半查找一樣,也是logn。不少博客說,在處理海量數據時,拆分查找的middle = (low + hight)/2,除法可能會影響效率,而斐波那契的middle = low + F[k-1] -1,純加減計算,速度要快一些。我覺得是扯淡,因為完全可以用middle = (loe+hight)>>2來代替,要知道相比于加減乘除而言,位運算的效率可是最高的喲。

實現:

還是慣例,能上代碼就不說話環節。
public class FbonacciSearch {

    /**
     * <p>name: main</p>
     * <p>description: </p>
     * <p>return: void</p>
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array = { 1, 5, 15, 22, 25, 31, 39, 42, 47, 49, 59, 68, 88, 88,
                88, 88, 88 };
        System.out.println("result: " + fbSearch(array, 31));
    }

    /**
     * <p>
     * name: fbSearch
     * </p>
     * <p>
     * description: 斐波那契查找實現
     * </p>
     * <p>
     * return: int
     * </p>
     */
    public static int fbSearch(int[] array, int a) {
        if (array == null || array.length == 0) {
            return -1;
        } else {
            int length = array.length;
            int[] fb = makeFbArray(20);// 制造一個長度為10的斐波數列
            int k = 0;
            while (length > fb[k] - 1) {// 找出數組的長度在斐波數列(減1)中的位置,將決定如何拆分
                k++;
            }
            int[] temp = Arrays.copyOf(array, fb[k] - 1);// 構造一個長度為fb[k] - 1的新數列
            for (int i = length; i < temp.length; i++) {
                if (i >= length) {
                    temp[i] = array[length - 1];
                }
            }
            int low = 0;
            int hight = array.length - 1;
            while (low <= hight) {
                int middle = low + fb[k - 1] - 1;
                if (temp[middle] > a) {
                    hight = middle - 1;
                    k = k - 1;
                } else if (temp[middle] < a) {
                    low = middle + 1;
                    k = k - 2;
                } else {
                    if (middle <= hight) {
                        return middle;// 若相等則說明mid即為查找到的位置
                    } else {
                        return hight;// middle的值已經大于hight,進入擴展數組的填充部分,即最后一個數就是要查找的數。
                    }
                }
            }
            return -1;
            // return recurse(array, fb, a, low, hight, k);
        }
    }

    /**
     * <p>
     * name: makeFbArray
     * </p>
     * <p>
     * description: 生成指定長度的斐波數列
     * </p>
     * <p>
     * return: int[]
     * </p>
     */
    public static int[] makeFbArray(int length) {
        int[] array = null;
        if (length > 2) {
            array = new int[length];
            array[0] = 1;
            array[1] = 1;
            for (int i = 2; i < length; i++) {
                array[i] = array[i - 1] + array[i - 2];
            }
        }
        return array;
    }

    /**
     * <p>
     * name: recurse
     * </p>
     * <p>
     * description: 遞歸實現,可以來代替while (low <= hight)遍歷
     * </p>
     * <p>
     * return: int
     * </p>
     */
    public static int recurse(int[] array, int[] fb, int a, int low, int hight,
            int k) {
        if (array == null || array.length == 0 || a < array[low]
                || a > array[hight] || low > hight) {
            return -1;
        }
        int middle = low + fb[k - 1] - 1;
        if (a < array[middle]) {
            return recurse(array, fb, a, low, middle - 1, k - 1);
        } else if (a > array[middle]) {
            return recurse(array, fb, a, middle + 1, hight, k - 2);
        } else {
            if (middle <= hight) {
                return middle;
            } else {
                return hight;
            }
        }
    }
}

 

文章版權及轉載聲明:

作者:心月 本文地址:http://www.eojird.tw/algorithm/143.html發布于 2019-07-01
文章轉載或復制請以超鏈接形式并注明出處心月IT博客

分享到:
贊(

發表評論

快捷輸入:

    評論列表 (有 0 條評論,人圍觀)參與討論