[算法]java实现 二分查找 斐波那契数列 静静思考

最新推荐文章于 2023-01-18 15:40:28 发布
最新推荐文章于 2023-01-18 15:40:28 发布
阅读量1k 收藏 1
点赞数 1
分类专栏： 算法(初学) 文章标签： 斐波那契数列 伪代码 二分查找 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cook2eat/article/details/46523341
版权

问题提出

Binary search with addition and subtraction (probleme@ldc.ro, 2004)[1]
You are given a sorted array A[1..N], and you want to search for a given element. But you may only use additions and subtractions, and O(1) memory. Can you obtain O(lgN) running time?

在给定的无重复升序序列中，查找某个具体元素，只能使用加法和减法以及常数级别的内存，能否提供O(lgN)的解法？

思考过程

先排除只能使用加法和减法的条件——观察二分查找

输入数据是一个升序序列，可以使用直观简单的二分查找，本质上就是不断将数组5、5对半切开。

int BinarySearch(int key,int[] a)
{
    int lo = 0;
    int hi = a.length -1;
    int mid = 0;
    while(lo<hi){
        mid = lo+(hi-lo)/2; // 除法运算
        if(key<a[mid]) hi = mid -1;
        else if(key>a[mid]) lo = mid +1;
        else return mid; //查找到返回元素坐标
    }
    return -1;//没有查到返回-1
}

再加入只能使用加法和减法的限制——斐波那契查找

斐波那契数列：0 1 1 2 3 5 8 13 21 34 55 89 144...
最新一项等于前两项之和，F(X)=F(X-1)+F(X-2)随着项数不断增大，前一项与后一项的比值越来越逼近黄金分割0.618.[2]
可以想象成， 如果用斐波那契数列来分割数组，每一刀就是4、6开。

数值演示

先用一组精心准备的特殊数组来演示一下利用斐波那契数列查找的具体过程

int[] a = new int[22];
for(int i=0;i<22;i++) a[i] = i;

int max_value_of_a = a[a.length-1] = 21;


//int[] a = {0,1,2,3,4,5,6,7, 8, 9, 10,11,12,13,14,15,16,17,18,19,20,21};
//int[] F = {0,1,1,2,3,5,8,13,21,34,55,89,144,...};
// [ , ] Search Area
// Try to find number : 1
Start : 1 ?
Search:
max_value_of_a = F(8) = 21      
    [0,F(8)] = [0,F(6)+F(7)] = [0,8+13]     1 < F(6)    =8  
    [0,F(6)] = [0,F(4)+F(5)] = [0,3+ 5]     1 < F(4) =3 
    [0,F(4)] = [0,F(2)+F(3)] = [0,1+ 1]     1 = F(2) =1   break;

End: 1 Yes.

// Try to find number : 20
Start ：20 ?
Search:
max_value_of_a = F(8) = 21  
                        [ 0,F(8)] = [ 0,F(6)+F(7)] = [ 0, 8+ 13] = [ 0,21]
20 >    F(6)= 8         [ 0+F(6), 0+F(6)+F(7)] = [ 0 + 8, 0+ 8+13] = [ 8,21] = [8,  8+F(7)]=[ 8, 8+F(5)+F(6)]
20 >  8+F(5)= 8+5=13    [ 8+F(5), 8+F(5)+F(6)] = [ 8 + 5, 8+ 5+ 8] = [13,21] = [13,13+F(6)]=[13,13+F(4)+F(5)]
20 > 13+F(4)=13+3=16    [13+F(4),13+F(4)+F(5)] = [13 + 3,13+ 3+ 5] = [16,21] = [16,16+F(5)]=[16,16+F(3)+F(4)]
20 > 16+F(3)=16+2=18    [16+F(3),16+F(3)+F(4)] = [16 + 2,16+ 2+ 3] = [18,21] = [18,18+F(4)]=[18,18+F(2)+F(3)]
20 > 18+F(2)=18+1=19    [19+F(2),19+F(2)+F(3)] = [19 + 1,19+ 1+ 2] = [19,21] = [19,19+F(3)]=[19,19+F(1)+F(2)]
20 = 19+F(1)=19+1=20            break;    

End: 20 Yes.

//Try to find number: 4
Start: 4?
Search:
max_value_of_a = F(8) = 21      
    [0,F(8)]    = [0,F(6)+F(7)] = [0, 8+13]         4 < F(6)    =8 
    [0,F(6)]    = [0,F(4)+F(5)] = [0, 3+ 5]         4 > F(4)    =3
    [0+3,0+3+5] = [3,3+5]   = [3,3+F(3)+F(4)]   4 < 3+F(3)  =5
    [3,3+F(4)]  = [3,3+1+2] = [3,3+F(2)+F(3)]   4 = 3+F(2)  =4 break；           

End: 4 Yes.

代码排版可能错位辅助以下图片

查找数值1 一路朝着数组左边（更小的一侧）切过去

1

查找数值2 一路朝着数组右边（更大的一侧）切过去

2

查找数值3 先左再右

3

演示说明

算法本质

  • 斐波那契数列F(x) 的值在运算时承担的是数组下标的职责；
  • 每一个斐波那契数列中的数其实本质上最终都可以拆成若干个F(0)、F(1)的组合，这意味着利用这些数是可以遍历整个数组的下标（算法本质）

可行性

  • 二分既可以理解成不断对分，也可以理解成不对半，只要切下去就可以了，最终只会剩下一个（步骤始终是有穷的）；

  • 每一个斐波那契数列元素都是前两个项的和，保证了只要按照这个规则的出来的数就一定可以分成更小的斐波那契数（循环可持续）；

  • 最后剩下的那个如果满足查找值就可以得到结果，否则就查找该数（循环终止条件）

算法原理

F(k) = F(k-1)+F(k-2)  
//斐波那契数列的规则

AT FIRST Arrays [index , index+F(k) ] = [index,index+F(k-2)+F(k-1)]
 //总是可以拆成前两个

WHILE F(k-2) NOT EQUALS ZERO                         // 切至最后一块  
    IF KEY < Arrays [F(k-2)] THEN 
            SEARCH Arrays [index , index+F(k-2)]
    END IF

    ELSE IF KEY > Arrays  [F(k-2)] THEN  
            SEARCH  Arrays [index +F(k-2) , index+F(k-2)+F(k-1)]
                     INDEX  index = index +F(k-2)

    ELSE  KEY == Arrays  [F(k-2)] THEN 
            RETURN  "KEY FOUND MESSAGE";
    END IF
END

完整源码


public class FibonacciSearch
{
    public static void main(String args[]){     
        int[] t = {0,1,2,3,4,5,6,7,8,9,10};
        int indexi = CreateFindex(t);
        int[] a = CreateArray(indexi,t);
        for(int x:a) System.out.print(" "+x+" ");

        // Search number
        for(int i=0;i<a.length;i++){
            int key = i-1;
            System.out.println("\n---- Try to find : "+ key+"----\n");
            if(hasNum(key,indexi,a)>-1)
                System.out.print(" < "+key+" > yes. \n");
            else
                System.out.print(" < "+key+" > no. \n");
        }
    }
    public static int F(int x){
        int[] f = new int[30];
        for(int i=2;i<f.length;i++){
            //f[0] = 1;
            f[0] = 0;
            f[1] = 1;
            f[i] = f[i-1] + f[i-2];
        }
        return f[x];
    }
    // Create new array
    public static int[] CreateArray(int indexi,int[] a){
        int[] newa = new int[F(indexi)+1];
        int N = a.length;
        for(int x=0;x<newa.length;x++){
            if(x<N)
                newa[x] = a[x];
            else
                newa[x] = a[N-1];
        }
        return newa;
    }
    public static int CreateFindex(int[] a){
        int N = a.length;
        int indexi = 0;
        for(int i=0;true;i++)
        {
            if(F(i) >=(N-1) ){
                indexi = i;
                break;
            }
        }
        return indexi;
    }
    // Binary search with only addition and substration
    public static int hasNum(int key,int k,int[] nums){
        int  c = F(k);
        int  b = F(k-1);
        int  a = c - b;
        int index = 0;

        while(a>0){
            //System.out.println("Time : "+k);
            if(key<(nums[index+a])) {
                System.out.println(" <<< Dn ["+index+","+(index+a)+"]");
                b = b - a;
                c = a;
                a = c - b;
                if(b==0){
                    a = 0;
                    if(nums[index+a]==key) return key;
                }
            }
            else if(key>(nums[index+a])){
                System.out.println(" >>> Up ["+(index+a)+","+(index+c)+"]");
                index = index + a;
                c = b;
                b = a;
                a = c - b;

            }
            else {
                System.out.println("Bingo ["+(index+a)+"]"+" Found : "+key);
                return key;
            }
        }
        return -1;
    }


}

/*
 BUG REPORT 
 zero found fixed.
*/

运行结果

Compiling FibonacciSearch.java.......  
-----------OUTPUT-----------  
 0  1  2  3  4  5  6  7  8  9  10  10  10  10 
---- Try to find : -1----

 <<< Dn [0,5]
 <<< Dn [0,2]
 <<< Dn [0,1]
 < -1 > no. 

---- Try to find : 0----

 <<< Dn [0,5]
 <<< Dn [0,2]
 <<< Dn [0,1]
 < 0 > yes. 

---- Try to find : 1----

 <<< Dn [0,5]
 <<< Dn [0,2]
Bingo [1] Found : 1
 < 1 > yes. 

---- Try to find : 2----

 <<< Dn [0,5]
Bingo [2] Found : 2
 < 2 > yes. 

---- Try to find : 3----

 <<< Dn [0,5]
 >>> Up [2,5]
Bingo [3] Found : 3
 < 3 > yes. 

---- Try to find : 4----

 <<< Dn [0,5]
 >>> Up [2,5]
 >>> Up [3,5]
Bingo [4] Found : 4
 < 4 > yes. 

---- Try to find : 5----

Bingo [5] Found : 5
 < 5 > yes. 

---- Try to find : 6----

 >>> Up [5,13]
 <<< Dn [5,8]
Bingo [6] Found : 6
 < 6 > yes. 

---- Try to find : 7----

 >>> Up [5,13]
 <<< Dn [5,8]
 >>> Up [6,8]
Bingo [7] Found : 7
 < 7 > yes. 

---- Try to find : 8----

 >>> Up [5,13]
Bingo [8] Found : 8
 < 8 > yes. 

---- Try to find : 9----

 >>> Up [5,13]
 >>> Up [8,13]
 <<< Dn [8,10]
Bingo [9] Found : 9
 < 9 > yes. 

---- Try to find : 10----

 >>> Up [5,13]
 >>> Up [8,13]
Bingo [10] Found : 10
 < 10 > yes. 

---- Try to find : 11----

 >>> Up [5,13]
 >>> Up [8,13]
 >>> Up [10,13]
 >>> Up [11,13]
 >>> Up [12,13]
 < 11 > no. 

---- Try to find : 12----

 >>> Up [5,13]
 >>> Up [8,13]
 >>> Up [10,13]
 >>> Up [11,13]
 >>> Up [12,13]
 < 12 > no. 
[Finished in 1.0s]

代码说明

  1. 诸如前面所述，正因为F(x)承担的是数组下标的角色，那么我假定我的程序里面F(x)是一个有效小标；
  2. 可是，斐波那契数列中的数值并不一定就恰恰等于我输入数组的最大下标(N-1);
  3. 然而无非两种情况，要么最大下标恰恰等于某个斐波那契数，这就很好办了，直接开始算；
  4. 更多的情况应该是最大下标恰恰小于某个斐波那契数f，也很好办，只要把重声明一个数组并且把长度补到那个斐波那契数f就可以了；
  5. 至于补充什么数，我按照我输入数据是升序的规律，为了方便一律填充了数组的最大值；
  6. 因为0 1 1这头三个序列数字比较特殊，再下降到差不多F(0)的时候，用一个if语句防止找不到Array[0]元素的BUG：
                if(b==0){
                    a = 0;
                    if(nums[index+a]==key) return key;
                }

代码心得

从题干里F是什么都看不懂到总算把这个谜题硬解出了，虽然代码还是很糙但是好开心啊！
但是，我感觉吧，包括各种准备功夫，都不是O(lgN)可以解决的问题了(´・ω・｀)。。。。
目前为止，我编程是 1成实现、1成命名注释、2成算法设计、2成用例设计、2成调试、1成可复用性Git管理，剩下1成自我陶醉，还有的九万九千九八九十九成以后再说吧w

引用出处

[1] Puzzles Binary search with addition and subtraction (probleme@ldc.ro, 2004)(Mihai Patrascu)
http://people.csail.mit.edu/mip/probs.html
[2] 百度百科斐波那契数列

Su_CRF
关注
专栏目录
二分查找、递归实现的斐波那契数列的时间/空间复杂度
是小狐狸*
06-09 884
一、二分查找法的时间复杂度int Er_Feng_Find(int arr[],int sz, int data){    int left = 0;    int right = sz - 1;    int mid = 0;    while (left &lt;= right)    {        mid =(right + left) / 2;        if (data &lt;...
函数递归练习（斐波那契数列，二分查找）
12-21
1.函数递归 1）问题规模大→划分小规模（如果没有问题规模，自己构建） 2）函数自己调用自己（体现问题规模不断缩小） 3）函数推出条件（防止死递归） 2斐波那契数列 public static int fibonacci(int n){ if(n==1||n==2){ return 1; } return fibonacci(n-1)+fibonacci(n-2); } public static void main(String[] args) { int reslut=fibonacci(9); System.out.println
二分查找之斐波那契查找
lfz_sau的博客
07-16 1018
1、什么是Fibonacci数列？       斐波那契数列，又称黄金分割数列，指的是这样一个数列：1、1、2、3、5、8、13、21、····，在数学上，斐波那契被递归方法如下定义：F(1)=1，F(2)=1，F(n)=f(n-1)+F(n-2) （n>=2）。该数列越往后相邻的两个数的比值越趋向于黄金比例值（0.618）。 2、什么是Fibonacci查找？      Fibonacci
【算法基础（2）】二分查找和斐波那契数列
谁说学美术将来只能卖画了，我也有自己的梦想。
01-18 942
nlogb⁡a=O(n0.793)，取ε = 0.2，显然当 c = 3 / 4 时，对于充分大的 n 可以满足 a * f(n / b) = 3 * (n / 4) * log(n / 4)
13 斐波那契数列 ,排序(快速排序) ,查找(二分查找) . 包装类(Integer和Character)
Baldteen_的博客
07-13 526
13 递归 自身调用自身 条件 : 必须有出口 , 若没有出口则是一个死递归 , 死递归的最终结果就是栈溢出 斐波那契数列 (兔子数列) 概述 : 斐波那契数列(Fibonacci Sequence) , 又称黄金分割数列 , 又称兔子数列 . 指如下数列 : 1 , 1 , 2 , 3 , 5 , 8 , 13 , 21 … 后一个数为前两个数之和 //斐波那契数列 public class FibonacciSequence { public static void main(String[]
查找算法之二分查找(斐波那契查找)
Y_JESSE的博客
03-31 2020
斐波那契数列   在数学中，斐波那契数列的定义是： fn={n(n=0,1)fn−1+fn−2    (n⩾2      )f_n=\left\{\begin{array}{lc}n&(n=0,1)\\f_{n-1}+f_{n-2}\;\;&(n\geqslant2\;\;\;)\end{array}\right.fn​={nfn−1​+fn−2​​(n=0,1)(n⩾2)​   ...
Java递归实现斐波那契数列
08-28
Java递归实现斐波那契数列是 Java 编程语言中的一种编程技巧，通过递归算法来实现斐波那契数列的生成。斐波那契数列是一个著名的数列，前面几个数字是0、1、1、2、3、5、8、13、21、34、55、89、144、233、377、610...
Java实现的两种常见简单查找算法示例【快速查找与二分查找】
08-29
Java实现的两种常见简单查找算法示例【快速查找与二分查找】 查找算法是计算机科学中的一种基本算法，它可以在大量数据中快速地找到指定的数据。在 Java 中，有多种查找算法，以下我们将介绍两种常见的简单查找算法...
Java实现用递归算法和非递归算法求解斐波那契数列问题.docx
最新发布
06-28
### Java实现用递归算法和非递归算法求解斐波那契数列问题 #### 知识点解析 在给定的文档标题与描述中，“Java实现用递归算法和非递归算法求解斐波那契数列问题”明确指出了本文将围绕Java编程语言、递归算法与非...
JAVA递归与非递归实现斐波那契数列
08-28
在Java中，斐波那契数列可以用递归和非递归两种方法来实现。 1. **递归实现**： 递归实现是最直观的方式，它通过函数自身调用来解决问题。在上述代码中，`feibonaci1` 方法就使用了递归。当计算 `feibonaci1(n)` ...
二分查找算法,斐波那契数列的递归及非递归。（分析时间复杂度及空间复杂度）
Victor.Chang
12-08 2947
//二分查找的非递归与递归实现： #include int binarry_Search(int arr[], int len, int value){ //采用左闭右闭区间方式 int left=0,right=len-1; int mid; while(left<=right){ mid=left+((right-left)>>1); //(left+right)/2; if
二分查找（递归、非递归）和斐波那契数列
文艺小木头的博客
08-31 206
package Suanfa; public class 二分查找和斐波那契数列 { public static void main(String[] args) { // TODO Auto-generated method stub int []arr={1,2,3,6,7,8}; int index=二分查找递归(arr,9,0,arr.length); System...
斐波那契查找—Java实现
qq_41056506的博客
08-20 2832
基本思想：也是二分查找的一种提升算法，通过运用黄金比例的概念在数列中选择查找点进行查找，提高查找效率。同样地，斐波那契查找也属于一种有序查找算法。 相对于折半查找，一般将待比较的key值与第mid=（low+high）/2位置的元素比较，比较结果分三种情况： 　　1）相等，mid位置的元素即为所求 　　2）&gt;，low=mid+1; 3）&lt;，high=mid-1。 　　斐波...
《剑指offer》斐波那契数列-二分查找
gsch_12的博客
06-25 174
题目： 大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项。 n&amp;lt;=39 思路： 这道有几个坑爹的地方。 首先，它的数列是从0开始出发。 其次， 第0项是0，第1项是1，后面才是正常的n项=n-1项+ n+1项 如果这题暴力，那么就是递归，花费整整1430ms，各位大佬已经毙掉这个解法。 这题用动态规划,只需要18ms 动态规划核心思想是：把该问题...
算法 - Java实现二分、插值、斐波那契查找法
江南烟雨却痴缠丶
07-29 348
一、二分查找法 二分查找法，就是对一个有序数组进行拆分。找到这个数组的中间的那个数的值，将查找的这个数与其比较。这里是从小到大排序的，如果比这个中间值小，就在把中间值左边看成一个数组，在这个数组里继续二分查找，直到查到(或者查完全部也没查到). 如果比这个中间值大，就在把中间值右边看成一个数组，在这个数组里继续二分查找，直到查到(或者查完全部也没查到). 代码实现 public class BinarySearchDemo { public static void main(String[] ar
二分查找、插值查找、斐波那契（黄金分割）查找分析与实现（Java）
zhangyuanshuai的博客
08-03 964
目录二分查找基本思想算法实现插值查找基本思想算法实现斐波那契（黄金分割）查找基本思想图解算法实现简单测试(JUnit) 二分查找   二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。 基本思想   首先，假设表中元素是按升序排列，将表中间位置记录的关键...
【数据结构与算法】二分搜索和斐波那契搜索-C实现
太白断水客
02-08 319
一直在家，无聊就看看. 二分搜索有O(1.5logn)的时间复杂度，斐波那契搜索可以进一步提升至O(1.4logn).
查找算法 -- 线性、二分、插值、斐波那契
JeremyIverson的博客
02-22 259
1.1 查找算法介绍 在 java 中，我们常用的查找有四种: 顺序(线性)查找 二分查找/折半查找 插值查找 斐波那契查找 1.2 线性查找算法 有一个数列： {1,8, 10, 89, 1000, 1234} ，判断数列中是否包含某个指定的数。 要求: 如果找到了，就提示找到，并给出下标值。 代码实现 public class SeqSearch { public static vo...
一个斐波那契数列的前10项为：1, 2, 3, 5, 8, 13, 21, 34, 55, 89，对于一个最大项的值不超过n的斐波那契数列，求值为偶数的项的和。
欢迎光临雨落星辰的博客
03-13 1904
题目内容：一个斐波那契数列的前10项为：1, 2, 3, 5, 8, 13, 21, 34, 55, 89，对于一个最大项的值不超过n的斐波那契数列，求值为偶数的项的和。 输入格式: 一个正整数n，如100。 输出格式： 值为偶数的项的和，如 2 + 8 + 34 = 44。 输入样例： 100 输出样例： 44 在这里插入代码片 ...
Java实现：线性查找、二分查找、插值查找与斐波那契查找算法
"这篇资源主要介绍了四种常见的查找算法——线性查找、二分查找、插值查找和斐波那契查找，特别关注了在Java中的实现。作者提供了详细的代码示例，便于理解和应用这些算法。 一、线性查找 线性查找是最基础的查找...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值