web-dev-qa-db-fra.com

Comment utiliser la récursivité dans la création d'un algorithme de recherche binaire

J'utilisais mon temps libre pour pratiquer Java avec des algorithmes de codage. Un des algorithmes que j'ai codé était la recherche binaire:

public class BinarySearch {

    private static int list[] = {3, 6, 7, 8, 9, 10};

    public static void main(String[] args) {
        BinarySearch b = new BinarySearch();
        b.binarySearch(list);

    }

    public void binarySearch(int[] args) {
        System.out.println("Binary search.");

        int upperBound = args.length;
        int lowerBound = 1;
        int midpoint = (upperBound + lowerBound) / 2;
        int difference = upperBound - lowerBound;

        int search = 7;

        for (int i = 0; i < args.length; i++) {
            if (search < args[midpoint - 1] && difference != 1) {
                upperBound = midpoint - 1;
                midpoint = upperBound / 2;
            } else if (search > args[midpoint - 1] && difference != 1) {
                lowerBound = midpoint + 1;
                midpoint = (lowerBound + upperBound) / 2;

            } else if (search == args[midpoint - 1]) {
                midpoint = midpoint - 1;

                System.out.println("We found " + search + " at position " + midpoint + " in the list.");
                i = args.length;
            } else {
                System.out.println("We couldn't find " + search + " in the list.");
                i = args.length;
            }
        }
    }
}

Je veux vraiment pouvoir écrire un algorithme de recherche binaire beaucoup plus propre et efficace, une alternative à ce que j'ai codé. J'ai vu des exemples d'utilisation de la récursivité, par exemple lorsque je compose des nombres avec des nombres que je comprends. Cependant, lors de la codification de quelque chose de cette complexité, je ne sais pas comment l'utiliser à mon avantage. Par conséquent, ma question est de savoir comment appliquer la récursivité lors du codage d'un algorithme de recherche binaire. Et si vous avez des conseils pour que je perfectionne mes compétences en matière de récursivité, même si cela ne concerne pas la recherche binaire, n'hésitez pas à poster.

javaalgorithmbinary-search
7
JP24

Si vous voulez vraiment utiliser la récursivité, faites-le.

public static int binarySearch(int[] a, int target) {
    return binarySearch(a, 0, a.length-1, target);
}

public static int binarySearch(int[] a, int start, int end, int target) {
    int middle = (start + end) / 2;
    if(end < start) {
        return -1;
    } 

    if(target==a[middle]) {
        return middle;
    } else if(target<a[middle]) {
        return binarySearch(a, start, middle - 1, target);
    } else {
        return binarySearch(a, middle + 1, end, target);
    }
}
28
Cruncher

Voici un moyen plus simple de faire une recherche binaire:

public static int binarySearch(int intToSearch, int[] sortedArray) {

    int lower = 0;
    int upper = sortedArray.length - 1;

    while (lower <= upper) {

        int mid = lower + (upper - lower) / 2;

        if(intToSearch < sortedArray[mid]) 

            upper = mid - 1;

        else if (intToSearch > sortedArray[mid]) 

            lower = mid + 1;

        else 

            return mid;
    }

    return -1; // Returns -1 if no match is found
}
7
Sajal Dutta

Voici un exemple de code extrait de here .

public class BinarySearch {

    public boolean find(int[] sortedValues, int value) {
        return search(sortedValues, value, 0, sortedValues.length - 1);
    }

    private boolean search(int[] sorted, int value, int leftIndex, int rightIndex) {

        // 1. index check
        if (leftIndex > rightIndex) {
            return false;
        }

        // 2. middle index
        int middle = (rightIndex + leftIndex) / 2;

        // 3. recursive invoke
        if (sorted[middle] > value) {
            return search(sorted, value, leftIndex, middle - 1);
        } else if (sorted[middle] < value) {
            return search(sorted, value, middle + 1, rightIndex);
        } else {
            return true;
        }
    }
}

Vous pouvez trouver des implémentations des cas de test ci-dessous par rapport à l'implémentation de la recherche binaire ci-dessus dans la référence link .

1. shouldReturnFalseIfArrayIsEmpty()
2. shouldReturnFalseIfNotFoundInSortedOddArray()
3. shouldReturnFalseIfNotFoundInSortedEvenArray()
4. shouldReturnTrueIfFoundAsFirstInSortedArray()
5. shouldReturnTrueIfFoundAtEndInSortedArray()
6. shouldReturnTrueIfFoundInMiddleInSortedArray()
7. shouldReturnTrueIfFoundAnywhereInSortedArray()
8. shouldReturnFalseIfNotFoundInSortedArray()
2
lkamal

C'est une autre façon de faire de la récursivité:

int[] n = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
@Test
public void testRecursiveSolution() {
    Assert.assertEquals(0, recursiveBinarySearch(1,n));
    Assert.assertEquals(15, recursiveBinarySearch(16,n));
    Assert.assertEquals(14, recursiveBinarySearch(15,n));
    Assert.assertEquals(13, recursiveBinarySearch(14,n));
    Assert.assertEquals(12, recursiveBinarySearch(13,n));
    Assert.assertEquals(11, recursiveBinarySearch(12,n));
    Assert.assertEquals(10, recursiveBinarySearch(11,n));
    Assert.assertEquals(9, recursiveBinarySearch(10,n));
    Assert.assertEquals(-1, recursiveBinarySearch(100,n));
}
private int recursiveBinarySearch(int n, int[] array) {
    if(array.length==1) {
        if(array[0]==n) {
            return 0;
        } else {
            return -1;
        }
    } else {
        int mid = (array.length-1)/2;
        if(array[mid]==n) {
            return mid;
        } else if(array[mid]>n) {
            return recursiveBinarySearch(n, Arrays.copyOfRange(array, 0, mid));
        } else {
            int returnIndex = recursiveBinarySearch(n, Arrays.copyOfRange(array, mid+1, array.length));
            if(returnIndex>=0) {
                return returnIndex+mid+1;
            } else {
                return returnIndex;
            }
        }
    }
}
1
Michele Orsi

Voici un algorithme qui devrait vous aider. Laissez votre signature de méthode être:

public boolean binarysearchRecursion(Array, begin_index,end_index, search_element)
  1. Vérifiez si votre begin_index> end_index si OUI renvoie alors false.
  2. Calculez mid_element pour votre tableau d'entrée.
  3. Vérifiez si votre search_element est égal à ce mid_element. si OUI, retourne true 
  4. Si mid_element> search_element Appelez votre méthode avec pour range 0 - mid
  5. Si mid_element <search_element Appelez votre méthode avec pour la plage mid+1 - Length_of_Array

En outre, comme @DwB l'a dit dans son commentaire, il vaut mieux utiliser la boucle pour faire avancer les choses. Certains problèmes sont de nature récursive (comme les problèmes d’arbres binaires). Mais celui-ci n'en fait pas partie.

1
Prateek

Un exemple possible est:

// need extra "helper" method, feed in params
   public int binarySearch(int[] a, int x) { 
      return binarySearch(a, x, 0, a.length - 1);
   }

   // need extra low and high parameters
   private int binarySearch(int[ ] a, int x,
         int low, int high) {
      if (low > high) return -1; 
      int mid = (low + high)/2;
      if (a[mid] == x) return mid;
      else if (a[mid] < x)
         return binarySearch(a, x, mid+1, high);
      else // last possibility: a[mid] > x
         return binarySearch(a, x, low, mid-1);
   }

Ici, vous pouvez vérifier en C Recherche binaire, avec et sans récursion

Source: http://www.cs.utsa.edu/~wagner/CS3343/recursion/binsearch.html

1
delive

Une BinarySearch récursive avec des conditions de pause au cas où vous ne puissiez pas trouver la valeur que vous recherchez

public interface Searcher{
    public int search(int [] data, int target, int low, int high);
}

La mise en oeuvre

public class BinarySearch implements Searcher {

    public int search(int[] data, int target, int low, int high) {
        //The return variable
        int retorno = -1;
        if(low > high) return retorno;
        int middle = (high + low)/2;
        if(target == data[middle]){
            retorno = data[middle];
        }else if(target < data[middle] && (middle - 1 != high)){
            //the (middle - 1 != high) avoids beeing locked inside a never ending recursion loop
            retorno = search(data, target, low, middle - 1);
        }else if(target > data[middle] && (middle - 1 != low)){
            //the (middle - 1 != low) avoids beeing locked inside a never ending recursion loop
            retorno = search(data, target, middle - 1, high);
        }else if(middle - 1 == low || middle - 1 == high){
            //Break condition if you can not find the desired balue
            retorno =  -1;
        }
        return retorno;
    }
}
0
Daniel Ferreira Castro

Bien que cela ne retourne pas l'index, ceci renvoie au moins l'idée de «oui» ou de «non» que quelque chose est dans la collection:

public static boolean recursive(int[] input, int valueToFind) {
    if (input.length == 0) {
        return false;
    }

    int mid = input.length / 2;
    if (input[mid] == valueToFind) {
        return true;
    } else if (input[mid] > valueToFind) {
        int[] smallerInput = Arrays.copyOfRange(input, 0, mid);
        return recursive(smallerInput, valueToFind);
    } else if (input[mid] < valueToFind) {
        int[] smallerInput = Arrays.copyOfRange(input, mid+1, input.length);
        return recursive(smallerInput, valueToFind);
    }

    return false;
}
0
Lorena Nicole