Sortieren und Binär suchen mit Java

Wurde ich gebeten, zu Sortieren und durchsuchen eines Arrays. Die Sortierung der array war einfach und mein code funktionierte aber dann immer, wenn ich versuche zu nennen, die binary-search-Methode funktioniert für das erste element im array, sondern gibt mir "-1" als Ergebnis

Mein vollständiger code lautet wie folgt:

 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;
}
  • Haben Sie einen Blick auf Ihre rBsearch - Methode - wie Sie Aussehen, mischen Grenzen und Schlüssel in der Rekursion nennt. Vielleicht fügen Sie eine println zu sehen, was tatsächlich geschieht.
InformationsquelleAutor Scarl | 2013-10-21
  1. 3

    Du patzte die binäre Suche Intervallen 

    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);
    }
 }
    • Ich hatte eine Menge Dinge im Hinterkopf, während dies zu tun! Anyways, danke!
    InformationsquelleAutor Pratik Shelar
  2. 2

    Hast du einen Fehler bei dem aufrufen der rBsearch Methode in den folgenden Zeilen
    Statt

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

    Sollten Sie verwenden

    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);
        }
    InformationsquelleAutor shikjohari
  3. 0

    Einfachste Weg ist:
    Konvertieren Sie die array-Liste: Arrays.asList(array)

    Für Art: Collections#sort

    Suche: Collections#binarySearch

    Sehen diese

    InformationsquelleAutor G.S
  4. 0
    1. Nehmen-Array Aus Benutzer
    2. Sort-Array mit dem Build-in-Funktion von Java...

    3. dann Suche Element unter Verwendung der Binären Suche....

          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");
              }
          }
        }
    }

      Ergebnis der binarysearch-Methode

    InformationsquelleAutor Adeel Asghar
Schreibe einen Kommentar