Java实现二分查找

public class BinarySearch {
        /**
        * 二分查找算法
        *
        * @param srcArray 有序数组
        * @param key 查找元素
        * @return key的数组下标,没找到返回-1
        */
        public static void main(String[] args) {
            int srcArray[] = {3,5,11,17,21,23,28,30,32,50,64,78,81,95,101};
            System.out.println(binSearch(srcArray, 0, srcArray.length - 1, 81));
        } 

        // 二分查找递归实现
        public static int binSearch(int srcArray[], int start, int end, int key) {   

            int mid = (end - start) / 2 + start;
            if (srcArray[mid] == key) {
                return mid;
            }
            if (start >= end) {
                return -1;
            } else if (key > srcArray[mid]) {
                return binSearch(srcArray, mid + 1, end, key);
            } else if (key < srcArray[mid]) {
                return binSearch(srcArray, start, mid - 1, key);
            }
            return -1;
        } 

        // 二分查找普通循环实现
        public static int binSearch(int srcArray[], int key) {
            int mid = srcArray.length / 2;
            if (key == srcArray[mid]) {
                return mid;
            }   

            int start = 0;
            int end = srcArray.length - 1;
            while (start <= end) {
                mid = (end - start) / 2 + start;
                if (key < srcArray[mid]) {
                   end = mid - 1;
                } else if (key > srcArray[mid]) {
                    start = mid + 1;
                } else {
                    return mid;
                }
            }
            return -1;
        }
    }

时间: 2024-12-07 22:04:27

Java实现二分查找的相关文章

Java 实现二分查找\折半查找

二分查找又称折半查找,优点是比较次数少,查找速度快:其缺点是要求待查表为有序表,且插入删除困难.因此,折半查找方法适用于不经常变动而查找频繁的有序列表. 该算法要求: 1.  必须采用顺序存储结构. 2.  必须按关键字大小有序排列. 该算法时间复杂度最坏为:O(logn) 注意点有mid.low.high 其Java实现代码如下(该代码有缺陷,只是基本实现,有待完善): public class BinarySearch { /** * @param args */ public static

Java数组二分查找

二分查找法一般指二分查找 二分查找又称折半查找,优点是比较次数少,查找速度快,平均性能好:其缺点是要求待查表为有序表,且插入删除困难.因此,折半查找方法适用于不经常变动而查找频繁的有序列表.首先,假设表中元素是按升序排列,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功:否则利用中间位置记录将表分成前.后两个子表,如果中间位置记录的关键字大于查找关键字,则进一步查找前一子表,否则进一步查找后一子表.重复以上过程,直到找到满足条件的记录,使查找成功,或直到子表不存在为止,此时查找

java 实现二分查找法

/** * 二分查找又称折半查找,它是一种效率较高的查找方法. [二分查找要求]:1.必须采用顺序存储结构 2.必须按关键字大小有序排列. * @author Administrator * */ 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))

java,二分查找法,网上查阅

二分查找又称折半查找,它是一种效率较高的查找方法. 折半查找的算法思想是将数列按有序化(递增或递减)排列,查找过程中采用跳跃式方式查找,即先以有序数列的中点位置为比较对象,如果要找的元素值小于该中点元素,则将待查序列缩小为左半部分,否则为右半部分.通过一次比较,将查找区间缩小一半. 折半查找是一种高效的查找方法.它可以明显减少比较次数,提高查找效率.但是,折半查找的先决条件是查找表中的数据元素必须有序. 折半查找法的优点是比较次数少,查找速度快,平均性能好;其缺点是要求待查表为有序表,且插入删除

java 冒泡排序 二分查找

下面这个程序是先定义一个整型数组,然后将其中的元素反序赋值,再用冒泡排序进行排序以后用二分查找来查找其中是否有某个数,返回值为-1时表示这个数可能小于这个数组的最小值或大小这个数组的最大值,-2表示这个数比这个数组的最小值大,最大值小,但是数组中不包含这个数,代码如下: package com.jll.sort; public class ErFenSort {    static int[] unsorted;    public static void main(String[] args)

Java的二分查找

今天学习了二分查找,虽然代码简单,但还是要有必要,记录一下今天的学习的. 1 public class TestBrinarySeach { 2 public static void main(String[] args) { 3 int[] arr = {24,32,15,56,39,44,87,65,59}; 4 Arrays.sort(arr); 5 6 int value = 39;//要查找的值 7 8 System.out.println(Arrays.toString(arr));

Java实现二分查找算法

二分查找:两种方式: 非递归方式和递归方式主要思路: 对于已排序的数组(先假定是从小到大排序), 先定义两个"指针", 一个"指向"首元素low, 一个"指向"末尾元素high. 然后, 开始折半比较, 即让要查找的数与数组中间的元素(索引为 low+high/2)比较. 若要查找的数比中间数小, 说明要查找的数在数组左侧(注意前提是数组从小到大排序), 否则说明该数在数组的右侧. 如果low最后还比high大,俩"指针"交叉

java基础 二分查找算法

/*   * 折半查找法:   * 思路:   * 定义三个变量记录查找范围中最大.最小和中间的索引值,每次都是使用中间索引值与要查找的目标进行对比,如果不符合,那么就不停缩小查找范围   * */  //前提:查找的序列必须是有序的  int[] arr1 = {3,5,7,10,22,45,191};  //定义三个变量记录查找的边界和中间位置,并且初始化  int min = 0;  int max = arr1.length;  int mid = (min + max)/2;  //定

Java数据结构——二分查找

import java.lang.reflect.Array; import java.nio.Buffer; import java.util.Arrays; import java.util.Random; //================================================= // File Name : Binary_Search //-------------------------------------------------------------