Java二进制搜索
我能得到一些帮助吗?我已经尝试了很多方法来实现这一点,我对数组进行了排序并进行了打印,但之后我的二进制搜索函数不想运行并给出正确的结果。它总是给我-1。有什么帮助吗Java二进制搜索,java,Java,我能得到一些帮助吗?我已经尝试了很多方法来实现这一点,我对数组进行了排序并进行了打印,但之后我的二进制搜索函数不想运行并给出正确的结果。它总是给我-1。有什么帮助吗 public class BinarySearch { public static final int NOT_FOUND = -1; public static int binarySearch(double[] a, double key) { int low = 0; int high = a.length -
public class BinarySearch {
public static final int NOT_FOUND = -1;
public static int binarySearch(double[] a, double key) {
int low = 0;
int high = a.length -1;
int mid;
while (low<=high) {
mid = (low+high) /2;
if (mid > key)
high = mid -1;
else if (mid < key)
low = mid +1;
else
return mid;
}
return NOT_FOUND;
}
public static void main(String[] args) {
double key = 10.5, index;
double a[] ={10,5,4,10.5,30.5};
int i;
int l = a.length;
int j;
System.out.println("The array currently looks like");
for (i=0; i<a.length; i++)
System.out.println(a[i]);
System.out.println("The array after sorting looks like");
for (j=1; j < l; j++) {
for (i=0; i < l-j; i++) {
if (a[i] > a[i+1]) {
double temp = a[i];
a[i] = a[i+1];
a[i+1] = temp;
}
}
}
for (i=0;i < l;i++) {
System.out.println(a[i]);
}
System.out.println("Found " + key + " at " + binarySearch(double a[], key));
}
}
公共类二进制搜索{
公共静态final int NOT_FOUND=-1;
公共静态int-binarySearch(双[]a,双键){
int低=0;
int高=a.长度-1;
int mid;
while(低调)
高=中-1;
否则如果(中间<键)
低=中+1;
其他的
中途返回;
}
未找到返回;
}
公共静态void main(字符串[]args){
双键=10.5,索引;
双a[]={10,5,4,10.5,30.5};
int i;
int l=a.长度;
int j;
System.out.println(“数组当前看起来像”);
对于(i=0;i a[i+1]){
双温=a[i];
a[i]=a[i+1];
a[i+1]=温度;
}
}
}
对于(i=0;i
这里
if (mid > key)
high = mid -1;
else if (mid < key)
low = mid +1;
else
return mid;
应该是
System.out.println("Found " + key + " at " + binarySearch(a, key));
System.out.println("Found " + key + " at " + binarySearch(a, key));
实际上,您并不是在与数组值进行比较。在
while (low <= high) {
mid = (low + high) / 2;
if (mid > key) {
high = mid - 1;
} else if (mid < key) {
low = mid + 1;
} else {
return mid;
}
}
publicstaticdoublebinarysearch(double[]a,双键){
如果(a.length==0){
返回-1;
}
int低=0;
int高=a.length-1;
while(低a[中]){
低=中+1;
}如果(b
我不知何故发现迭代版本不太容易阅读,递归让它变得又好又容易:-)
公共类二进制搜索{
私有静态int-binarySearchMain(int-key,int[]arr,int-start,int-end){
int middle=(end start+1)/2+start;//获取特定数组部分中间元素的索引
if(arr[中间]==键){
返回中间;
}
如果(键0){
返回binarySearchMain(key,arr,start,middle-1);//递归下半部分
}
if(键>排列[中间]&中间<排列长度-1){
返回binarySearchMain(key,arr,middle+1,end);//递归上半部分
}
返回Integer.MAX_值;
}
公共静态int-binarySearch(int-key,int[]arr){//此处的入口点
返回binarySearchMain(键,arr,0,arr.length-1);
}
}
这是一个没有堆的解决方案。同样的事情也可以在数组中完成。
如果我们需要找到“k”最大的数字,我们将获取一个大小为“k”的数组,该数组由主数据源中的前k项填充。现在,继续读取一个项目,并将其放置在结果数组中(如果它有位置的话)
public static void largestkNumbers() {
int k = 4; // find 4 largest numbers
int[] arr = {4,90,7,10,-5,34,98,1,2};
int[] result = new int[k];
//initial formation of elems
for (int i = 0; i < k; ++i) {
result[i] = arr[i];
}
Arrays.sort(result);
for ( int i = k; i < arr.length; ++i ) {
int index = binarySearch(result, arr[i]);
if (index > 0) {
// insert arr[i] at result[index] and remove result[0]
insertInBetweenArray(result, index, arr[i]);
}
}
}
public static void insertInBetweenArray(int[] arr, int index, int num) {
// insert num at arr[index] and remove arr[0]
for ( int i = 0 ; i < index; ++i ) {
arr[i] = arr[i+1];
}
arr[index-1] = num;
}
public static int binarySearch(int[] arr, int num) {
int lo = 0;
int hi = arr.length - 1;
int mid = -1;
while( lo <= hi ) {
mid = (lo+hi)/2;
if ( arr[mid] > num ) {
hi = mid-1;
} else if ( arr[mid] < num ) {
lo = mid+1;
} else {
return mid;
}
}
return mid;
}
public static void largestkNumbers(){
int k=4;//查找4个最大数
int[]arr={4,90,7,10,-5,34,98,1,2};
int[]结果=新的int[k];
//元素的初始形成
对于(int i=0;i0){
//在结果[索引]处插入arr[i]并删除结果[0]
插入序列(结果、索引、arr[i]);
}
}
}
公共静态void insertInBetweenArray(int[]arr,int index,int num){
//在arr[index]处插入num并删除arr[0]
对于(int i=0;i
int-bin搜索(int[]数组,int-size,int-value)
{
如果(size==0)返回-1;
if(数组[size-1]==值)返回size-1;
如果(数组[0]==值)返回0;
如果(大小%2==0){
if(数组[size-1]==值)返回size-1;
BinSearch(数组,大小为1,值);
}
其他的
{
if(数组[size/2]==值)返回(size/2);
else if(array[size/2]>value)返回bin搜索(array,(size/2)+1,value);
else if(数组[size/2]
或
/**
*找出67是否是一个基本否
*域由25个素数组成
*二进制搜索
*/
int素数[]={2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97};
int min=0,
中间,
最大值=素数长度,
键=67,
计数=0;
布尔值isFound=false;
而(!isFound){
如果(计数<6){
中间=(最小+最大)/2;
if(素数[mid]==键){
isFound=true;
System.out.println(“在“+mid”处找到素数);
}else if(素数[mid]<键){
最小值=中间值+1;
isFound=false;
}else如果(primes[mid]>key){
max=mid-1;
isFound=false;
}
计数++;
}否则{
System.out.println(“无此类编号”);
isFound=true;
}
}
/**
希望你喜欢
又称二进制搜索
取数字数组中的10个元素,输入一个数字,检查数字是否正确
出席者:
**/
封装阵列;
导入java.io.InputStreamReader;
导入java.io.BufferedReader;
导入java.io.IOException;
类二进制
{
公共静态void main(字符串args[])引发IOException
{
BufferedReader br=新的BufferedReader(新的InputStreamReader(System.in));
System.out.print(“输入一个数字:”);
int n=Integer.parseInt(br.readLine());
INTA[]={10,20,30,40,50,60,70,80,90100};
int upper=a.length-1,lower=0,mid;
布尔值=false;
int pos=0;
System.out.println("Found " + key + " at " + binarySearch(a, key));
public static double binarySearch(double[] a, double key) {
if (a.length == 0) {
return -1;
}
int low = 0;
int high = a.length-1;
while(low <= high) {
int middle = (low+high) /2;
if (b> a[middle]){
low = middle +1;
} else if (b< a[middle]){
high = middle -1;
} else { // The element has been found
return a[middle];
}
}
return -1;
}
public class BinarySearch {
private static int binarySearchMain(int key, int[] arr, int start, int end) {
int middle = (end-start+1)/2 + start; //get index of the middle element of a particular array portion
if (arr[middle] == key) {
return middle;
}
if (key < arr[middle] && middle > 0) {
return binarySearchMain(key, arr, start, middle-1); //recurse lower half
}
if (key > arr[middle] && middle < arr.length-1) {
return binarySearchMain(key, arr, middle+1, end); //recurse higher half
}
return Integer.MAX_VALUE;
}
public static int binarySearch(int key, int[] arr) { //entry point here
return binarySearchMain(key, arr, 0, arr.length-1);
}
}
public static void largestkNumbers() {
int k = 4; // find 4 largest numbers
int[] arr = {4,90,7,10,-5,34,98,1,2};
int[] result = new int[k];
//initial formation of elems
for (int i = 0; i < k; ++i) {
result[i] = arr[i];
}
Arrays.sort(result);
for ( int i = k; i < arr.length; ++i ) {
int index = binarySearch(result, arr[i]);
if (index > 0) {
// insert arr[i] at result[index] and remove result[0]
insertInBetweenArray(result, index, arr[i]);
}
}
}
public static void insertInBetweenArray(int[] arr, int index, int num) {
// insert num at arr[index] and remove arr[0]
for ( int i = 0 ; i < index; ++i ) {
arr[i] = arr[i+1];
}
arr[index-1] = num;
}
public static int binarySearch(int[] arr, int num) {
int lo = 0;
int hi = arr.length - 1;
int mid = -1;
while( lo <= hi ) {
mid = (lo+hi)/2;
if ( arr[mid] > num ) {
hi = mid-1;
} else if ( arr[mid] < num ) {
lo = mid+1;
} else {
return mid;
}
}
return mid;
}
int BinSearch(int[] array, int size, int value)
{
if(size == 0) return -1;
if(array[size-1] == value) return size-1;
if(array[0] == value) return 0;
if(size % 2 == 0) {
if(array[size-1] == value) return size-1;
BinSearch(array,size-1,value);
}
else
{
if(array[size/2] == value) return (size/2);
else if(array[size/2] > value) return BinSearch(array, (size/2)+1, value);
else if(array[size/2] < value) return (size/2)+BinSearch(array+size/2, size/2, value);
}
}
/**
* Find whether 67 is a prime no
* Domain consists 25 of prime numbers
* Binary Search
*/
int primes[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};
int min = 0,
mid,
max = primes.length,
key = 67,
count= 0;
boolean isFound = false;
while (!isFound) {
if (count < 6) {
mid = (min + max) / 2;
if (primes[mid] == key) {
isFound = true;
System.out.println("Found prime at: " + mid);
} else if (primes[mid] < key) {
min = mid + 1;
isFound = false;
} else if (primes[mid] > key) {
max = mid - 1;
isFound = false;
}
count++;
} else {
System.out.println("No such number");
isFound = true;
}
}
/**
HOPE YOU LIKE IT
A.K.A Binary Search
Take number array of 10 elements, input a number a check whether the number
is present:
**/
package array;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.IOException;
class BinaryS
{
public static void main(String args[]) throws IOException
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
System.out.print("Enter a number: ");
int n=Integer.parseInt(br.readLine());
int a[]={10,20,30,40,50,60,70,80,90,100};
int upper=a.length-1,lower=0,mid;
boolean found=false;
int pos=0;
while(lower<=upper)
{
mid=(upper+lower)/2;
if(n<a[mid])upper=mid-1;
else if(n>a[mid])lower=mid+1;
else
{
found=true;
pos=mid;
break;
}
}
if(found)System.out.println(n+" found at index "+pos);
else System.out.println(n+" not found in array");
}
}
int binarySearch(int list[], int lowIndex, int highIndex, int find)
{
if (highIndex>=lowIndex)
{
int mid = lowIndex + (highIndex - lowIndex)/2;
// If the element is present at the
// middle itself
if (list[mid] == find)
return mid;
// If element is smaller than mid, then
// it can only be present in left subarray
if (list[mid] > find)
return binarySearch(list, lowIndex, mid-1, find);
// Else the element can only be present
// in right subarray
return binarySearch(list, mid+1, highIndex, find);
}
// We reach here when element is not present
// in array
return -1;
}
public static int binarySearch(int[] array, int element){
if(array == null || array.length == 0){ // validate array
return -1;
}else if(element<array[0] || element > array[array.length-1]){ // validate value our of range that to be search
return -1;
}else if(element == array[0]){ // if element present at very first element of array
return 0;
}else if(element == array[array.length-1]){ // if element present at very last element of array
return array.length-1;
}
int start = 0;
int end = array.length-1;
while (start<=end){
int midIndex = start + ((end-start)/2); // calculate midIndex
if(element < array[midIndex]){ // focus on left side of midIndex
end = midIndex-1;
}else if(element > array[midIndex]){// focus on right side of midIndex
start = midIndex+1;
}else {
return midIndex; // You are in luck :)
}
}
return -1; // better luck next time :(
}
static int binarySearchAlgorithm() {
// Array should be in sorted order. Mandatory requirement
int[] a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int lowIndex = 0;
int valueToFind = 8;
int highIndex = a.length - 1;
while (lowIndex <= highIndex) {
//Finding the midIndex;
int midIndex = (highIndex + lowIndex) / 2;
// Checking if midIndex value of array contains the value to be find.
if (a[midIndex] == valueToFind) {
return midIndex;
}
// Checking the mid Index value is less than the value to be find.
else if (a[midIndex] < valueToFind) {
// If Yes, changing the lowIndex value to midIndex value + 1;
lowIndex = midIndex + 1;
} else if (a[midIndex] > valueToFind) {
// If Yes, changing the highIndex value to midIndex value - 1;
highIndex = midIndex - 1;
} else {
return -1;
}
}
return -1;
}