java二分法算法

1. 怎么计算java二分法查找的比较次数

您好，我来为您解答：
算法：当数据量很大适宜采用该方法。采用二分法查找时，数据需是有序不重复的。 基本思想：假设数据是按升序排序的，对于给定值 x，从序列的中间位置开始比较，如果当前位置值等于 x，则查找成功；若 x 小于当前位置值，则在数列的前半段中查找；若 x 大于当前位置值则在数列的后半段中继续查找，直到找到为止。
希望我的回答对你有帮助。

2. Java二分法

首先得告诉你，二分法的前提是必须是顺序方式存储，而且必须是排好序了的。比如要从100个数中查找某一个数，前提是这一百个数是排好序（这里假如从小到大）的，然后找到最中间的数，若最中间的数（这里是第50个）比你要找的这个数大那你只需要在1到49个数里找，然后再取最中间的数，再判断，如此往复下去，最多次数，你算算看，

3. java 二分法 排序

二分排序就是用先用二分查找法来查某一个元素，然后再用别的排序算法来进行排序。

package insert;

public class InsArrayApp {
public static void main(String[] args) {
int size = 100;
InsArray arr = new InsArray(size);

arr.insert(10);
arr.insert(9);
arr.insert(8);
arr.insert(7);
arr.insert(6);
arr.insert(10);
arr.insert(9);
arr.insert(8);
arr.insert(5);
arr.insert(4);
arr.insert(3);
arr.insert(2);
arr.insert(1);

arr.display();

// arr.insertSort();

// arr.display();

// System.out.println(arr.median());

// arr.noDups();

arr.noDups2();
arr.display();
}
}

class InsArray {
private int[] a;
private int nElems;

public InsArray(int size) {
a = new int[size];
nElems = 0;
}

public void insert(int value) {
a[nElems] = value;
nElems++;
}

public void display() {
for (int i = 0; i < nElems; i++) {
System.out.print(a[i] + " ");
}
System.out.println();
}

public void insertSort() {
int out, in;
int = 0;
int compare = 0;
/* for(out = 1;out<nElems;out++){
int tmp = a[out];
in = out;
while(in>0&&a[in-1]>=tmp){
a[in] = a[in-1];
--in;
}
a[in] = tmp;
}*/
for(out = 1;out<nElems;out++){
int tmp = a[out];
in = out;
while(in>0){
if(a[in-1]>=tmp){
a[in] = a[in-1];
--in;
++;
++compare;}
else{
break;
}
}
++compare;
a[in] = tmp;
}
System.out.println(":" + + "compare:" + compare);
}

public int median(){
insertSort();
int m = nElems/2;
return a[m];
}

public void noDups(){
insertSort();
/*
InsArray tmp = new InsArray(nElems);
for(int i = 0;i<nElems;i++){
for(int j = i+1;j<nElems;j++)
if(a[i] == a[j]){
a[j] = -1;
}
if(a[i]!=-1)
tmp.insert(a[i]);
}
*/
InsArray tmp = new InsArray(nElems);
int i;
for(int j = 0;j<this.nElems;j++){
/*if(tmp.nElems==tmp.find(this.a[j])) //binary find
tmp.insert(this.a[j]);
else
continue;*/
for( i = 0; i < tmp.nElems; i++) { // for each element
if(tmp.a[i]==this.a[j]) // found searchKey?
break;
}
if(i==tmp.nElems) // no
tmp.insert(this.a[j]);
}
this.a = tmp.a;
this.nElems = tmp.nElems;
}

public int find(long searchKey) {
int lowerBound = 0;
int upperBound = nElems-1;
int curIn;

while(true) {
curIn = (lowerBound + upperBound)/2;
if(a[curIn]==searchKey)
return curIn;
else if(lowerBound>upperBound)
return nElems;
else {
if(a[curIn]>searchKey)
upperBound = curIn-1;
else
lowerBound = curIn+1;
}
}
}

public void noDups2(){
insertSort();
for(int i = 0;i<nElems;i++){
for(int j = i+1;j<nElems;j++)
if(a[i] == a[j]){
a[j] = -1;
}
}
display();
int index = 0;
for(int i=0;i<nElems;i++){
if(a[i]!=-1){
index++;
}else{
for(int j=index+1;j<nElems;j++){
if(a[j]!=-1){
a[index] = a[j];
a[j]=-1;
index++;
break;
}
}
}
}
nElems = index;

}
}

上面的代码，是我以前敲的，有个find()方法是二分查找，然后再用插入排序去进行排序。

4. Java基础 递归二分法

如果都不满足条件呢 可能你能确定一定会满足其中一个 可是程序不能确定是不是一定会满足其中一个 又不知道如果不满足要返回什么 所以报错啦

5. JAVA 二分法

二分法的算法一次查找剩下一半元素，那么，最大比较次数，就是去到只剩下一个为止。
所以100除以2，除以几次能小于等于1呢？
所以答案是7..

6. java计算2分法查找次数

2分法查找，前提是要有序，要排序，必然要比较大小，所以只要一个类它实现了Comparable接口的compareTo(T
o)方法（Comparable在java.lang包中）或是实现一个比较器对象接口Comparator(Comparator在java.util包)，都可以进行比较了。不管是String型,计本数据类型,还是其他什么的，都可以用2分发查找了。给你看看API
java．util．Collections中2分法的API
binarySearch
public
static
<T>
int
binarySearch(List<?
extends
Comparable<?
super
T>>
list,
T
key)使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据列表元素的自然顺序对列表进行升序排序（通过
sort(List)
方法）。如果没有对列表进行排序，则结果是不确定的。如果列表包含多个等于指定对象的元素，则无法保证找到的是哪一个。
此方法对“随机访问”列表运行
log(n)
次（它提供接近固定时间的位置访问）。如果指定列表没有实现
RandomAccess
接口并且是一个大型列表，则此方法将执行基于迭代器的二分搜索，执行
O(n)
次链接遍历和
O(log
n)
次元素比较。
参数：
list
-
要搜索的列表。
key
-
要搜索的键。
返回：
如果搜索键包含在列表中，则返回搜索键的索引；否则返回
(-(插入点)
-
1)。插入点
被定义为将键插入列表的那一点：即第一个大于此键的元素索引；如果列表中的所有元素都小于指定的键，则为
list.size()。注意，这保证了当且仅当此键被找到时，返回的值将
>=
0。
抛出：
ClassCastException
-
如果列表中包含不可相互比较
的元素（例如，字符串和整数），或者搜索键无法与列表的元素进行相互比较。

7. java泛型 二分查找

以下代码是关于对象的 二分查找 的例子，已经测试通过，执行即可。
Student 是基本比较对象类
Dichotomy 是二分法执行类
Test 是测试类

package com.dichotomy;

public class Student implements Comparable<Student> {

private int id;
private String name;
private String idCard;
private String sex;
private String mobile;

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getIdCard() {
return idCard;
}

public void setIdCard(String idCard) {
this.idCard = idCard;
}

public String getSex() {
return sex;
}

public void setSex(String sex) {
this.sex = sex;
}

public String getMobile() {
return mobile;
}

public void setMobile(String mobile) {
this.mobile = mobile;
}

/**
* 排序控制
* @param o1 Student
* @param o2 Student
* @return int 返回 -1 向前移动, 1 向后移动, 0 不移动
* 这个方法需要自己进行调整，排序比较和二分查找时均使用此方法进行位置调整
* 比较时使用的key自己可以进行修改，不过要保证唯一性，否则查询出来的值会不准确
*/
public int compareTo(Student o) {

//不同的执行次序决定排序和查找次序不同,可以同下面的调换一下
if(this.getId() < o.getId()){
return -1;
} else if(this.getId() == o.getId()){
;
} else {
return 1;
}

//不同的执行次序决定排序和查找次序不同
int c = this.getIdCard().compareTo(o.getIdCard());
if(c != 0){
return c;
}

//不同的执行次序决定排序和查找次序不同
int n = this.getName().compareTo(o.getName());

if(n != 0){
return n;
}

return 0;
}

public String toString(){
StringBuffer sb = new StringBuffer();
sb.append(this.getId()).append("\t");
sb.append(this.getName()).append("\t");
sb.append(this.getIdCard()).append("\t");
sb.append(this.getMobile()).append("\t");
sb.append(this.getSex());
return sb.toString();
}
}

8. java二分法查找的递归算法怎么实现

publicclass二分法递归查找{
	publicstaticvoidmain(String[]args){

		//定义数组,注意,二分查找数组必须是有序的数组!
		int[]arr={1,3,5,7,9,11,13,15,17};
		
		//接受查找后的返回值:索引值,如果没有则是-1;
		//测试查找元素:9
		inta=binary(arr,9,0,arr.length-1);
		System.out.println("被查找数字索引位置在:"+a);
	}
	//参数列表依次为:被查找的数组,查找的数字,头索引,尾索引!
	publicstaticintbinary(int[]arr,intkey,intstar,intend)//递归
	{
		//每次进来创建,中间索引值!
		intmid=(star+end)/2;
		//如果被查找数小于头,或者尾,或者头索引大于尾索引,则说明无该数,返回-1;
		if(key<arr[star]||key>arr[end]||star>end){
			return-1;
		}
		//如果中间值小于被查找数,则重新定义头索引移至中间+1位置,筛选掉一半数字!
		if(arr[mid]<key){
			//开始递归!
			returnbinary(arr,key,mid+1,end);
			//否则如果中间值大于被查找数,则重新尾索引移至中间-1位置,筛选掉一半数字!
		}elseif(arr[mid]>key){
			//开始递归!
			returnbinary(arr,key,star,mid-1);
		}else{
			//否者就是找到了,返回该索引!
			returnmid;
		}
	}
}