Binary algorithme de recherche, gâteau d'entrevue
Un algorithme de recherche binaire trouve un élément dans un tableau trié dans le temps.
Une recherche de force brute passerions tout le tableau. en prenant le temps dans le pire des cas.
Disons que nous avons un tableau trié de nombres. Pour trouver un numéro avec une recherche binaire, nous:
- Commencez par le nombre du milieu: est-il plus grand ou plus petit que notre numéro de cible? Étant donné que le tableau est trié, ce qui nous indique si la cible serait dans la moitié gauche ou la moitié droite de notre tableau.
- Nous avons effectivement divisé le problème en deux. Nous pouvons « exclure » toute la moitié du tableau que nous connaissons ne contient pas le numéro cible.
- Répétez la même approche (de départ au milieu) sur le nouveau problème demi-taille. Ensuite, faites encore et encore, jusqu'à ce que nous trouvons le nombre ou « règle sur » l'ensemble.
Nous pouvons le faire récursive, ou itérativement. Voici une version itérative:
statique boolean binarySearch publique (cible int, int [] nums) < // see if target appears in nums // we think of floorIndex and ceilingIndex as "walls" around // the possible positions of our target, so by -1 below we mean // to start our wall "to the left" of the 0th index // (we *don't* mean "the last index") int floorIndex = -1; int ceilingIndex = nums.length; // if there isn't at least 1 index between floor and ceiling, // we've run out of guesses and the number must not be present while (floorIndex + 1 < ceilingIndex) < // find the index
à mi-chemin entre le plancher et le plafond // nous utilisons la division entière, donc nous ne pourrons jamais un « indice de la moitié » la distance int = ceilingIndex - floorIndex; int halfDistance = distance / 2; int guessIndex = floorIndex + halfDistance; int guessValue = nums [guessIndex]; if (guessValue == cible) < return true; > if (guessValue> cible) < // target is to the left, so move ceiling to the left ceilingIndex = guessIndex; > autre < // target is to the right, so move floor to the right floorIndex = guessIndex; > > Return false; >
Comment avons-nous savons que le coût du temps de recherche binaire était? La seule partie non constante de notre coût du temps est le nombre de fois nos runs de boucle while. Chaque étape de notre boucle while coupe les (dictée par floorIndex et ceilingIndex) dans la moitié, jusqu'à ce que notre gamme a juste un élément gauche.
La question est, « combien de fois devons-nous partager notre originale taille du tableau (n) dans la moitié jusqu'à ce que nous nous attelons à 1? »
Combien de \ frac « s sont là? Nous ne savons pas encore, mais nous pouvons appeler ce numéro x.
Maintenant, nous résolvons pour x.
Maintenant, pour obtenir les x de l'exposant. Comment fait-on cela? Logarithmes.
Rappelons que des moyens \ de LOG_, « quel pouvoir devons nous élever à 10, pour obtenir 100 »? La réponse est 2.
Donc dans ce cas, si nous prenons le \ log_ des deux côtés.
Le côté droit demande, « quel pouvoir doit nous élever à 2, pour obtenir 2 ^ x? » Eh bien, c'est juste x.
Tiens voilà. Le nombre de fois nous devons diviser n en deux pour descendre à 1 est log_n. Donc, notre coût du temps total est
Attention: nous ne pouvons utiliser la recherche binaire si le tableau d'entrée est déjà triée.
Passez vos entretiens avec mon gratuit de 7 jours Crash Course
Je vais vous apprendre la bonne façon de penser pour décomposer les questions d'entrevue de codage algorithmiques difficiles que vous avez jamais vu auparavant.
Pas avant la formation informatique nécessaire-vous lever je vais accélérer rapidement, sauter tous les trucs trop académique.
Pas de spam. Un clic désabonnement si vous détestez.
Vous êtes dans! Rendez-vous sur votre boîte de réception e-mail dès maintenant à lire le premier jour!