精华内容
下载资源
问答
  • 主要介绍了Java实现的快速查找算法,结合具体实例形式分析了快速查找算法的原理与相关实现技巧,需要的朋友可以参考下
  • java实现折半查找算法

    2019-12-06 17:27:55
    所谓的二分查找,指的是将待查的数据序列而分化,然后对比中间中间值和要查找值,判断结果,相等则找到,小于则在左边的子序列找,大于则在右边的子序列找
  • java 几种查找算法

    2014-03-06 16:44:08
    java 几种查找算法
  • Java 二分查找 算法

    2014-07-04 10:38:46
    Java 二分查找算法的示例代码。 欢迎访问个人博客。 http://blog.csdn.net/evanwang1987
  • Java 查找算法

    万次阅读 2015-07-08 19:49:15
    二分查找 Hash表 二叉树 B Tree

    这个问题有几个点要先确认

    • 必须是有序,如果无序的话就只能全遍历了
    • 查找算法跟数据结构相关,不同的数据结构适用于不同的查找算法
    • 查找算法与磁盘I/O有一定的关系,比如数据库在索引排序的时候,如果每次都从磁盘读取一个节点然后进行判断

    数组

    如果知道下标的话就方便了,查找的复杂度为1.
    如果是针对值的查找,那么顺序遍历是O(n),

    二分查找

    使用二分查找的话可以减少时间复杂度为:O(logn)

    /**
     * 二分查找又称折半查找,它是一种效率较高的查找方法。 
      【二分查找要求】:1.必须采用顺序存储结构 2.必须按关键字大小有序排列。
     * @author wzj
     *
     */
    public class BinarySearch { 
        public static void main(String[] args) {
            int[] src = new int[] {1, 3, 5, 7, 8, 9}; 
            System.out.println(binarySearch(src, 3));
            System.out.println(binarySearch(src,3,0,src.length-1));
        }
    
        /**
         * * 二分查找算法 * *
         * 
         * @param srcArray
         *            有序数组 *
         * @param des
         *            查找元素 *
         * @return des的数组下标,没找到返回-1
         */ 
       public static int binarySearch(int[] srcArray, int des){ 
    
            int low = 0; 
            int high = srcArray.length-1; 
            while(low <= high) { 
                int middle = (low + high)/2; 
                if(des == srcArray[middle]) { 
                    return middle; 
                }else if(des <srcArray[middle]) { 
                    high = middle - 1; 
                }else { 
                    low = middle + 1; 
                }
            }
            return -1;
       }
    
          /**  
         *二分查找特定整数在整型数组中的位置(递归)  
         *@paramdataset  
         *@paramdata  
         *@parambeginIndex  
         *@paramendIndex  
         *@returnindex  
         */
        public static int binarySearch(int[] dataset,int data,int beginIndex,int endIndex){  
           int midIndex = (beginIndex+endIndex)/2;  
           if(data <dataset[beginIndex]||data>dataset[endIndex]||beginIndex>endIndex){
               return -1;  
           }
           if(data <dataset[midIndex]){  
               return binarySearch(dataset,data,beginIndex,midIndex-1);  
           }else if(data>dataset[midIndex]){  
               return binarySearch(dataset,data,midIndex+1,endIndex);  
           }else {  
               return midIndex;  
           }  
       } 
    }

    但是插入因为会涉及当前节点后的所有值得移动,一次,其时间复杂度为O(n) + O(log n)

    链表

    只能从头节点遍历, 查找的复杂度是O(n)
    插入或者是删除,因为只需要移动指针,时间复杂度为O(1) + O(n)

    树的查找,主要是先序遍历,中序等遍历方式。
    插入和删除,还是比较快
    常用的会有如下的衍生方式:

    二叉树

    二叉树的构建:

    class BinaryNode{
            int value;
            BinaryNode left;
            BinaryNode right;
            public BinaryNode(int value){
                this.value = value;
                this.left = null;
                this.right = null;
            }
    
            public void add(int value){
                if(value > this.value){
                    if(this.right != null){
                        this.right.add(value);
                    }else{
                        this.right = new BinaryNode(value);
                    }
                }else{
                    if(this.left != null){
                        this.left.add(value);
                    }else{
                        this.left = new BinaryNode(value);
                    }
                }
            }
    
            // 中序查找
            public BinaryNode get(int value){
                if(this.value == value){
                    return this;
                }
                if(this.value > value){
                    return this.left.get(value);
                }
    
                if(this.value < value){
                    return this.right.get(value);
                }
                return null;
            }
        }

    插入的复杂度本身并不高,只是简单的节点添加。但是因为寻找插入位置的查找操作的复杂度跟树的高度相关为logn,极差的情况下可能接近于线性查找。

    平衡二叉树

    平衡二叉树是尽量减少数高的二叉树,其算法中增加了左旋和右旋的操作。插入复杂度会高一些,但是会得到不错的查找性能。

    B+Tree

    学习自这里
    这个就要说一下上面说的跟磁盘I/O相关的,因此为了减少磁盘I/O。可以利用磁盘的预读特性,一次提取大概相当于一页大小的节点到内存中。
    先要说一下B-Tree.
    一个平衡的m-way查找数,其要满足如下的条件:

    • 每节点中的数据量 < m
    • 每层节点数 <= m
    • 子数节点要完全大于、小于、或者在其之间。 也就是不能越过父节点的两个值
    • 叶子节点中的值的个数>=m/2
    • 非叶子节点中的值的个数=子节点个数-1
      如下图:
      这里写图片描述
      可以看出,三个子节点的有两个值,三个子节点中的数据分别对应了小于、之间、大于这个范围

    B+Tree
    与上面的差别是:

    • 所有关键字都在叶子节点
    • 父节点存储的都是到子节点的指针
    • 会有两个入口,一个是根节点,另外一个是从最小叶子节点开始的指针
      这里写图片描述

    查找跟二叉树比较像,因为插入的时候已经是相当于二分算法了,所以只需要,递归找到就可以了。

    Hash表

    为了解决一些不容易排序,或者查找的对象。 比如图像,视频等等。
    在Java的HashMap中有使用。
    是一个链表的数组
    - 对key进行进行散列函数,求Hash值,找到其对应的链表。
    - 剩下的解决hash冲突的问题
    - 解决hash冲突,可以在命中链表之后顺序比较
    - 这里顺便再说一下一致性hash. 预置很多节点,选择最近的节点存入,可以解决增加节点数据转移的问题。

    展开全文
  • Java查找算法之顺序查找

    千次阅读 2018-01-13 19:59:19
    顺序查找又称为线性查找,是一种最简单、最基本的查找方法。 顺序查找的基本思想是从顺序表的一端开始,依次将每一个数据元素的值与关键字值key比较,若相等,则表明查找成功;若直到所有元素都比较完毕仍找不到,...

    顺序查找又称为线性查找,是一种最简单、最基本的查找方法。

    顺序查找的基本思想是从顺序表的一端开始,依次将每一个数据元素的值与关键字值key比较,若相等,则表明查找成功;若直到所有元素都比较完毕仍找不到,则表明查找失败。

    代码如下:

    public class Test {
    
        //顺序查找
        public int seqSearch(int a[], int key)
        {
            int n=a.length;
            for(int i=0; i<n; i++)
            {
                if(a[i]==key)
                    return i;
            }
            return -1;
        }
    
        public static void main(String[] args)
        {
            int[] a={ 30, 24, -3, 78, 16, 345, 84, -36, 1004, 5 };
            Test test=new Test();
            int pos=test.seqSearch(a,84);
            if(pos!=-1)
                System.out.println("84的位置下标为: "+pos);
            else
                System.out.println("找不到该数字!");
        }
    }

    顺序查找没什么难的,就简单一点了。(凡星逝水2018)


    展开全文
  • Java查找算法之折半查找

    千次阅读 2018-01-13 21:31:05
    折半查找又称为“二分查找”,算法复杂度为nlog2n。 1.折半查找思路 设有序顺序表{a[0], a[1], ......, a[n-1]},先求出查找区间中间元素下标mid,然后将该位置值a[mid]与要查找值key比较,比较结果有3种可能性...

    折半查找又称为“二分查找”,算法复杂度为nlog2n

    1.折半查找思路

    设有序顺序表{a[0], a[1], ......, a[n-1]},先求出查找区间中间元素下标mid,然后将该位置值a[mid]与要查找值key比较,比较结果有3种可能性:

    • 若key=a[mid],则查找成功,返回下标;
    • 若key<a[mid],则要查找元素在mid左侧,缩小查找区间到表前半部分再进行折半查找;
    • 若key>a[mid],则要查找元素在mid右侧,缩小查找区间到表后半部分再进行折半查找。


    2.过程示例

    3.代码实现
    递归
    //非递归
        public int binSearch(int a[], int low, int high, int key)
        {
            while(low<=high)
            {
                int mid=(low+high)/2;
                if(a[mid]==key)
                    return mid;
                else if(key<a[mid])
                    high=mid-1;
                else
                    low=mid+1;
            }
            return -1;
        }


    非递归
    //递归
        public int binRecSearch(int a[], int low, int high, int key)
        {
            if(low<=high)
            {
                int mid=(low+high)/2;
                if(a[mid]==key)
                    return mid;
                else if(key<a[mid])
                    return binRecSearch(a, low,mid-1, key);
                else
                    return binRecSearch(a,mid+1, high, key);
            }
            else
                return -1;
        }


    4.完整代码示例

    public class Test {
    
        //非递归
        public int binSearch(int a[], int low, int high, int key)
        {
            while(low<=high)
            {
                int mid=(low+high)/2;
                if(a[mid]==key)
                    return mid;
                else if(key<a[mid])
                    high=mid-1;
                else
                    low=mid+1;
            }
            return -1;
        }
    
        //递归
        public int binRecSearch(int a[], int low, int high, int key)
        {
            if(low<=high)
            {
                int mid=(low+high)/2;
                if(a[mid]==key)
                    return mid;
                else if(key<a[mid])
                    return binRecSearch(a, low,mid-1, key);
                else
                    return binRecSearch(a,mid+1, high, key);
            }
            else
                return -1;
        }
    
        public static void main(String[] args)
        {
            int[] a={ -36, -3, 5, 16, 24, 30, 78, 84, 345, 1004};
            Test test=new Test();
    
            //非递归
            int pos1=test.binSearch(a,0,a.length-1,-3);
            if(pos1!=-1)
                System.out.println("-3所在的位置下标是 "+pos1);
            else
                System.out.println("找不到该数字84!");
    
            //递归
            int pos2=test.binRecSearch(a,0,a.length-1,84);
            if(pos2!=-1)
                System.out.println("84所在的位置下标是 "+pos2);
            else
                System.out.println("找不到该数字84!");
        }
    }

    运行结果:

    要记得一点,查找的序列首先必须是有序的才能进行折半查找。而 折半查找的递归和非递归思路都是差不多的。(凡星逝水2018)

    展开全文
  • 该工具包含有Java一些比较常见的排序算法和查找算法。 排序算法包括:冒泡排序、选择排序 、插入排序、希尔排序、快速排序、归并排序、基数排序(桶排序) 查找算法包括:线性查找、二分查找、插值查询、斐波那契...
  • 四种查找算法Java

    千次阅读 2020-04-26 11:44:29
    一、线性查找算法【easy】 package search; public class SeqSearch { public static void main(String[] args) { int[] arr = {1, 3, 9, 8, 7, -1, 2}; //没有顺序的数组 int index = seqSearch(arr, 7); ...

    一、线性查找算法【easy】

    package search;
    
    public class SeqSearch
    {
    	public static void main(String[] args)
    	{
    		int[] arr = {1, 3, 9, 8, 7, -1, 2};  //没有顺序的数组
    		int index = seqSearch(arr, 7);
    		if(index == -1)
    			System.out.println("没有找到值 " + 7);
    		else
    			System.out.println("值为 " + 7 + "的下标为 " + index);
    	}
    	
    	/**
    	 * 这里我们实现的线性查找是找到一个满足条件的值,就返回
    	 * @param arr
    	 * @param value
    	 * @return
    	 */
    	public static int seqSearch(int[] arr, int value)
    	{
    		//线性查找就是逐一比对,发现有相同值就返回
    		for(int i = 0; i < arr.length; i++)
    		{
    			if(arr[i] == value)
    			{
    				return i;
    			}
    		}
    		return -1;
    	}
    }
    

     二、二分查找算法

    2.1思路

     

    2.2代码实现

    package search;
    
    public class BinarySearch
    {
    	//注意:使用二分查找的前提是该数组是有序的
    	public static void main(String[] args)
    	{
    		int[] arr = {1, 8, 10, 89, 1000, 1024, 2048};
    		
    		int findVal = 1024;
    		
    		int resIndex = binarySearch(arr, findVal, 0, arr.length - 1);
    		if(resIndex == -1)
    		{
    			System.out.println("数组中未找到值 : " + findVal);
    		}
    		else
    			System.out.println("resIndex: " + resIndex);
    		
    	}
    
    	/**
    	 * 二分查找算法
    	 * @param arr 数组
    	 * @param findVal 要查找的值
    	 * @param l 左边的索引
    	 * @param r 右边的索引
    	 * @return 如果找到就返回下标,如果没有找到,就返回-1
    	 */
    	public static int binarySearch(int[] arr, int findVal, int l, int r)
    	{
    		if(l > r)
    			return -1;
    		int mid = (l + r) / 2;
    		
    		if(findVal > arr[mid])
    			return binarySearch(arr, findVal, mid + 1, r);
    		else
    			if(findVal < arr[mid])
    			return binarySearch(arr, findVal, l, mid - 1);
    		else
    		return mid;
    	}
    }
    

    2.3二分查找算法功能完善 

    当一个有序数组中,有多个相同的数值时,如何将所有的数值都查到。

    如:[1, 9 , 88, 582, 1000, 1000, 1000, 99999]

    思路:

    1、在找到mid索引值,不要马上返回

    2、向mid索引值的左边扫描,将所有满足1000的元素的下标,加入到集合ArrayList

    3、 向mid索引值的右边扫描,将所有满足1000的元素的下标,加入到集合ArrayList

    4、将ArrayList返回

     

    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, 1000, 1024, 2048};
    		
    		int findVal = 1000;
    		
    		List<Integer> resIndex = binarySearch2(arr, findVal, 0, arr.length - 1);
    		if(resIndex == null)
    		{
    			System.out.println("数组中未找到值 : " + findVal);
    		}
    		else
    			System.out.println("resIndex: " + resIndex);
    		
    	}
    	
    	public static List<Integer> binarySearch2(int[] arr, int findVal, int l, int r)
    	{
    		if(l > r)
    			return new ArrayList<Integer>();
    		int mid = (l + r) / 2;
    		
    		if(findVal > arr[mid])
    			return binarySearch2(arr, findVal, mid + 1, r);
    		else
    			if(findVal < arr[mid])
    			return binarySearch2(arr, findVal, l, mid - 1);
    		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 = temp - 1; //左移
    			}
    			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 = temp + 1; //左移
    			}
    			return resIndexlist;
    		}
    	}
    }
    

    三、插值查找算法 

    3.1工作原理 

     

    3.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;
    		}
    		System.out.println(Arrays.toString(arr));
    		
    		int index = insertValueSearch(arr, 0, arr.length - 1, 1);
    		System.out.println("index: " + index);
    	}
    	
    	//编写插值算法
    	//插值查找算法,也是要求数组是有序的
    	/**
    	 * 
    	 * @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;
    		}
    	}
    
    }
    

     

     

    四、斐波那契数列 

     

    展开全文
  • 查找算法总结-java

    千次阅读 2019-05-31 11:05:47
    查找算法分类 平均查找长度(Average Search Length,ASL) 顺序查找 顺序查找的基本思想 顺序查找的代码 顺序查找的复杂度 二分查找 二分查找的基本思想 二分查找的代码 二分查找的复杂度 插值查找 插值...
  • java查找算法(一)--顺序查找

    千次阅读 2016-03-21 14:08:42
    对给定数组(字符串)顺序进行查找元素是否存在。public class SeqSearch { public static void main(String args[]){ int [] array={32,5,67,6,1,7}; int data=6; Sy
  • 这是一个百度面试的题目,乱序给出从1到1000的999个数,其中有一个数丢失了,找出这个数,给出了3种解决方法,并给出的运行时间,对比了3种方案优劣
  • Java常见算法之二分法查找算法详解

    千次阅读 2018-10-19 21:55:43
    二分法查找,是在已经排好序的序列中,定义一个起始位置start(即序列第一个元素)和一个终止位置end(即序列最后一个元素),通过mid=(start+end)/2计算出中间位置,通过待查找元素与mid中间位置的元素进行比较,如果待...
  • 常见查找算法Java代码实现)

    万次阅读 2018-12-27 10:25:32
    尊重原创,转载请标明出处...查找算法中顺序查找算是最简单的了,无论是有序的还是无序的都可以,只需要一个个对比即可,但其实效率很低。我们来看下代码 public static int search(int[] a, int key...
  • 二分法查找 *进行二分法查找的前提是数组已有序 *查找范围的上下界
  • java选择算法、java查找算法汇总

    千次阅读 2017-02-07 13:44:09
    线性查找顺序查找适合于存储结构为顺序存储或链接存储的线性表public static int query(int[] arrays, int target){ for(int i = 0 ;i ; i ++){ if(arrays[i] == target)return i; } return -1;//没找到 }线性...
  • java实现常见查找算法

    万次阅读 多人点赞 2017-06-15 22:04:44
    查找(Searching)就是根据给定的某个值,在查找表中确定一个其关键字等于给定值的数据元素(或记录)。 在互联网上查找信息是我们的家常便饭。所有这些需要被查的数据所在的集合,我们给它一个统称叫查找表。 查找表...
  • Java查找算法有哪些?

    千次阅读 2021-10-09 09:05:33
    8.1 查找算法介绍 在 java 中,我们常用的查找有四种: 顺序(线性)查找 二分查找/折半查找 插值查找 斐波那契查找 8.2 线性查找算法 有一个数列: {1,8, 10, 89, 1000, 1234} ,判断数列中是否包含此名称【顺序查找...
  • Java查找算法--线性查找

    千次阅读 2016-09-20 19:53:13
    线性查找二分查找(折半查找)分块查找 线性查找思路:  在待查数据中进行顺序性轮询查找,当存在待查的数据时返回当前数据索引位置,如果不存在则返回不存在表示-1,技巧为了增加效率减少主要代码的操作,可以...
  • 折半查找算法折半查找(Binary Search)又称为二分查找,其要求数据序列呈线性结构,也就是经过排序的。对于没有经过排序的,可以查阅我之前的排序算法文章进行预排序,然后进行折半查找操作。譬如数组{1,2, 3, 4,...
  • 主要介绍了Java实现二分查找算法,实例分析了二分查找算法的原理与相关实现技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • Java查找算法总结

    千次阅读 2017-03-28 16:19:37
    常见查找算法:顺序查找,二分查找,哈希表查找,二叉排序树查找。 具体内容有空再写
  • Java查找算法之顺序查找说明:顺序查找适合于存储结构为顺序存储或链接存储的线性表。 下面我们来详细说明下
  • 详细介绍了常见的4种查找算法,比如顺序查找/线性查找、二分查找/折半查找、插值查找、斐波那契查找等,并且提供了相应的Java代码实现。
  • 数据结构Java版的查找算法实现

    千次阅读 2017-08-16 15:26:36
    import java.util.Arrays; import java.util.HashMap; import java.util.Iterator; import java.util.Set; /** * 查找的基本算法: * - 顺下查找 * -基于线性表的查找(静态查找)- 折半
  • 主要介绍了Java二分查找算法实现代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了java算法之二分查找法的实例详解的相关资料,这里提供简单实例帮助大家学习理解这部分内容,需要的朋友可以参考下
  • 主要介绍了Java实现的两种常见简单查找算法,结合具体实例形式分析了java快速查找与二分查找的原理与简单实现技巧,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 242,946
精华内容 97,178
关键字:

java查找算法

java 订阅