十、查找算法（二分查找、插值查找、斐波那契、哈希表）

最新推荐文章于 2024-03-27 09:44:32 发布
最新推荐文章于 2024-03-27 09:44:32 发布
阅读量112 收藏
点赞数
分类专栏： 数据结构与算法学习总结（java）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43907062/article/details/108842377
版权

一、二分查找算法（有序序列）

1.查找原理

在这里插入图片描述

2.代码实现

package search;

import java.util.ArrayList;
import java.util.List;

//注意：使用二分查找的前提是 该数组是有序的.
public class BinarySearch {

	public static void main(String[] args) {
		int arr[] = { 1, 8, 10, 89,1000,1000, 1234 };
		//int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 , 11, 12, 13,14,15,16,17,18,19,20 };
		

		//
//		int resIndex = binarySearch(arr, 0, arr.length - 1, 1000);
//		System.out.println("resIndex=" + resIndex);
		
		List<Integer> resIndexList = binarySearch2(arr, 0, arr.length - 1, 1000);
		System.out.println("resIndexList=" + resIndexList);
	}

	// 二分查找算法
	/**
	 * 
	 * @param arr
	 *            数组
	 * @param left
	 *            左边的索引
	 * @param right
	 *            右边的索引
	 * @param findVal
	 *            要查找的值
	 * @return 如果找到就返回下标，如果没有找到，就返回 -1
	 */
	public static int binarySearch(int[] arr, int left, int right, int findVal) {
		

		// 当 left > right 时，说明递归整个数组，但是没有找到
		if (left > right) {
			return -1;
		}
		int mid = (left + right) / 2;
		int midVal = arr[mid];

		if (findVal > midVal) { // 向右递归
			return binarySearch(arr, mid + 1, right, findVal);
		} else if (findVal < midVal) { // 向左递归
			return binarySearch(arr, left, mid - 1, findVal);
		} else {
			
			return mid;
		}

	}
	
	//完成一个课后思考题:
	/*
	 * 课后思考题： {1,8, 10, 89, 1000, 1000，1234} 当一个有序数组中，
	 * 有多个相同的数值时，如何将所有的数值都查找到，比如这里的 1000
	 * 
	 * 思路分析
	 * 1. 在找到mid 索引值，不要马上返回
	 * 2. 向mid 索引值的左边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
	 * 3. 向mid 索引值的右边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
	 * 4. 将Arraylist返回
	 */

	public static List<Integer> binarySearch2(int[] arr, int left, int right, int findVal) {
		// 当 left > right 时，说明递归整个数组，但是没有找到
		if (left > right) {
			return new ArrayList<Integer>();
		}
		int mid = (left + right) / 2;
		int midVal = arr[mid];

		if (findVal > midVal) { // 向 右递归
			return binarySearch2(arr, mid + 1, right, findVal);
		} else if (findVal < midVal) { // 向左递归
			return binarySearch2(arr, left, mid - 1, findVal);
		} else {
//			 * 思路分析
//			 * 1. 在找到mid 索引值，不要马上返回
//			 * 2. 向mid 索引值的左边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
//			 * 3. 向mid 索引值的右边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
//			 * 4. 将Arraylist返回
			
			List<Integer> resIndexlist = new ArrayList<Integer>();
			//向mid 索引值的左边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
			int temp = mid - 1;
			while(true) {
				if (temp < 0 || arr[temp] != findVal) {//退出
					break;
				}
				//否则，就temp 放入到 resIndexlist
				resIndexlist.add(temp);
				temp -= 1; //temp左移
			}
			resIndexlist.add(mid);  //
			
			//向mid 索引值的右边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
			temp = mid + 1;
			while(true) {
				if (temp > arr.length - 1 || arr[temp] != findVal) {//退出
					break;
				}
				//否则，就temp 放入到 resIndexlist
				resIndexlist.add(temp);
				temp += 1; //temp右移
			}
			
			return resIndexlist;
		}

	}
}

3.测试结果

resIndexList=[4, 5]

二、插值查找算法

1.查找原理

在这里插入图片描述
在这里插入图片描述

2.代码实现

package search;

import java.util.Arrays;

public class InsertValueSearch {

	public static void main(String[] args) {
		
//		int [] arr = new int[100];
//		for(int i = 0; i < 100; i++) {
//			arr[i] = i + 1;
//		}
		
		int arr[] = { 1, 8, 10, 89,1000,1000, 1234 };
		
		int index = insertValueSearch(arr, 0, arr.length - 1, 1234);
		//int index = binarySearch(arr, 0, arr.length, 1);
		System.out.println("index = " + index);
		
		//System.out.println(Arrays.toString(arr));
	}
	
	public static int binarySearch(int[] arr, int left, int right, int findVal) {
		System.out.println("二分查找被调用~");
		// 当 left > right 时，说明递归整个数组，但是没有找到
		if (left > right) {
			return -1;
		}
		int mid = (left + right) / 2;
		int midVal = arr[mid];

		if (findVal > midVal) { // 向 右递归
			return binarySearch(arr, mid + 1, right, findVal);
		} else if (findVal < midVal) { // 向左递归
			return binarySearch(arr, left, mid - 1, findVal);
		} else {

			return mid;
		}

	}

	//编写插值查找算法
	//说明：插值查找算法，也要求数组是有序的
	/**
	 * 
	 * @param arr 数组
	 * @param left 左边索引
	 * @param right 右边索引
	 * @param findVal 查找值
	 * @return 如果找到，就返回对应的下标，如果没有找到，返回-1
	 */
	public static int insertValueSearch(int[] arr, int left, int right, int findVal) { 
		//注意：findVal < arr[0]  和  findVal > arr[arr.length - 1] 必须需要
		//否则我们得到的 mid 可能越界
		if (left > right || findVal < arr[0] || findVal > arr[arr.length - 1]) {
			return -1;
		}

		// 求出mid, 自适应
		int mid = left + (right - left) * (findVal - arr[left]) / (arr[right] - arr[left]);
		int midVal = arr[mid];
		if (findVal > midVal) { // 说明应该向右边递归
			return insertValueSearch(arr, mid + 1, right, findVal);
		} else if (findVal < midVal) { // 说明向左递归查找
			return insertValueSearch(arr, left, mid - 1, findVal);
		} else {
			return mid;
		}

	}
}

3.测试结果

index = 6

三、斐波那契查找算法

1.查找原理

在这里插入图片描述
在这里插入图片描述

2.代码实现

package search;

import java.util.Arrays;

public class FibonacciSearch {

	public static int maxSize = 20;
	public static void main(String[] args) {
		int [] arr = {1,8, 10, 89, 1000, 1234};
		
		System.out.println("index=" + fibSearch(arr, 89));// 0
		
	}

	//因为后面我们mid=low+F(k-1)-1，需要使用到斐波那契数列，因此我们需要先获取到一个斐波那契数列
	//非递归方法得到一个斐波那契数列
	public static int[] fib() {
		int[] f = new int[maxSize];
		f[0] = 1;
		f[1] = 1;
		for (int i = 2; i < maxSize; i++) {
			f[i] = f[i - 1] + f[i - 2];
		}
		return f;
	}
	
	//编写斐波那契查找算法
	//使用非递归的方式编写算法
	/**
	 * 
	 * @param a  数组
	 * @param key 我们需要查找的关键码(值)
	 * @return 返回对应的下标，如果没有-1
	 */
	public static int fibSearch(int[] a, int key) {
		int low = 0;
		int high = a.length - 1;
		int k = 0; //表示斐波那契分割数值的下标
		int mid = 0; //存放mid值
		int f[] = fib(); //获取到斐波那契数列
		//获取到斐波那契分割数值的下标
		while(high > f[k] - 1) {
			k++;
		}
		//因为 f[k] 值 可能大于 a 的 长度，因此我们需要使用Arrays类，构造一个新的数组，并指向temp[]
		//不足的部分会使用0填充
		int[] temp = Arrays.copyOf(a, f[k]);
		//实际上需求使用a数组最后的数填充 temp
		//举例:
		//temp = {1,8, 10, 89, 1000, 1234, 0, 0}  => {1,8, 10, 89, 1000, 1234, 1234, 1234,}
		for(int i = high + 1; i < temp.length; i++) {
			temp[i] = a[high];
		}
		
		// 使用while来循环处理，找到我们的数 key
		while (low <= high) { // 只要这个条件满足，就可以找
			mid = low + f[k - 1] - 1;
			if(key < temp[mid]) { //我们应该继续向数组的前面查找(左边)
				high = mid - 1;
				//为甚是 k--
				//说明
				//1. 全部元素 = 前面的元素 + 后边元素
				//2. f[k] = f[k-1] + f[k-2]
				//因为 前面有 f[k-1]个元素,所以可以继续拆分 f[k-1] = f[k-2] + f[k-3]
				//即 在 f[k-1] 的前面继续查找 k--
				//即下次循环 mid = f[k-1-1]-1
				k--;
			} else if ( key > temp[mid]) { // 我们应该继续向数组的后面查找(右边)
				low = mid + 1;
				//为什么是k -=2
				//说明
				//1. 全部元素 = 前面的元素 + 后边元素
				//2. f[k] = f[k-1] + f[k-2]
				//3. 因为后面我们有f[k-2] 所以可以继续拆分 f[k-1] = f[k-3] + f[k-4]
				//4. 即在f[k-2] 的前面进行查找 k -=2
				//5. 即下次循环 mid = f[k - 1 - 2] - 1
				k -= 2;
			} else { //找到
				//需要确定，返回的是哪个下标
				if(mid <= high) {
					return mid;
				} else {
					return high;
				}
			}
		}
		return -1;
	}
}

3.测试结果

index=3

四、哈希表

1.问题引入

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.代码实现

package search;

import java.util.Scanner;

public class HashTabDemo {

	public static void main(String[] args) {
		
		//创建哈希表
		HashTab hashTab = new HashTab(7);
		
		//写一个简单的菜单
		String key = "";
		Scanner scanner = new Scanner(System.in);
		while(true) {
			System.out.println("add:  添加雇员");
			System.out.println("list: 显示雇员");
			System.out.println("find: 查找雇员");
			System.out.println("exit: 退出系统");
			
			key = scanner.next();
			switch (key) {
			case "add":
				System.out.println("输入id");
				int id = scanner.nextInt();
				System.out.println("输入名字");
				String name = scanner.next();
				//创建 雇员
				Emp emp = new Emp(id, name);
				hashTab.add(emp);
				break;
			case "list":
				hashTab.list();
				break;
			case "find":
				System.out.println("请输入要查找的id");
				id = scanner.nextInt();
				hashTab.findEmpById(id);
				break;
			case "exit":
				scanner.close();
				System.exit(0);
			default:
				break;
			}
		}
		
	}

}

//创建HashTab 管理多条链表
class HashTab {
	private EmpLinkedList[] empLinkedListArray;
	private int size; //表示有多少条链表
	
	//构造器
	public HashTab(int size) {
		this.size = size;
		//初始化empLinkedListArray
		empLinkedListArray = new EmpLinkedList[size];
		//？留一个坑, 这时不要分别初始化每个链表
		for(int i = 0; i < size; i++) {
			empLinkedListArray[i] = new EmpLinkedList();
		}
	}
	
	//添加雇员
	public void add(Emp emp) {
		//根据员工的id ,得到该员工应当添加到哪条链表
		int empLinkedListNO = hashFun(emp.id);
		//将emp 添加到对应的链表中
		empLinkedListArray[empLinkedListNO].add(emp);
		
	}
	//遍历所有的链表,遍历hashtab
	public void list() {
		for(int i = 0; i < size; i++) {
			empLinkedListArray[i].list(i);
		}
	}
	
	//根据输入的id,查找雇员
	public void findEmpById(int id) {
		//使用散列函数确定到哪条链表查找
		int empLinkedListNO = hashFun(id);
		Emp emp = empLinkedListArray[empLinkedListNO].findEmpById(id);
		if(emp != null) {//找到
			System.out.printf("在第%d条链表中找到 雇员 id = %d\n", (empLinkedListNO + 1), id);
		}else{
			System.out.println("在哈希表中，没有找到该雇员~");
		}
	}
	
	//编写散列函数, 使用一个简单取模法
	public int hashFun(int id) {
		return id % size;
	}
	
	
}

//表示一个雇员
class Emp {
	public int id;
	public String name;
	public Emp next; //next 默认为 null
	public Emp(int id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
}

//创建EmpLinkedList ,表示链表
class EmpLinkedList {
	//头指针，执行第一个Emp,因此我们这个链表的head 是直接指向第一个Emp
	private Emp head; //默认null
	
	//添加雇员到链表
	//说明
	//1. 假定，当添加雇员时，id 是自增长，即id的分配总是从小到大
	//   因此我们将该雇员直接加入到本链表的最后即可
	public void add(Emp emp) {
		//如果是添加第一个雇员
		if(head == null) {
			head = emp;
			return;
		}
		//如果不是第一个雇员，则使用一个辅助的指针，帮助定位到最后
		Emp curEmp = head;
		while(true) {
			if(curEmp.next == null) {//说明到链表最后
				break;
			}
			curEmp = curEmp.next; //后移
		}
		//退出时直接将emp 加入链表
		curEmp.next = emp;
	}
	
	//遍历链表的雇员信息
	public void list(int no) {
		if(head == null) { //说明链表为空
			System.out.println("第 "+(no+1)+" 链表为空");
			return;
		}
		System.out.print("第 "+(no+1)+" 链表的信息为");
		Emp curEmp = head; //辅助指针
		while(true) {
			System.out.printf(" => id=%d name=%s\t", curEmp.id, curEmp.name);
			if(curEmp.next == null) {//说明curEmp已经是最后结点
				break;
			}
			curEmp = curEmp.next; //后移，遍历
		}
		System.out.println();
	}
	
	//根据id查找雇员
	//如果查找到，就返回Emp, 如果没有找到，就返回null
	public Emp findEmpById(int id) {
		//判断链表是否为空
		if(head == null) {
			System.out.println("链表为空");
			return null;
		}
		//辅助指针
		Emp curEmp = head;
		while(true) {
			if(curEmp.id == id) {//找到
				break;//这时curEmp就指向要查找的雇员
			}
			//退出
			if(curEmp.next == null) {//说明遍历当前链表没有找到该雇员
				curEmp = null;
				break;
			}
			curEmp = curEmp.next;//以后
		}
		
		return curEmp;
	}
	
}
陈大大哈喔
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——哈希表（散列）原理与代码应用
流楚丶格念的博客
10-24 5262
文章目录什么是哈希表？Hash的应用Hash复杂度散列表的查找步骤散列函数（哈希函数）——散列地址哈希表优缺点优点：缺点：散列的三种方法1、除法散列法2、平方散列法3、斐波那契（Fibonacci）散列法散列冲突的解决方案：扩展代码应用 什么是哈希表？ 哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 记录的存储位置=f(关键
有序表查找（二分查找，插值查找，斐波那契查找）
Chenyt01的专栏
05-17 608
1.二分查找 //二分查找非递归 int Binary_Search1(int *num, int len,int target){ int low=0,hight=len-1,mid; while(low<=hight){ mid=(low+hight)/2; if(num[mid]==target) return mid; else if(num[mid]>targe
findhash:一个IDA脚本，可以检测出哈希算法（无论是否魔改常数）并生成frida hook代码
03-25
芬达哈希 在哈希算法上，比Findcrypt更好的检测工具，同时生成Frida hook代码。 使用方法 把findhash.xml和findhash.py放到ida插件目录下 ida -edit-plugin-findhash 试图解决的问题 哈希函数的初始化魔数被修改 想快速验证所分析的函数中是否使用了MD5，SHA1，SHA2这些哈希算法。 Findcrypt / Signsrch没发现来 可以应对如下各种findcrypt发现或哈希函数被魔改的情况 原理 通过正则表达式校正伪伪C代码中的初始化魔数代码以及哈希运算函数，很粗鲁暴力，所以运行时间会比较长，因为要反编译所有函数，但对哈希算法的检测上效果非常好。 去做 适应arm64 增加对特征常量立即数的搜索 根据相关理论，高占比的位运算指令以及循环，是加解密算法难以抹去的结构特征。
哈希表（散列表）原理详解
Mr.Steven 专注于Java
12-01 1306
转载：写的很好，大佬地址http://blog.csdn.net/duan19920101/article/details/51579136 什么是哈希表？ 哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
探索神秘的代码世界：FindHash - 检索与识别哈希值的利器
最新发布
gitblog_00097的博客
03-27 413
探索神秘的代码世界：FindHash - 检索与识别哈希值的利器 项目地址:https://gitcode.com/Pr0214/findhash 在编程和信息安全领域，哈希函数是我们日常工作中不可或缺的一部分，它们用于数据校验、密码存储等关键任务。而FindHash项目正是为了解决一个常见的问题——如何快速有效地查找并识别特定的哈希值。本文将深入探讨这个项目的功能、技术实现、应用场景及其独特之处...
hash简介
feiyu07的博客
12-13 215
散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)为哈
php实现的二分查找算法示例
12-19
4. **其他查找算法**：除了二分查找，还有哈希查找、线性查找、插值查找、斐波那契查找等多种查找算法，每种算法都有其适用的场景和优缺点。 理解并熟练掌握二分查找算法，有助于提升编程能力，特别是在处理大量...
查找算法总结---（附代码）
10-14
- 斐波那契查找也是对二分查找的改进，利用斐波那契数列的性质来确定分割点，理论上比插值查找更优，但实际应用中不如二分查找常见。 5. **树表查找**： - 树表查找通常指的是基于二叉搜索树或其他类型的查找树的...
查找算法 c++
01-03
与二分查找相比，插值查找在数据分布不均匀时可能更快，但其性能依赖于数据的分布情况。 6. 二叉搜索树查找： 二叉搜索树（BST）是一种特殊的二叉树，每个节点的左子树只包含比它小的元素，右子树只包含比它大的...
七大查找算法及C++源码.pdf
09-13
这些方法在不同的场景下各有优势，比如插值查找和斐波那契查找是对二分查找的优化，适用于接近均匀分布的数据；树表查找利用了树的结构，提供了快速查找；而哈希查找通过哈希函数将查找时间降低到常数级别，但在处理...
hashfind:Hashfind - 一种搜索文件以匹配密码哈希类型和其他有趣数据的工具
06-25
哈希查找 Hashfind - 一种搜索文件以匹配密码哈希类型和其他有趣数据的工具。 Hashfind 允许您搜索单个文件、多个文件或整个目录和子目录以查找与常见哈希类型的匹配项。 提取的支持的密码哈希类型包括； 原始 MD5 MySQL（旧）Joomla vBulletin phpbb3 WordpressMD5 Drupal Unix MD5（旧）SHA512 地穴电子邮件信用卡号码 稍后会添加更多。 该程序可以写入指定的输出文件，也可以在安静模式下直接写入标准输出。 笔记 如果散列被分成多行并用 \n 分割，则程序可能无法检测到散列。 这将在未来的版本中解决，但目前对此的需求还不是很大。
实验8查找算法实验比较报告-201908010705-杨杰1
08-04
1. 顺序查找 2. 二分查找[2] 3. 插值查找 4. 斐波那契查找 5. 树表查找 6. 分块查找 7. 哈希查找
Android逆向-实战so分析-某洲_v3.5.8_unidbg学习
哔_哩哩!的博客
07-20 4578
文章目录1.unidbg的介绍2.unidbg的安装2.1.下载unidbg工具2.2.导入IDEA2.3.验证导入是否成功3.unidbg的使用3.1.目标方法静态分析3.2.模拟执行目标方法3.3.算法分析3.3.1.OLLVM去混淆3.3.2.指令级TraceJNIEnv、jobject、jclassJNIEnv指针是什么东西？jobject和jclass又有什么区别？ 1.unidbg的介绍 unidbg是一款基于unicorn的用来模拟执行so的逆向工具，可以让安全研究人员直接在PC上运行andr
二分插值斐波那契查找算法和哈希表
lucylala007的博客
08-14 411
查找算法介绍 在java中，我们常用的查找有四种:* 1) 顺序(线性)查找 2) 二分查找/折半查找 3) 插值查找 4) 斐波那契查找 1) 顺序(线性)查找 ​ 有一个数列： {1,8, 10, 89, 1000, 1234} ，判断数列中是否包含此名称【顺序查找】 要求: 如果找到了，就提示找到，并给出下标值。 2) 二分查找/折半查找 二分查找的思路分析 首先确定该数组的中间的下标 mid = (left + right) / 2 然后让需要查找的数 findVal 和 arr[
4305 斐波那契字符串（哈希表、递推）
二哈
03-03 520
1. 问题描述： 斐波那契数列指的是这样一个数列：1、1、2、3、5、8、13、21、34、……在数学上，斐波那契数列以如下递推的形式定义：F(0) = 1，F(1) = 1，F(n) = F(n−1) + F(n−2)（n ≥ 2，n∈N∗）。如果一个数出现在斐波那契数列之中，那么我们就称这个数为斐波那契数。现在，给定一个整数 n，请你构造一个长度为 n 的字符串 s1s2…sn。对于字符串中的第 i 个字符 si： 如果 i 是斐波那契数，则 si 为大写字母 O。 如果 i 不是斐波那契数，则 si
【力扣】873. 最长的斐波那契子序列的长度
漆黑梦工厂
11-15 199
题目： 如果序列 X_1, X_2, …, X_n 满足下列条件，就说它是 斐波那契式 的： n >= 3 对于所有 i + 2 <= n，都有 X_i + X_{i+1} = X_{i+2} 给定一个严格递增的正整数数组形成序列 arr ，找到 arr 中最长的斐波那契式的子序列的长度。如果一个不存在，返回 0 。 （回想一下，子序列是从原序列 arr 中派生出来的，它从 arr 中删掉任意数量的元素（也可以不删），而不改变其余元素的顺序。例如， [3, 5, 8] 是 [3, 4, 5,
查找算法之哈希查找
青萍之末的博客
06-11 7476
  哈希也称散列，哈希表是一种与数组、链表等不同的数据结构，与他们需要不断的遍历比较来查找的办法，哈希表设计了一个映射关系f(key)= address，根据key来计算存储地址address，这样可以1次查找，f既是存储数据过程中用来指引数据存储到什么位置的函数，也是将来查找这个位置的算法，叫做哈希算法。 1、相关名词 1. 桶：哈希表中存储数据的位置，每一个位置对应唯一的一个地址，桶就好...
分治算法之二分查找【含例题】
爱笑的博客
05-10 4647
概述 给定已按升序排列的n个元素A[0:n-1]，现要在这n个元素中找出某一特定元素（查找关键字：key） 二分查找(Binary Search)又称为折半查找,是一种高效的算法。 二分查找要求待查找列表中的元素是有序的 核心思想 设A[low…high]为当前查找区间，首先确定区间的中点位置mid=⌊(low +high)/2⌋；然后将待查的key值与A[mid]进行比较 (1) 若key=A[mid]，则查找成功并返回该元素的下标 (2) 若key<A[mid]，则查找左子表A[lo
2018.10.08 NOIP模拟 斐波那契（贪心+hash/map）
weixin_30881367的博客
10-11 118
传送门 签到题。 显然是可以贪心分组的，也就是尽量跟当前的分成一组。 这时我们需要判断a[l]+a[r],a[l+1]+a[r]...a[r−1]+a[r]a[l]+a[r],a[l+1]+a[r]...a[r-1]+a[r]a[l]+a[r],a[l+1]+a[r]...a[r−1]+a[r]是否在fibfibfib数列中出现过 。 由于2e92e...
二分查找、插值查找和斐波那契查找的时间复杂度
11-17
二分查找、插值查找和斐波那契查找的时间复杂度如下： 1. 二分查找的时间复杂度为O(log n)。 2. 插值查找的时间复杂度也为O(log n)，但是在数据分布比较均匀的情况下，插值查找的效率比二分查找更高。 3. 斐波那契查找的时间复杂度也为O(log n)，但是相比于二分查找和插值查找，斐波那契查找的常数因子更小，因此在某些情况下，它的效率可能会更高。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值