经典算法二分查找循环实现Java版

二分查找

定义

二分查找(Binary Search)又称折半查找,它是一种效率较高的查找方法。

要求

(1)必须采用顺序存储结构
(2)必须按关键字大小有序排列

查找思路

首先将给定值K,与表中中间位置元素的关键字比较,若相等,返回该元素的存储位置;若不等,这所需查找的元素只能在中间数据以外的前半部分或后半部分中。然后在缩小的范围中继续进行同样的查找。如此反复直到找到为止。

适用情况

该查找方法仅适合于线性表的顺序存储结构,不适合链式存储结构,且要求元素按关键字有序排列。

优缺点

虽然二分查找的效率高,但是要将表按关键字排序。而排序本身是一种很费时的运算。既使采用高效率的排序方法也要花费O(nlgn)的时间。二分查找只适用顺序存储结构。为保持表的有序性,在顺序结构里插入和删除都必须移动大量的结点。因此,二分查找特别适用于那种一经建立就很少改动、而又经常需要查找的线性表。

非递归实现代(还有一种用递归实现的二分查找)

Java代码如下(自己写的,有兴趣的可以查看Java源码):

import java.util.Arrays;

public class BinarySearch {

    public static void main(String[] args) {
        // 测试代码
        int[] arr = { 4, 58, 69, 54, 2, 48, 62, 78 };

        // 对数组进行排序,以便使用二分查找(也称折半查找),并打印排序后的数组,
        System.out.println(Arrays.toString(arr));
        System.out.println(myBinarySearch(arr, 69));
    }

    /**
     * @param arr    操作数组
     * @param target 查找目标
     * @return 查找到,返回目标在数组中的索引,没找到返回-1
     */
    public static int myBinarySearch(int[] arr, int target) {
        int start = 0;// 开始查找的索引
        int end = arr.length - 1;// 结束查找的索引

        while (start <= end) {
            int mid = (start + end) / 2;

            if (target == arr[mid]) {
                return mid;
            }
            if (target > arr[mid]) {
                start = mid + 1;
            }
            if (target < arr[mid]) {
                end = mid - 1;
            }
        }
        // 没找到返回-1
        return -1;
    }// myBinarySearch

}

原文地址:https://www.cnblogs.com/zxfei/p/10740512.html

时间: 2024-08-27 05:38:00

经典算法二分查找循环实现Java版的相关文章

[经典算法] 二分查找

题目说明: 二分查找法是对一组有序的数字中进行查找,传递相应的数据,进行比较查找到与原数据相同的数据,查找到了返回对应的数组下标,失败返回-1. 题目解析: 二分查找又称折半查找,优点是比较次数少,查找速度快,平均性能好:其缺点是要求待查表为有序表,且插入删除困难.因此,折半查找方法适用于不经常变动而查找频繁的有序列表. 二分查找可以解决(预排序数组的查找)问题:只要数组中包含T(即要查找的值),那么通过不断缩小包含T的范围,最终就可以找到它.其算法流程如下: 1.一开始,范围覆盖整个数组. 2

查找算法-二分查找

查找算法-二分查找 标题 二分查找也称折半查找(Binary Search),它是一种效率较高的查找方法.但是,折半查找要求线性表必须采用顺序存储结构,而且表中元素按关键字有序排列. 过程 首先,假设表中元素是按升序排列,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功:否则利用中间位置记录将表分成前.后两个子表,如果中间位置记录的关键字大于查找关键字,则进一步查找前一子表,否则进一步查找后一子表.重复以上过程,直到找到满足条件的记录,使查找成功,或直到子表不存在为止,此时查找

八大排序算法二分查找

import java.util.ArrayList;import java.util.Arrays;import java.util.List; import org.junit.Test; public class InsertSort { public static void display(int[] arr){ System.out.print("["); for(int i=0;i<arr.length;i++){ if(i == arr.length-1){ Sys

初级算法:二分查找

如果有这样一个列表,让你从这个列表中找到66的位置,你要怎么做? l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88] 你说,so easy! l.index(66)... 我们之所以用index方法可以找到,是因为python帮我们实现了查找方法.如果,index方法不给你用了...你还能找到这个66么?   上面这个方法就实现了从一个列表中找到66所在的位置了. 但我们现在是怎么找到这个数的

oldboy seventeenth day. I love Python. 万恶之神: 递归; 初始算法: 二分查找;

一, 昨日内容讲解 内置函数:重点说几个: max(*args,key=None) min(*args,key=None) zip(*args,key=None) sorted(*args,key=None,reverse=False) reversed() 翻转 返回的是迭代器 filter(key,*args) map(key,*args) 匿名函数: lambda x: x*x二, 作业讲解 三, 今日内容 递归: 设置递归次数: import sys sys.setrecursionli

入门算法-二分查找,二分排序,插入排序,冒泡排序

1.二分查找(nlogn) 二分查找,需要将业务模拟一个有序数组.然后查找某个值在该数组中的位置. 二分查找的关键是: 1)查找的值一定在某次的范围中间.即使值是最后一个,也要按照二分法的规则去查找. 2)有左右边界的查找范围作为一个循环不变式 function bsearch(A, x) { // A 是有序升数组:x是待查值; 结果要返回x在A中的位置 // 循环不变式 let l = 0,r = A.length-1, guess; while(i <= r) { guess = Math

经典算法学习——非循环双向链表实现冒泡排序(不带头结点)

我在前面两篇博客<经典算法学习--单链表(不带头结点)实现冒泡排序><经典算法学习--单链表实现冒泡排序(带头结点)>中详细描述了分别使用带头结点和不带头结点的单链表实现了冒泡排序,让我们对单链表和冒泡排序有了理性的认识.今天我们将会来使用不带头结点的非循环双向链表来实现冒泡排序,在处理过程中,这种冒泡比前面两种更为简单高效.代码上传至 https://github.com/chenyufeng1991/DoubleLinkedList_BubbleSort . 核心代码如下: /

检索算法——二分查找

如果要查找的数据是有序的, 二分查找算法比顺序查找算法更高效. function insertionSort(arr) { var temp, inner; for ( var outer = 1; outer < arr.length; ++outer) { temp = arr[outer]; //选中一个值作为临时值,使得其前面的数依次与它进行比较 inner = outer; while (inner > 0 && (arr[inner - 1] >= temp)

算法----二分查找算法

二分查找算法是在有序数组中用到的较为频繁的一种算法,在未接触二分查找算法时,最通用的一种做法是,对数组进行遍历,跟每个元素进行比较,其时间为O(n).但二分查找算法则更优,因为其查找时间为O(lgn),譬如数组{1, 2, 3, 4, 5, 6, 7, 8, 9},查找元素6,用二分查找的算法执行的话,其顺序为: 1.第一步查找中间元素,即5,由于5<6,则6必然在5之后的数组元素中,那么就在{6, 7, 8, 9}中查找, 2.寻找{6, 7, 8, 9}的中位数,为7,7>6,则6应该在7