使用Java进行排序和二进制搜索_Java_Arrays_Sorting_Search_Recursion

使用Java进行排序和二进制搜索

java arrays sorting search recursion

使用Java进行排序和二进制搜索,java,arrays,sorting,search,recursion,Java,Arrays,Sorting,Search,Recursion,我被要求对数组进行排序和搜索。数组的排序很简单，我的代码也很有效，但每当我尝试调用二进制搜索方法时，它对数组中的第一个元素有效，但结果是“-1” 我的全部代码如下： public static void main(String[] args) { int[] array = new int[5]; array[0] = 50; array[1] = 40; array[2] = 10; array[3] = 20; array[4] = 100

我被要求对数组进行排序和搜索。数组的排序很简单，我的代码也很有效，但每当我尝试调用二进制搜索方法时，它对数组中的第一个元素有效，但结果是“-1”

我的全部代码如下：

 public static void main(String[] args) {

    int[] array = new int[5];
    array[0] = 50;
    array[1] = 40;
    array[2] = 10;
    array[3] = 20;
    array[4] = 100;

sort(array, (array.length - 1));

      for (int x = 0; x < array.length; x++) {
        System.out.println(" " + array[x]);
    }
    System.out.println("");
    System.out.println("Binary search (R): " + rBsearch(array, 0, (array.length), 20));
}
    public static void sort(int[] a, int last) {
    if (last > 0) {
        int max = findMax(a, last);
        swap(a, last, max);
        sort(a, last - 1);
    }
}

public static int rBsearch(int[] L, int low, int high, int k) {


    int mid = (low + high) / 2;

    if (low > high) {
        return -1;
    } else if (L[mid] == k) {
        return mid;
    } else if (L[mid] < k) {
        return rBsearch(L, k, mid + 1, high);
    } else {
        return rBsearch(L, k, low, mid - 1);
    }
 }

public static int findMax(int[] arr, int last) {

    int max = 0;
    for (int i = 0; i <= last; i++) {
        if (arr[i] > arr[max]) {
            max = i;
        }
    }
    return max;
    }

public static void swap(int[] arr, int last, int max) {
    int temp = arr[last];
    arr[last] = arr[max];
    arr[max] = temp;
}

publicstaticvoidmain（字符串[]args）{
int[]数组=新的int[5]；
数组[0]=50；
数组[1]=40；
数组[2]=10；
数组[3]=20；
数组[4]=100；
排序（数组，（array.length-1））；
对于（int x=0；x0）{
int max=findMax（a，最后一个）；
交换（a，最后一个，最大值）；
排序（a，最后-1）；
}
}
公共静态int-rBsearch（int[]L，int-low，int-high，int-k）{
int mid=（低+高）/2；
如果（低>高）{
返回-1；
}else如果（L[mid]==k）{
中途返回；
}else if（L[mid]

最简单的方法是：
将数组转换为列表：array.asList（array）

对于排序：集合#排序

用于搜索：集合#二进制搜索

参见最简单的方法是：
将数组转换为列表：array.asList（array）

对于排序：集合#排序

用于搜索：集合#二进制搜索

请参见在以下几行中调用rBsearch方法时出错
而不是
else if (L[mid] < k) {
        return rBsearch(L, k, mid + 1, high); 
    } else {
        return rBsearch(L, k, low, mid - 1);
    }

else if（L[mid]

你应该使用
else if (L[mid] < k) {
            return rBsearch(L,  mid + 1, high,k); //the order of the parameters
        } else {
            return rBsearch(L, low, mid - 1,k);
        }

else if（L[mid]在以下几行中调用rBsearch方法时出错
而不是
else if (L[mid] < k) {
        return rBsearch(L, k, mid + 1, high); 
    } else {
        return rBsearch(L, k, low, mid - 1);
    }

else if（L[mid]

你应该使用
else if (L[mid] < k) {
            return rBsearch(L,  mid + 1, high,k); //the order of the parameters
        } else {
            return rBsearch(L, low, mid - 1,k);
        }

else if（L[mid]
你搞错了二进制搜索间隔
public static int rBsearch(int[] L, int low, int high, int k) {


    int mid = (low + high) / 2;

    if (low > high) {
        return -1;
    } else if (L[mid] == k) {
        return L[mid];
    } else if (L[mid] < k) {
        return rBsearch(L, mid + 1, high, k);
    } else {
        return rBsearch(L, low, mid - 1, k);
    }
 }

公共静态int-rBsearch（int[]L，int-low，int-high，int-k）{
int mid=（低+高）/2；
如果（低>高）{
返回-1；
}else如果（L[mid]==k）{
返回L[mid]；
}else if（L[mid]
你搞错了二进制搜索间隔
public static int rBsearch(int[] L, int low, int high, int k) {


    int mid = (low + high) / 2;

    if (low > high) {
        return -1;
    } else if (L[mid] == k) {
        return L[mid];
    } else if (L[mid] < k) {
        return rBsearch(L, mid + 1, high, k);
    } else {
        return rBsearch(L, low, mid - 1, k);
    }
 }

公共静态int-rBsearch（int[]L，int-low，int-high，int-k）{
int mid=（低+高）/2；
如果（低>高）{
返回-1；
}else如果（L[mid]==k）{
返回L[mid]；
}else if（L[mid]

从用户获取数组
使用Java的内置函数对数组进行排序
然后使用二进制搜索来搜索元素
    import java.lang.reflect.Array;
    import java.util.Arrays;
    import java.util.Scanner;

    class BinarySearch
    {
       public static void main(String args[])
       {
          int array[];

          Scanner input = new Scanner(System.in);
          System.out.println("Enter number of elements:");
         int Size_Of_Array = input.nextInt(); 


          array = new int[Size_Of_Array];

          System.out.println("Enter " + Size_Of_Array + " integers");

          for (int counter = 0; counter < Size_Of_Array; counter++)
              array[counter] = input.nextInt();

          Arrays.sort(array);
          System.out.println("Sorting Array is :-");
          for (int counter = 0; counter < Size_Of_Array; counter++)
              System.out.println(array[counter]);

          System.out.println("Enter the search value:");
          int  Searching_item = input.nextInt();

          int First_Index=0;
          int Last_Index=Size_Of_Array-1;
          int Middle_Index=(First_Index+Last_Index)/2;

          while(First_Index <= Last_Index)
          {
              if(array[Middle_Index] < Searching_item)
              {
                  First_Index=Middle_Index+1;
              }
              else if ( array[Middle_Index] == Searching_item ) 
              {
                System.out.println(Searching_item + " found at location " + (Middle_Index + 1) + ".");
                break;
              }
              else
              {
                  Last_Index = Middle_Index - 1;
              }
              Middle_Index = (First_Index + Last_Index)/2;

              if ( First_Index > Last_Index )
              {
                  System.out.println(Searching_item + " is not found.\n");
              }
          }
        }
    }

import java.lang.reflect.Array；
导入java.util.array；
导入java.util.Scanner；
类二进制搜索
{
公共静态void main（字符串参数[]）
{
int数组[]；
扫描仪输入=新扫描仪（System.in）；
System.out.println（“输入元素数：”）；
数组的int Size_=input.nextInt（）；
数组=新整数[数组的大小]；
System.out.println（“输入”+数组的大小”+“整数”）；
for（int counter=0；计数器<数组的大小\u；计数器++）
数组[计数器]=input.nextInt（）；
数组。排序（数组）；
System.out.println（“排序数组为：-”）；
for（int counter=0；计数器<数组的大小\u；计数器++）
System.out.println（数组[计数器]）；
System.out.println（“输入搜索值：”）；
int search_item=input.nextInt（）；
int First_Index=0；
int Last_Index=_数组的大小_-1；
中间指数=（第一个指数+最后一个指数）/2；
while（第一个索引最后一个索引）
{
System.out.println（未找到搜索项+）；
}
}
}
}


从用户获取数组
使用Java的内置函数对数组进行排序
然后使用二进制搜索来搜索元素
    import java.lang.reflect.Array;
    import java.util.Arrays;
    import java.util.Scanner;

    class BinarySearch
    {
       public static void main(String args[])
       {
          int array[];

          Scanner input = new Scanner(System.in);
          System.out.println("Enter number of elements:");
         int Size_Of_Array = input.nextInt(); 


          array = new int[Size_Of_Array];

          System.out.println("Enter " + Size_Of_Array + " integers");

          for (int counter = 0; counter < Size_Of_Array; counter++)
              array[counter] = input.nextInt();

          Arrays.sort(array);
          System.out.println("Sorting Array is :-");
          for (int counter = 0; counter < Size_Of_Array; counter++)
              System.out.println(array[counter]);

          System.out.println("Enter the search value:");
          int  Searching_item = input.nextInt();

          int First_Index=0;
          int Last_Index=Size_Of_Array-1;
          int Middle_Index=(First_Index+Last_Index)/2;

          while(First_Index <= Last_Index)
          {
              if(array[Middle_Index] < Searching_item)
              {
                  First_Index=Middle_Index+1;
              }
              else if ( array[Middle_Index] == Searching_item ) 
              {
                System.out.println(Searching_item + " found at location " + (Middle_Index + 1) + ".");
                break;
              }
              else
              {
                  Last_Index = Middle_Index - 1;
              }
              Middle_Index = (First_Index + Last_Index)/2;

              if ( First_Index > Last_Index )
              {
                  System.out.println(Searching_item + " is not found.\n");
              }
          }
        }
    }

import java.lang.reflect.Array；
导入java.util.array；
导入java.util.Scanner；
类二进制搜索
{
公共静态void main（字符串参数[]）
{
int数组[]；
扫描仪输入=新扫描仪（System.in）；
System.out.println（“输入元素数：”）；
数组的int Size_=input.nextInt（）；
数组=新整数[数组的大小]；
System.out.println（“输入”+数组的大小”+“整数”）；
for（int counter=0；计数器<数组的大小\u；计数器++）
数组[计数器]=input.nextInt（）；
数组。排序（数组）；
System.out.println（“排序数组为：-”）；
for（int counter=0；计数器<数组的大小\u；计数器++）
System.out.println（数组[计数器]）；
System.out.println（“输入搜索值：”）；
整数搜索项=inp