查找算法 —— 斐波拉契查找法

已于 2024-04-18 22:41:44 修改
阅读量483 收藏 3
点赞数 2
分类专栏： 知识点记录 算法数据结构 文章标签： 算法
于 2023-10-08 20:19:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50702814/article/details/133686070
版权

一、介绍

        斐波拉契查找法是以分割范围进行查找的，分割的方式是按照斐波拉契级数的方式来分割。好处是：只用到加减运算，计算效率较高一些。

       要使用斐波拉契查找首先需要定义一颗斐波拉契查找树，建立规则如下：

       1.斐波拉契树的左右子树均为斐波拉契树。

       2.当数据个数n确定时，若想确定斐波拉契树的层数k值，就必须找到一个最小的K值，使得斐波拉契层数的Fib（k+1）>= n+1.

       3.斐波拉契树的树根一定是一个斐波拉契树，且子节点与父节点差值的绝对值为斐波拉契数。

       4.当k>=2时，斐波拉契树的树根为Fib(k),左子树为（k-1）层斐波拉契树（其树根为Fib(k-1)）,

右子树为（k-2）层斐波拉契树（其树根为Fib(k) + Fib(k-2)）。

       5.若n+1的值不为斐波拉契数的值，则可以找出存在一个m使用Fib(k+1)-m = n+1，m=Fib(k+1)-(n+1),再按斐波拉契树的建立原则完成斐波拉契树的建立，最后斐波拉契树的各节点减去差值m即可，并把小于1的节点去掉。

      可以先罗列一部分斐波拉契数的值，如下：

 Fib(0) = 0, Fib(1) = 1, Fib(2) = 1, Fib(3) =2, Fib(4) = 3，

 Fib(5) = 5, Fib(6) = 8, Fib(7) = 13,  Fib(8) = 21, Fib(9) = 34,

      接下来第一种情况时n+1的值是斐波拉契数的值，假设就是数1~33，也就是n=33,那么n+1 = 34,可以根据Fib(k+1) >= n+1 得出 k的值为8，则可以建立斐波拉契树，如下：       

  第二种情况就是n+1的值不是斐波拉契数的值，假设n=10,那么n+1 =11，不是斐波拉契数，按照第五条规则，可以找出一个值m,使Fib(k+1) - m = n+1成立，则Fib(k+1)=13,则m=2, k=6,按照规则建立的斐波拉契树如下：

各节点减去m,并把小于1的节点去掉之后得到

斐波拉契查找法步骤首先将要查找的数与树根Fib(k)比较，如果相等这个数就是Fib(k),如果比Fib(k)小则，数在1到Fib(k)-1之间，如果比Fib(k)大，则这个数在Fib(k)+1到Fib(k+1)-1之间。

二、建立Fib树代码

1.首先先生成Fib数储存起来，避免每次查找都要计算一遍：

void FibCalc(int n)
{   
    fibls.Add(0);
    for (int i = 1; i < n; i++)
    {
        if (i < 3)
        {
            fibls.Add(1);
        }
        else
        {
            fibls.Add(fibls[i-1] + fibls[i-2]);
        } 
    }
}

2.然后判断一个数是不是Fib数并且找到一个比这个数大或者相等的Fib数

 bool LookUpFibAndIsFib(int val, out int ksum1)
 {
     ksum1 = -1;
     if (val < 0)
     {
         Debug.LogError("输入的值不能小于0");
         return false;
     }
        
     for (int i = 0; i < fibls.Count; i++)
     {
         if (val == fibls[i])
         {
             ksum1 = i;
             return true;
         }
         else if(val < fibls[i])
         {
             ksum1 = i;
             return false;
         }
     }
     Debug.LogError("没有匹配到K");
     return false;
 }

 3，生成Fib树

  void GenerateFibTree(Node node, int k,int val)
  {
      if (k - 2 < 0) return;
      int fibNum = node.Data - fibls[k - 2];
      

      if (fibNum == node.Data) return;

      if (node.Data != 1)
      {
          node.LeftNode = new Node();
          node.LeftNode.Data = fibNum;
          node.LeftNode.PNode = node;
      }

      int fibNumR = node.Data + fibls[k - 2];
      if (fibNum > 1 && fibNumR != root.Data)
      {

          if (fibNumR != node.PNode.Data || node.PNode == null)
          {
              if (node.PNode.PNode != null && fibNumR != node.PNode.PNode.Data)
              {
                  node.RightNode = new Node();
                  node.RightNode.Data = fibNumR;
                  node.RightNode.PNode = node;
              }
              if (node.PNode.PNode == null)
              {
                  node.RightNode = new Node();
                  node.RightNode.Data = fibNumR;
                  node.RightNode.PNode = node;
              }
          }
      }

      if (node.LeftNode != null)
          GenerateFibTree(node.LeftNode, k - 1, val);
      if (node.RightNode != null)
          GenerateFibTree(node.RightNode, k - 2, val);
  }

 4.在需要减去m的情况下：

 void FibTreeMinusM(int m,Node node)
 {
     if (node.LeftNode != null)
     {
         node.LeftNode.Data -= m;
         FibTreeMinusM(m, node.LeftNode);
         if (node.LeftNode.Data < 1)
             node.LeftNode = null;
     }
     if (node.RightNode != null)
     {
         node.RightNode.Data -= m;
         FibTreeMinusM(m, node.RightNode);
         if (node.RightNode.Data < 1)
             node.RightNode = null;
     }
 }

5.最后按照输入的数值生成Fib树

   void FibLookUpArithmetic(int val)
   {
       int ksum1 = 0;
       if (LookUpFibAndIsFib(val+1, out ksum1))
       {
           int k = ksum1 - 1;
           InitGenerateFibTree(k,val);
       }
       else
       {
           int k = ksum1 - 1;
           InitGenerateFibTree(k, val);
           int m = fibls[ksum1] - (val + 1);
           root.Data -= m;
           FibTreeMinusM(m, root);
       }
   }

 完整代码：

using System.Collections.Generic;
using UnityEditor.Experimental.GraphView;
using UnityEngine;
using UnityEngine.Rendering;

public class LookUpArithmetic : MonoBehaviour
{
    List<int> fibls;
    Node root;
    void Start()
    {
        fibls = new List<int>(30);
        FibCalc(30);
        FibLookUpArithmetic(10);
    }

    void FibLookUpArithmetic(int val)
    {
        int ksum1 = 0;
        if (LookUpFibAndIsFib(val+1, out ksum1))
        {
            int k = ksum1 - 1;
            InitGenerateFibTree(k,val);
        }
        else
        {
            int k = ksum1 - 1;
            InitGenerateFibTree(k, val);
            int m = fibls[ksum1] - (val + 1);
            root.Data -= m;
            FibTreeMinusM(m, root);
        }
    }

    bool LookUpFibAndIsFib(int val, out int ksum1)
    {
        //首先判断是否是一个Fbi数和找到一个Fbi数两步可以合并为一步
        ksum1 = -1;
        if (val < 0)
        {
            Debug.LogError("输入的值不能小于0");
            return false;
        }
           
        for (int i = 0; i < fibls.Count; i++)
        {
            if (val == fibls[i])
            {
                ksum1 = i;
                return true;
            }
            else if(val < fibls[i])
            {
                ksum1 = i;
                return false;
            }
        }
        Debug.LogError("没有匹配到K");
        return false;
    }

    void FibCalc(int n)
    {   
        fibls.Add(0);
        for (int i = 1; i < n; i++)
        {
            if (i < 3)
            {
                fibls.Add(1);
            }
            else
            {
                fibls.Add(fibls[i-1] + fibls[i-2]);
            } 
        }
    }

    void InitGenerateFibTree(int k, int val)
    {
        root = new Node();
        root.Data = fibls[k];
        root.LeftNode = new Node();
        root.LeftNode.Data = fibls[k] - fibls[k - 2];
        root.LeftNode.PNode= root;
        GenerateFibTree(root.LeftNode, k - 1, val);
        root.RightNode = new Node();
        root.RightNode.Data = fibls[k] + fibls[k - 2];
        root.RightNode.PNode = root;
        GenerateFibTree(root.RightNode, k - 2, val);
    }

    void GenerateFibTree(Node node, int k,int val)
    {
        if (k - 2 < 0) return;
        int fibNum = node.Data - fibls[k - 2];
      

        if (fibNum == node.Data) return;

        if (node.Data != 1)
        {
            node.LeftNode = new Node();
            node.LeftNode.Data = fibNum;
            node.LeftNode.PNode = node;
        }

        int fibNumR = node.Data + fibls[k - 2];
        if (fibNum > 1 && fibNumR != root.Data)
        {

            if (fibNumR != node.PNode.Data || node.PNode == null)
            {
                if (node.PNode.PNode != null && fibNumR != node.PNode.PNode.Data)
                {
                    node.RightNode = new Node();
                    node.RightNode.Data = fibNumR;
                    node.RightNode.PNode = node;
                }
                if (node.PNode.PNode == null)
                {
                    node.RightNode = new Node();
                    node.RightNode.Data = fibNumR;
                    node.RightNode.PNode = node;
                }
            }
        }

        if (node.LeftNode != null)
            GenerateFibTree(node.LeftNode, k - 1, val);
        if (node.RightNode != null)
            GenerateFibTree(node.RightNode, k - 2, val);
    }

    void FibTreeMinusM(int m,Node node)
    {
        if (node.LeftNode != null)
        {
            node.LeftNode.Data -= m;
            FibTreeMinusM(m, node.LeftNode);
            if (node.LeftNode.Data < 1)
                node.LeftNode = null;
        }
        if (node.RightNode != null)
        {
            node.RightNode.Data -= m;
            FibTreeMinusM(m, node.RightNode);
            if (node.RightNode.Data < 1)
                node.RightNode = null;
        }
    }
}

class Node
{
    public Node LeftNode;
    public Node RightNode;
    public int Data;
    public Node PNode = null;
}

如有不足之处，欢迎指正。

参考书籍：

清华大学出版社-图书详情-《图解数据结构--使用C#》 (tsinghua.edu.cn)

浅陌sss
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
静态与动态查找算法性能比较课程设计
03-13
　③散列法查找 　在Hash查找方法中 散列函数构造方法多种多样 同时对于同一散列函数解决冲突的方法也可以不同 两者是影响查询算法性能的关键因素 对于几种典型的散列函数构造方法 做实验观察 不同的解决冲突方法对...
【查找】斐波那契查找
StudyWinter的博客
10-13 3054
开始看的时候，很懵逼，后来又看了一下思路，又有一些理解了。记录一下。 1、斐波那契(黄金分割法)查找基本介绍 （1）黄金分割点是指把一条线段分割为两部分，使其中一部分与全长之比等于另一部分与这部分之比。取其前三位数字的近似值是0.618。由于按此比例设计的造型十分美丽，因此称为黄金分割，也称为中外比。这是一个神奇的数字，会带来意向不大的效果。 （2）斐波那契数列 {1, 1, 2, 3, 5, 8, 13, 21, 34, 55 } 发现斐波那契数列的两个相邻数 的比例，无限接近黄金分割值0.618
斐波那契查找（Fibonacci Search）
高物终结者
10-07 547
斐波那契查找 斐波那契查找就是在二分查找的基础上根据斐波那契数列进行分割的。 在斐波那契数列找一个等于略大于查找表中元素个数的数F[n]，将原查找表扩展为长度为F[n](如果要补充元素，则补充重复最后一个元素，直到满足F[n]个元素)，完成后进行斐波那契分割，即F[n]个元素分割为前半部分F[n-1]个元素，后半部分F[n-2]个元素，找出要查找的元素在那一部分并递归，直到...
斐波那契查找(FibonacciSearch)
游戏开发
11-07 925
说明 二分搜寻法每次搜寻时，都会将搜寻区间分为一半，所以其搜寻时间为O(log(2)n)，log(2)表示以2为底的log值，这边要介绍的费氏搜寻，其利用费氏数列作为间隔来搜寻下一个数，所以区间收敛的速度更快，搜寻时间为O(logn)。 方法 该方法稍有些繁琐，对照代码更容易理解。费氏搜寻使用费氏数列来决定下一个数的搜寻位置，所以必须先制作费氏数列，这在之前有提过；费氏搜寻会先透过公式计
斐波那契查找
沈波的专栏
03-23 1223
斐波那契查找 黄金比例又称黄金分割，是指事物各部分间一定的数学比例关系，即将整体一分为二，较大部分与较小部分之比等于整体与较大部分之比，其比值约为1:0.618或1.618:1。 0.618被公认为最具有审美意义的比例数字，这个数值的作用不仅仅体现在诸如绘画、雕塑、音乐、建筑等艺术领域，而且在管理、工程设计等方面也有着不可忽视的作用。因此被称为黄金分割。 大家记不记得斐波那契
数据结构-改进的线性查找算法（c++）实现
08-09
线性查找又称顺序查找，其基本思想位：从线性表的一端向另一端逐个将记录与给定值进行比较，若相等，则查找成功...本文所述的线性查找算法位改进的，增设了许多功能，有：折半查找，分块查找，插值查找，斐波拉契查找。
斐波拉契数列分治法实现
03-10
斐波拉契数列用分治法实现算法，整体效率比用递归方式实现要快出很多。我已经亲手测试过了，希望上传的资源可以帮到大家。如果有任何问题要记得给我留言，大家一起探讨，共同进步啊。
斐波拉契查找原理分析及代码实现.md
07-07
本章节主要用于讲解斐波那契查找方法的分析与实现，其中包括介绍相关概念，数学分析、以及代码附上。菜鸡一枚，自己学习心得，方便自己日后查看，如果能给你提供帮助，很荣幸
运用斐波拉契算法进行数据查询（python代码）
06-03
运用斐波拉契算法进行数据查询，运行后根据提示输入要查找的数据
斐波那契数列java前四项_四大查找算法 - 贪挽懒月的个人空间 - OSCHINA - 中文开源技术交流社区...
weixin_28726083的博客
02-27 174
在Java中，常用的查找算法有以下四种：顺序查找；二分查找；插值查找；斐波那契查找；一、顺序查找顺序查找非常简单，就是遍历数组，找到了就返回元素下标，代码如下：publicstaticintfind(int[]arr,inttargetNum){if(arr==null){return-1;}for(inti=0;iif(arr[i]==targetNum)...
Java实现斐波那契数列记忆化搜索
最新发布
10-08
Java实现斐波那契数列的记忆化搜索可以通过使用一个数组来存储已经计算过的结果，避免重复计算。下面是一个示例代码： ```java public class Fibonacci { private static long[] memo; public static long fibonacci(int n) { memo = new long[n + 1]; return fibonacciHelper(n); } private static long fibonacciHelper(int n) { if (n <= 1) { return n; } if (memo[n] != 0) { return memo[n]; } memo[n] = fibonacciHelper(n - 1) + fibonacciHelper(n - 2); return memo[n]; } public static void main(String[] args) { int n = 10; long result = fibonacci(n); System.out.println("Fibonacci of " + n + " is: " + result); } } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值