Java 实现二分法查找算法

算法

假如有一组数为3,12,24,36,55,68,75,88要查给定的值24.可设三个变量front,mid,end分别指向数据的上界,中间和下界,mid=(front+end)/2.  

1.开始令front=0(指向3),end=7(指向88),则mid=3(指向36)。因为mid>x,故应在前半段中查找。
2.令新的end=mid-1=2,而front=0不变,则新的mid=1。此时x>mid,故确定应在后半段中查找。
3.令新的front=mid+1=2,而end=2不变,则新的mid=2,此时a[mid]=x,查找成功。如果要查找的数不是数列中的数,例如x=25,当第三次判断时,x>a[mid],按以上规律,令front=mid+1,即front=3,出现front>end的情况,表示查找不成功。

例:在有序的有N个元素的数组中查找用户输进去的数据x。算法如下:

1.确定查找范围front=0,end=N-1,计算中项mid=(front+end)/2。

2.若a[mid]=x或front>=end,则结束查找;否则,向下继续。

3.若a[mid]<x,说明待查找的元素值只可能在比中项元素大的范围内,则把mid+1的值赋给front,并重新计算mid,转去执行步骤2;若a[mid]>x,说明待查找的元素值只可能在比中项元素小的范围内,则把mid-1的值赋给end,并重新计算mid,转去执行步骤2。

[一维数组,折半查找]2算法复杂度分析

时间复杂度

  1.最坏情况查找最后一个元素(或者第一个元素)Master定理T(n)=T(n/2)+O(1)所以T(n)=O(logn)
  2.最好情况查找中间元素O(1)查找的元素即为中间元素(奇数长度数列的正中间,偶数长度数列的中间靠左的元素)

空间复杂度:

  S(n)=n

Java实现代码

package com.leo.kang.interview;

public class BinarySearch {

	// 查找次数
	static int count;

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

		System.out.println(searchRecursive(array, 0, array.length - 1, 9));
		System.out.println(count);
		count = 0;
		System.out.println(searchLoop(array, 9));
		System.out.println(count);
	}

	/**
	 * 执行递归二分查找,返回第一次出现该值的位置
	 *
	 * @param array
	 *            已排序的数组
	 * @param start
	 *            开始位置
	 * @param end
	 *            结束位置
	 * @param findValue
	 *            需要找的值
	 * @return 值在数组中的位置,从0开始。找不到返回-1
	 */
	public static int searchRecursive(int[] array, int start, int end,
			int findValue) {
		// 如果数组为空,直接返回-1,即查找失败
		if (array == null) {
			return -1;
		}
		count++;
		if (start <= end) {
			// 中间位置
			int middle = (start + end) / 1;
			// 中值
			int middleValue = array[middle];

			if (findValue == middleValue) {
				// 等于中值直接返回
				return middle;
			} else if (findValue < middleValue) {
				// 小于中值时在中值前面找
				return searchRecursive(array, start, middle - 1, findValue);
			} else {
				// 大于中值在中值后面找
				return searchRecursive(array, middle + 1, end, findValue);
			}
		} else {
			// 返回-1,即查找失败
			return -1;
		}
	}

	/**
	 * 循环二分查找,返回第一次出现该值的位置
	 *
	 * @param array
	 *            已排序的数组
	 * @param findValue
	 *            需要找的值
	 * @return 值在数组中的位置,从0开始。找不到返回-1
	 */
	public static int searchLoop(int[] array, int findValue) {
		// 如果数组为空,直接返回-1,即查找失败
		if (array == null) {
			return -1;
		}

		// 起始位置
		int start = 0;

		// 结束位置
		int end = array.length - 1;

		while (start <= end) {
			count++;
			// 中间位置
			int middle = (start + end) / 2;
			// 中值
			int middleValue = array[middle];

			if (findValue == middleValue) {
				// 等于中值直接返回
				return middle;
			} else if (findValue < middleValue) {
				// 小于中值时在中值前面找
				end = middle - 1;
			} else {
				// 大于中值在中值后面找
				start = middle + 1;
			}
		}
		// 返回-1,即查找失败
		return -1;
	}
}

  

时间: 2024-11-05 17:50:27

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

Java中的二分法查找算法

[ 什么是二分查找 ]  二分查找又称为折半查找,该算法的思想是将数列按序排列,采用跳跃式方法进行查找,即先以有序数列的中点位置为比较对象, 如果要找的元素值小于该中点元素,则将待查序列缩小为左半部分,否则为右半部分.以此类推不断缩小搜索范围. [ 二分查找的条件 ] 二分查找的先决条件是查找的数列必须是有序的. [ 二分查找的优缺点 ] 优点:比较次数少,查找速度快,平均性能好: 缺点:要求待查数列为有序,且插入删除困难: 适用场景:不经常变动而查找频繁的有序列表. [ 算法步骤描述 ] ①

java的二分法查找数据

Java二分法查找的源代码:    二分查找是一种高效率线性表的查找算法.在查找时必须将线性表中的关键词排好序.基本思路是:先断定线性表的中心方位 mid=(first+last)/2:对比所要查找的关键词 key与中心方位的关键词的巨细,假如比key和mid.key持平则回来: key比mid.key大(假定为升序)这所要查找的关键词在mid和last之间:否则在first与mid之间.持续按照上面办法查找中心元素,直到找到为止.    详细完成如下package com.cgogo; /**

Java中的查找算法之顺序查找(Sequential Search)

Java中的查找算法之顺序查找(Sequential Search) a) 原理:顺序查找就是按顺序从头到尾依次往下查找,找到数据,则提前结束查找,找不到便一直查找下去,直到数据最后一位. b) 图例说明: 原始数据:int[] a={4,6,2,8,1,9,0,3}; 要查找数字:8 找到数组中存在数据8,返回位置. 代码演示: import java.util.Scanner; /* * 顺序查找 */ public class SequelSearch { public static vo

数据结构Java版之查找算法(三)

关于查找算法,这里只进行两个算法的说明.包括 顺序查找 和 折半查找. 顺序查找: 顺序查找常用于未排序的数据中.查找速度较慢,只能应用于较小的数据量. public int sequentialSearch(int[] list, int ele) { for(int i = 0; i < list.length; i ++) { if(ele == list[i]) return i; } return -1; } 折半查找: 比较快的查找算法,但也仅限于对排好序的数据进行查找. publi

java基础 二分查找算法

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

二分法查找算法

package SuanFa; import java.text.SimpleDateFormat; import java.util.Date; public class Demo1 { public static void main(String []args){ int []arr={1,3,5,7,9,11,12,13,15,16,18,19,20}; int a=rank(100,arr); System.out.println(a); System.out.println(new S

Java实现二分查找算法

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

Java实现二分法查找数组

public class binarySearchTest { public static void main(String[] args) { int[] a = {1,5,9,36,49,89,102}; int c = 49; int pos = binarySearch(a,c); System.out.println(pos); } private static int binarySearch(int[] a, int c) { if(a.length == 0) return -1

I学霸官方免费教程二十九:Java查找算法之二分法查找

二分法查找算法 基本步骤:    第一步:获取数组中间的下标    第二步:中间下标处的值和目标值比较,如果目标值大,说明要找的值在数组的后边一半中    第三步:再次获取数组右边一半的中间下标    第四步:再次用获得的中间下标和目标值进行比较    后续步骤以此类推,这样每次查找都在"半份"数据中进行,所以又叫折半查找.这也是为什么使用二分法查找之前必须要对数组进行排序的原因.如果不排序,将无法判断目标值在哪"半份"中 实例: package algorithm