各种查找的实现Java

最新推荐文章于 2024-03-26 21:38:22 发布
最新推荐文章于 2024-03-26 21:38:22 发布
阅读量4.1k 收藏 2
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 查找 java 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liangxiamoyi/article/details/52185546
版权 
/**
 * 待排序记录类
 * @author liangxiamoyi
 *
 */
public class Element {
	/**
	 * 数据
	 */
	private int key;
	/**
	 * 获得数据
	 * @return key值
	 */
	public int getKey(){
		return key;
	}
	/**
	 * 设置数据值
	 * @param key 数据值
	 */
	public void setKey(int key){
		this.key=key;
	}
}


import java.util.Scanner;

/**
 * 查找方法类
 * @author liangxiamoyi
 *
 */
public class Search {
	/**
	 * 顺序查找
	 * @param r 待查找文件
	 * @param n 个数
	 * @param k 查找的元素
	 * @return 成功返回k所在的位置，不成功返回0
	 */
	public static int seqSearch(Element[] r,int n,int k){
		int i=1;
		while(i<=n&&r[i].getKey()!=k){
			i++;
		}
		if(i>n)return 0;
		return i;
	}
	/**
	 * <p>快速查找，引入一个“虚拟”记录r[n+1],提高算法查找效率</p>
	 * <p>加速原理：当算法的一个内循环要测试两个或多个条件时，应力图将其减少成一个条件</p>
	 * <p>算法quickSearch比seqSearch节省20%的运行时间</p>
	 * @param r 待查找文件
	 * @param n 个数
	 * @param k 查找元素
	 * @return 成功返回k所在的位置，不成功返回0
	 */
	public static int quickSearch(Element[] r,int n,int k){
		int i=1;
		r[n+1].setKey(k);
		while(r[i].getKey()!=k){
			i++;
		}
		if(i<=n)return i;
		return 0;
	}
	/**
	 * <p>更快速的查找</p>
	 * <p>算法quickerSearch比quickSearch总比较次数减少了10%，运行时间减少了30%</p>
	 * @param r 待查找文件
	 * @param n 个数
	 * @param k 查找元素
	 * @return 成功返回k的位置，不成功返回0
	 */
	public static int quickerSearch(Element[] r,int n,int k){
		int i=-1;
		r[n+1].setKey(k);
		i+=2;
		while(r[i].getKey()!=k){
			if(r[i+1].getKey()!=k)i+=2;
			else {
				i++;
				break;
			}
		}
		if(i<=n)return i;
		else return 0;
	}
	/**
	 * <p>有序表的顺序查找，设定一个虚拟记录r[n+1]=MAX_VALUE</p>
	 * <p>该算法能更快地确定一个记录不存在</p>
	 * @param r 待查找的文件
	 * @param n 个数
	 * @param k 查找元素
	 * @return 成功返回k的位置，不成功返回0 
	 */
	public static int sortedSearch(Element[] r,int n,int k){
		int i=1;
		r[n+1].setKey(Integer.MAX_VALUE);
		while(r[i].getKey()<k){
			i++;
		}
		if(r[i].getKey()==k)return i;
		else return 0;
	}
	/**
	 * 对半查找
	 * @param r 待查找文件
	 * @param n 个数
	 * @param k 查找元素
	 * @return 成功返回k的位置，不成功返回0
	 */
	public static int binSearch(Element[] r,int n,int k){
		int i,s=1,e=n;
		while(s<=e){
			i=(s+e)/2;
			if(k<r[i].getKey())e=i-1;
			if(k>r[i].getKey())s=i+1;
			if(k==r[i].getKey())return i;
		}
		return 0;
	}
	/**
	 * 一致对半查找，若n为偶数,则算法有时将涉及一个r[0]=MIN_VALUE
	 * <p>相比于对半查找，由三个游标变为两个游标</p>
	 * @param r 待查找文件
	 * @param n 个数
	 * @param k 查找元素
	 * @return 成功返回k的位置，不成功返回0
	 */
	public static int unanBinSearch(Element[] r,int n,int k){
		int i=(n+1)/2;
		int m=n/2;
		r[0].setKey(Integer.MIN_VALUE);
		while(k!=r[i].getKey()){
			if(k<r[i].getKey()){
				if(m==0)return 0;
				else {
					i-=(m+1)/2;
					m=m/2;
				}
			}
			if(k>r[i].getKey()){
				if(m==0)return 0;
				else {
					i+=(m+1)/2;
					m=m/2;
				}
			}	
		}
		return i;
	}
	/**
	 * 计算delta数组
	 * @param delta 辅助表
	 * @param n 个数
	 */
	public static void calDelta(int[] delta,int n){
		int k=(int)(Math.log(n)/Math.log(2))+2;
		int s=1;//累积存储2的j-1次方，初始为2的0次方，故为1
		for(int j=1;j<=k;j++){
			delta[j]=(n+s)/(s*2);
			s*=2;
		}
	}
	/**
	 * 使用辅助表的一致对半查找
	 * <p>该算法和算法unanBinSearch相似，但它使用一个辅助表来代替涉及m的计算</p>
	 * <p>辅助表的项是DELTA[j]=(N+2^(j-1))/2^j向下取整</p>
	 * @param r 待查找文件
	 * @param n 个数
	 * @param k 查找元素
	 * @param delta 辅助表
	 * @return 成功返回k的位置，不成功返回0
	 */
	public static int conBinSearch(Element[] r,int n,int k,int[] delta){
		int i=delta[1],j=2;
		while(k!=r[i].getKey()){
			if(k<r[i].getKey()){
				if(delta[j]==0)return 0;
				else {
					i-=delta[j];
					j++;
				}
			}
			if(k>r[i].getKey()){
				if(delta[j]==0)return 0;
				else {
					i+=delta[j];
					j++;
				}
			}	
		}
		return i;
	}
	/**
	 * 构造斐波那契数列
	 * @param f 存储数列的数组
	 * @param n 文件个数
	 */
	public static void fibonacci(int[] f,int n){
		f[0]=0;
		f[1]=1;
		f[2]=1;
		int i=2;
		while(f[i]<n){
			f[i+1]=f[i]+f[i-1];
			i=i+1;
		}
	}
	/**
	 * 斐波那契查找，算法假定n+1是一个斐波那契数，即n+1=f[m+1]
	 * <p>T(k)表示k阶斐波那契树，若k=0或1则此树就是0；若k>=2;则树T(k)根为f[k].</p>
	 * <p>左子树为T[k-1],右子树为阶数为k-2且所有结点之编号都增加f[k]的斐波那契树</p>
	 * @param r 待查找文件
	 * @param m 个数
	 * @param k 查找元素
	 * @param fib 存放Fibonacci序列的数组
	 * @return 成功返回k的位置，不成功返回0
	 */
	public static int fibSearch(Element[] r,int m,int k,int[] fib){
		int i=fib[m],p=fib[m-1],q=fib[m-2];
		int t;
		while(k!=r[i].getKey()){
			if(k<r[i].getKey()){
				if(q==0)return 0;
				else {
					i-=q;
					t=p;
					p=q;
					q=t-p;
				}
			}
			if(k>r[i].getKey()){
				if(p==1)return 0;
				else{
					i+=q;
					p-=q;
					q-=p;
				}
			}
		}
		return i;
	}
	/**
	 * 插值查找，表中关键词已为增序，且在(k[0],k[n+1])之间均匀分布
	 * @param r 待查找文件
	 * @param n 个数
	 * @param k 查找元素
	 * @return 成功返回k的位置，不成功返回0
	 */
	public static int  interSearch(Element[] r,int n,int k){
		int s=0,e=n+1;//s和e表示当前查找子表的下限和上限
		int i;
		while(e-s>1){
			//k的期望值
			i=(int)(Math.ceil(s+1.0*(k-r[s].getKey())/(r[e].getKey()-r[s].getKey())*(e-s-1)));
			if(k<r[i].getKey())e=i;
			if(k>r[i].getKey())s=i;
			if(k==r[i].getKey())return i;
		}
		return 0;
	}
	public static void main(String[] args){
		int num;
		Scanner s=new Scanner(System.in);
		System.out.println("请输入文件个数：");
		num=s.nextInt();
		Element[] e=new Element[num+2];
		System.out.println("请依次输入文件关键词：");
		e[0]=new Element();
		e[0].setKey(0);
		e[num+1]=new Element();
		e[num+1].setKey(13);
		for(int i=1;i<num+1;i++){
			e[i]=new Element();
			e[i].setKey(s.nextInt());
		}
		System.out.println("请输入你要查找的文件关键词：");
		System.out.println(Search.interSearch(e, num, s.nextInt()));
		System.out.println(Search.seqSearch(e, num, s.nextInt()));
		System.out.println(Search.quickSearch(e, num, s.nextInt()));
		System.out.println(Search.quickerSearch(e, num, s.nextInt()));
		System.out.println(Search.sortedSearch(e, num, s.nextInt()));
		System.out.println(Search.binSearch(e, num, s.nextInt()));
		System.out.println(Search.unanBinSearch(e, num, s.nextInt()));
		int[] delta=new int[num];
		Search.calDelta(delta, num);
		System.out.println(Search.conBinSearch(e, num, s.nextInt(), delta));
		int[] fib=new int[num];
		Search.fibonacci(fib, num);
		int m=0;
		while(fib[m+1]-1!=num){
			m++;
		}
		System.out.println(Search.fibSearch(e, m, s.nextInt(), fib));
	}
}

测试结果：


liangxiamoyi
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中五种常见的查找方式
fggugcfw的博客
06-11 1498
基本查找也叫做顺序查找顺序查找也称为线形查找，属于无序查找算法。从数据结构线的一端开始，顺序扫描，依次将遍历到的结点与要查找的值相比较，若相等则表示查找成功；若遍历结束仍没有找到相同的，表示查找失败说明：顺序查找适合于存储结构为数组或者链表。
Java 查找方法
小旺财的博客
02-20 588
但是排序之后，会改变原有数据的顺序，查找出来元素位置跟原来的元素可能是不一样的，所以排序之后再查找只能判断当前数据是否在容器当中，返回的索引无实际的意义。：对于表长较大，而关键字分布又比较均匀的查找表来说，插值查找算法的平均性能比折半查找要好的多。反之，数组中如果分布非常不均匀，那么插值查找未必是很合适的选择。：也称为是折半查找，属于有序查找算法。说明：元素必须是有序的，从小到大，或者从大到小都是可以的。代码跟二分查找类似，只要修改一下mid的计算方式即可。说明要查找的数字在中间节点左边。
在Java中实现用户界面和搜索功能，通常我们会结合使用Swing或JavaFX等GUI框架来构建用户界面
最新发布
BLOG域名:programb.blog.csdn.net
03-26 299
在Java中实现用户界面和搜索功能，通常我们会结合使用Swing或JavaFX等GUI框架来构建用户界面，以及可能使用数据库技术来支持搜索功能。搜索功能的具体实现取决于你的数据存储方式。如果你的音乐数据存储在文件中，你可能需要遍历文件并查找匹配的项。如果你的数据存储在数据库中，你将需要编写SQL查询来执行搜索。根据你的UI设计，你可能有一个列表组件（如JList）来显示搜索结果。在实际应用中，你可能需要处理更复杂的搜索逻辑，如模糊搜索、正则表达式。// 更新UI以显示搜索结果，例如更新一个列表组件。
java实现like高效_like动态查询结果集的实现！
weixin_39805883的博客
03-01 1530
有这么一个需求，有个sys_org表 可见这个code可以like查询所有子集没有什么问题，就是根据一个code值查询这个code自己包括所有子集，这时候只需要一个like就能很简单的查询出来，但是现在有个中间表paper_org如下结构， 首先根据试卷id查出所有的code来，然后再根据这些code查询出所有子集来，这时候再用like会直接报错！那么该怎么查询呢，第一种先查询所有的code来然后...
第07讲：Java操作之ElasticSearch高级查询
分享日常工作技术
01-09 1083
运行结果： 运行结果： 运行结果： 运行结果： 运行结果： 运行结果： 运行结果： 运行结果： 运行结果： 运行结果： 运行结果：
顺序查找-Java实现
12-22
在进行java web程序开发过程中，经常遇到这种问题，修改一个java文件（*.java），需要重启web服务器（如tomcat，weblogic等），部署项目。而起/停服务器浪费了大量的时间。在小项目中，也许我们感觉不到。但对于公司...
java实现查找替换功能
08-26
主要为大家详细介绍了java实现查找替换功能，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Java实现的快速查找算法示例
08-29
Java实现的快速查找算法示例 Java实现的快速查找算法示例是指通过Java语言实现的快速查找算法，旨在解决查找问题的高效解决方案。快速查找算法是指在一个数组中查找第k个大的数的算法，通过将数组分成两部分，左边...
Java实现二分查找算法实例分析
09-03
在Java中，二分查找可以使用递归或循环两种方式来实现。 1. **递归二分查找**： 递归版本的代码如下所示： ```java public static int binSearch(int arr[], int start, int end, int sear) { int mid = (end ...
折半查找2.java 使用java实现
12-14
折半查找 使用java实现
java学生成绩查询系统
11-29
java学生成绩查询系统，链接mysql，对学生数据进行排序，增删改查，以及关键字查找等功能
关键字查询AC算法 +（java）
05-21
关键字查询AC算法（java）+报告
搜索引擎 基于java的搜索引擎
04-29
实现了简单的搜索引擎，爬虫，网页处理 建立正派索引，倒排索引，实现检索
搜索功能设计java实现
01-14
搜索功能设计java实现能够完成功能搜索，支持用户业务上的搜索操作搜索功能设计java实现能够完成功能搜索，支持用户业务上的搜索操作
Java中操作数据库查询数据
热门推荐
他的博客
06-08 1万+
Java操作数据库查询数据的大概流程： 1）创建数据库连接（这里用的是MySQL数据库） private static String driver = "com.mysql.jdbc.Driver"; String url = "jdbc:mysql://localhost:3306/test"; //数据源(mysql)的连接地址 String user = "root"; //用户名 Str...
java中的几种基础排序,查找方法
skyfred的博客
09-14 639
（目前只整理了一种方法，后面有空继续整理） 1：冒泡排序： public static void main(String[] args){ int[] array={1,3,7,3,8,4,0,4,3,8,5,6}; /** * 冒泡排序，见名思意就是：每次选择一个数作为目标操作数，和下一个数字比较，选择较大或者较小的往后移位。
山东理工大学ACM平台题答案 1134 数列求和
SOHOCODE
11-17 5046
数列求和 Time Limit: 1000ms   Memory limit: 4096K  有疑问？点这里^_^ 题目描述 数列求和是一类常见的问题，本题有一定的代表性： 求s=a+aa+aaa+aaaa+……+aa…aa(n位） 其中，a的值由键盘输入，位数n也由键盘输入。 输入 第一行输入a的值； 第二行输入位数n。 输出 输出对n个数完成求和运算后的结果。
二叉查找树java实现
06-02
好的，下面是一份基本的二叉查找树的 Java 实现代码： ``` public class BinarySearchTree { private Node root; private class Node { private int key; private Node left; private Node right; public Node(int key) { this.key = key; this.left = null; this.right = null; } } public BinarySearchTree() { root = null; } public void insert(int key) { root = insert(root, key); } private Node insert(Node node, int key) { if (node == null) { node = new Node(key); return node; } if (key < node.key) { node.left = insert(node.left, key); } else if (key > node.key) { node.right = insert(node.right, key); } return node; } public void delete(int key) { root = delete(root, key); } private Node delete(Node node, int key) { if (node == null) { return null; } if (key < node.key) { node.left = delete(node.left, key); } else if (key > node.key) { node.right = delete(node.right, key); } else { if (node.left == null) { return node.right; } else if (node.right == null) { return node.left; } node.key = findMin(node.right).key; node.right = delete(node.right, node.key); } return node; } private Node findMin(Node node) { while (node.left != null) { node = node.left; } return node; } public boolean search(int key) { return search(root, key); } private boolean search(Node node, int key) { if (node == null) { return false; } if (key == node.key) { return true; } else if (key < node.key) { return search(node.left, key); } else { return search(node.right, key); } } public void inorderTraversal() { inorderTraversal(root); } private void inorderTraversal(Node node) { if (node != null) { inorderTraversal(node.left); System.out.print(node.key + " "); inorderTraversal(node.right); } } } ``` 这份代码实现了二叉查找树的基本操作，包括插入、删除、搜索和中序遍历。你可以根据自己的需求进行修改和拓展。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值