Java数据结构和算法（五）-查找算法、哈希表

最新推荐文章于 2022-09-27 15:38:00 发布

东风难破

最新推荐文章于 2022-09-27 15:38:00 发布

阅读量282

点赞数

分类专栏：数据结构 java

本文链接：https://blog.csdn.net/qq_37965402/article/details/117654216

版权

java 同时被 2 个专栏收录

22 篇文章 2 订阅

订阅专栏

数据结构

16 篇文章 0 订阅

订阅专栏

八查找算法

8.1 查找算法介绍

在 java 中，我们常用的查找有四种:
（1）顺序(线性)查找
（2）二分查找/折半查找
（3）插值查找
（4）斐波那契查找

8.2 线性查找

8.2.1 线性查找思路

有一个数列： {1,8, 10, 89, 1000, 1234} ，判断数列中是否包含此名称【顺序查找】要求: 如果找到了，就提示找到，并给出下标值。

8.2.2 线性查找的实现

public static int seqSearch(int[] arr,int value) {
	//一一比对，如果发现相同，就返回下标
	for (int i = 0; i < arr.length; i++) {
		if (arr[i]==value) {
			return i;
		}
	}
	return -1;
}

8.3 二分查找

8.3.1 二分查找思路

对象必须是一个有序数组。
在这里插入图片描述

8.3.2 二分查找的代码实现

只能找到第一次匹配到的数据。

public static int binarySearch(int[] arr,int left,int right,int findVal) {
	//如果left>right，直接返回-1，表示没找到
	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;
	}
}

8.3.3 二分查找的应用

将数组出现的所有符号要求的数据都找到。
思路分析：如果找到了mid值，不要着急返回；向mid左边扫描，将所有符合要求的数据返回，直到不符合要求；向mid右边扫描，’将所有符合要求的数据返回，直到不符合要求。

public static ArrayList<Integer> binarySearch2(int[] arr,int left,int right,int findVal) {
	//如果left>right，直接返回-1，表示没找到
	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 {
		//左移扫描
		ArrayList<Integer> resIndexList = new ArrayList<Integer>();
		int temp=mid-1;
		while (true) {
			if (temp<0 || arr[temp]!=findVal) { 	//退出
				break;
			}
			//否则加入链表
			resIndexList.add(temp);
			temp-=1;
		}
		
		resIndexList.add(mid);		//把中间的放进去
		
		int temp1=mid+1;
		while (true) {
			if (temp>arr.length || arr[temp]!=findVal) { 	//退出
				break;
			}
			//否则加入链表
			resIndexList.add(temp1);
			temp+=1;
		}
		return resIndexList;
	}
}

8.4 插值查找

插值查找也要求是有序数组
基本上一次查找即可，因为mid也参与了计算，

8.4 1 插值查找原理

插值查找算法类似于二分查找，不同的是插值查找每次从自适应mid 处开始查找。
对折半查找中公式mid进行改进：low 表示左边索引 left, high 表示右边索引 right. key 就是前面我们讲的 findVal；a是要查找的数组。

int mid = low + (high - low) * (key - arr[low]) / (arr[high] - arr[low]) ;/插值索引/
对应前面的代码公式：
int mid = left + (right – left) * (findVal – arr[left]) / (arr[right] – arr[left])

8.4.2 插值查找的注意事项

对于数据量较大，关键字分布比较均匀的查找表来说，采用插值查找, 速度较快.
关键字分布不均匀的情况下，该方法不一定比折半查找要好

8.4.3 插值查找的代码实现

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;
	}
	
	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;
	}
}

8.5 斐波那契（黄金分割法）查找

8.5.1 插值查找原理

黄金分割点是指把一条线段分割为两部分，使其中一部分与全长之比等于另一部分与这部分之比。取其前三位数字的近似值是 0.618。由于按此比例设计的造型十分美丽，因此称为黄金分割，也称为中外比。这是一个神奇的数字，会带来意向不大的效果。
斐波那契数列 {1, 1, 2, 3, 5, 8, 13, 21, 34, 55 } 发现斐波那契数列的两个相邻数的比例，无限接近黄金分割值 0.618

8.5.2斐波那契(黄金分割法)原理:

斐波那契查找原理与前两种相似，仅仅改变了中间结点（mid）的位置，mid 不再是中间或插值得到，而是位于黄金分割点附近，即 mid=low+F(k-1)-1（F 代表斐波那契数列），如下图所示
对F(K-1)-1的理解
（1）由斐波那契数列 F[k]=F[k-1]+F[k-2] 的性质，可以得到（F[k]-1）=（F[k-1]-1）+（F[k-2]-1）+1 。该式说明：只要顺序表的长度为 F[k]-1，则可以将该表分成长度为 F[k-1]-1 和 F[k-2]-1 的两段，即如上图所示。从而中间位置为： mid=low+F(k-1)-1
（2）类似的，每一子段也可以用相同的方式分割
（3）但顺序表长度 n 不一定刚好等于 F[k]-1，所以需要将原来的顺序表长度 n 增加至 F[k]-1。这里的 k 值只要能使
得 F[k]-1 恰好大于或等于 n 即可，由以下代码得到,顺序表长度增加后，新增的位置（从 n+1 到 F[k]-1 位置），都赋为 n 位置的值即可。while(n>fib(k)-1)； k++;

8.5.3 斐波那契查找的实现

对一个有序数组进行斐波那契查找 {1,8, 10, 89, 1000, 1234}进行查找。

//因为后面需要用到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;
}

//斐波那契查找算法
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的长度，因为我们需要使用array类，构造一个新的数组，并指向a[]
	//不足的部分使用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=f[k-1]-1;
		if (key<temp[mid]) {	//要找的key在数组的前半部分去找
			high=mid-1;
			k--;
			/*为什么是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
			 * */
		}else if (key>temp[mid]) {
			low=mid+1;
			k-=2;
			/*为什么是k-=2
			 * 因为f[k]=f[k-1]+f[k-2],所以，向后查找有f[k-2]
			 * 即下次循环mid=f[k-1-2]-1
			 * */
		}else {	//找到
			//需要确定返回的是哪个下标：一般返回比较小的
			if (mid<=high) {
				return mid;
			}else {
				return high;
			}
		}
		
	}
	return -1;	
}

九哈希表

9.2 哈希表的基本介绍

散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
在这里插入图片描述

9.2 Google上机题

题目
有一个公司,当有新的员工来报道时,要求将该员工的信息加入(id,性别,年龄,住址…),当输入该员工的id 时,要求查找到该员工的所有信息。
要求:
（1）不使用数据库,尽量节省内存,速度越快越好=>哈希表(散列)
（2）添加时，保证按照 id 从低到高插入 [课后思考：如果 id 不是从低到高插入，但要求各条链表仍是从低到高，怎么解决?]
（3）使用链表来实现哈希表, 该链表不带表头[即: 链表的第一个结点就存放雇员信息]
思路分析

9.3 上机题的代码实现

package com.atguigu.hashtab;
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("find:查找雇员");
			System.out.println("list:显示雇员");
			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 "find":
				System.out.println("请输入要查找的雇员id：");
				int no=scanner.nextInt();
				hashTab.findEmpById(no);
				break;
			case "list":
				hashTab.list();
				break;
			case "exit":
				scanner.close();
				System.exit(0);
				break;

			default:
				break;
			}
		}
	}
}

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

//创建hashTab
//此类中的函数是针对hashTab中的元素进行操作
class HashTab{
	private EmpLinkedList[] empLinkedListArray;
	private int size;	//表示有多少条链表
	//构造器
	public HashTab(int size) {
		empLinkedListArray =new EmpLinkedList[size];
		this.size = size;
		//有一个坑;对于hashTab，需要初始化每一个数组中的元素，否则添加雇员到链表中时，链表为null，不能添加
		//即，如果不初始化，hashtab中存放的就不是链表，怎么能向链表中添加数据呢
		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);
	}
	//编写查找函数，依据id查找hashTab数组中的链表中的值
	public void findEmpById(int id) {
		int no=hashFun(id);
		Emp emp=empLinkedListArray[no].findEmpById(id);
		if (emp!=null) {
			System.out.println("在第"+(no+1)+"条链表中找到id为"+id+"的雇员的信息");
			System.out.printf("雇员信息为：id=%d,name=%s\n",emp.id,emp.name);
		}else {
			System.out.println("在hashTab中没有找到该雇员的信息！");
		}
	}
	//遍历所有的链表，遍历hsshTab
	public void list() {
		for (int i = 0; i < size; i++) {
			empLinkedListArray[i].list(i+1);
		}
	}
	//编写散列函数，使用一个简单的取模法
	public int hashFun(int id) {
		return id%size;
	}
	
}
//创建EmpLinkedList，表示链表
//此类中的函数是针对hash表中国的链表的元素进行 的操作，
class EmpLinkedList{
	//头指针，执行第一个Emp，因此我们这个链表的head，是直接执行第一个Emp。
	private Emp head;	//默认为null
	
	//添加雇员到链表
	//说明：1. 假设，当添加雇员时，id是自增长，即id的分配总是从小到大，因此我们将该雇员直接放到本链表的最后即可
	public void add(Emp emp) {
		//如果是添加第一个雇员
		if (head==null ) {
			head=emp;
			return;
			
		}
		//如果不是第一个雇员，则使用一个辅助指针，先找到链表的最后，在添加
		Emp temp=head;
		while (true) {
			if (temp.next==null) {
				break;
			}
			temp=temp.next;
		}
		//退出后，直接将emp添加到链表尾部
		temp.next=emp;
	}
	
	//遍历链表所有雇员信息
	public void list(int no) {
		if (head==null) {//说明链表为空
			System.out.printf("第%d链表为空\n",no);
			return;
		}
		System.out.print("第"+no+"链表的信息为：");
		Emp temp=head;
		while (true) {
			System.out.printf("=>id=%d,name=%s\t", temp.id,temp.name);
			if (temp.next==null) {	//说明temp已经到最后节点
				break;
			}
			temp=temp.next;
		}
		System.out.println();
	}
	
	//根据id查找雇员；找到返回emp，没有找到，返回null
	public Emp findEmpById(int id) {
		//判断链表是否为空
		if (head==null) {
			return null;
		}
		//辅助指针
		Emp temp=head;
		while (true) {
			if (temp.id==id) {	//找到
				break;
			}
			//退出
			if (temp.next==null) {	//遍历当前链表没有找见
				temp=null;
				break;
			}
			temp=temp.next;
		}
		return temp;
	}
}

东风难破

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java数据结构和算法（五）-查找算法、哈希表

本行目录八查找算法8.1 查找算法介绍8.2 线性查找8.2.1 线性查找思路8.2.2 线性查找的实现8.3 二分查找8.3.1 二分查找思路8.3.2 二分查找的代码实现8.3.3 二分查找的应用8.4 插值查找8.4 1 插值查找原理8.4.2 插值查找的注意事项8.4.3 插值查找的代码实现8.5 斐波那契（黄金分割法）查找8.5.1 插值查找原理8.5.2斐波那契(黄金分割法)原理:8.5.3 斐波那契查找的实现八查找算法8.1 查找算法介绍在 java 中，我们常用的查找有四种:（1
复制链接

扫一扫