comment calculer la complexité de la recherche binaire
J'ai entendu quelqu'un dire que puisque la recherche binaire réduit de moitié les entrées nécessaires à la recherche, il s'agit donc de l'algorithme log (n). Étant donné que je ne suis pas issu des mathématiques, je ne suis pas en mesure de le comprendre. Quelqu'un peut-il expliquer un peu plus en détail? faut-il faire quelque chose avec la série logarithmique?
Voici une façon plus mathématique de le voir, bien que pas vraiment compliquée. L'OMI est beaucoup plus claire que les informelles:
La question est de savoir combien de fois pouvez-vous diviser N par 2 jusqu'à obtenir 1? Cela consiste essentiellement à dire, effectuez une recherche binaire (la moitié des éléments) jusqu'à ce que vous la trouviez. Dans une formule, ceci serait ceci:
1 = N/2x
multiplier par 2x:
2x = N
maintenant faire le journal2:
bûche2(2x) = Log2 N
x * log2(2) = log2 N
x * 1 = log2 N
cela signifie que vous pouvez diviser le journal N fois jusqu'à ce que tout soit divisé. Ce qui signifie que vous devez diviser le journal N ("effectuez l'étape de recherche binaire") jusqu'à ce que vous ayez trouvé votre élément.
Pour la recherche binaire, T (N) = T(N/2) + O(1) // la relation de récurrence
Appliquer le théorème des maîtres pour calculer la complexité des relations de récurrence à l'exécution: T (N) = aT (N/b) + f (N)
Ici, a = 1, b = 2 => Log (a base b) = 1
aussi, ici f(N) = n ^ c journal ^ k (n) // k = 0 & c = journal (a base b)
Donc, T(N) = O (N ^ c log ^ (k + 1) N) = O (log (N))
T (n) = T (n/2) +1
T (n/2) = T (n/4) + 1 + 1
Mettez la valeur de The (n/2) en haut de manière à ce que T (n) = T (n/4) + 1 + 1. /2^k)+1+1+1.....+1
= T (2 ^ k/2 ^ k) + 1 + 1 .... + 1 jusqu'à k
= T (1) + k
Comme nous avons pris 2 ^ k = n
K = log n
Donc, la complexité temporelle est O (log n)
Cela ne fait pas la moitié du temps de recherche, cela ne le rendrait pas log (n). Il le diminue de manière logarithmique. Pensez à cela pendant un moment. Si vous aviez 128 entrées dans une table et que vous deviez rechercher votre valeur de manière linéaire, il faudrait probablement environ 64 entrées en moyenne pour trouver votre valeur. C'est n/2 ou temps linéaire. Avec une recherche binaire, vous éliminez la moitié des entrées possibles à chaque itération, de sorte qu’au maximum 7 comparaisons suffisent pour trouver votre valeur (la base 2 le pouvoir de la recherche binaire.
La complexité temporelle de l'algorithme de recherche binaire appartient à la classe O (log n). Ceci est appelé grande notation O . Vous devez interpréter cela comme suit: la croissance asymptotique du temps nécessaire à la fonction pour exécuter un ensemble d'entrée de taille n ne dépassera pas log n.
Ceci est juste un jargon mathématique formel pour pouvoir prouver des déclarations, etc. Il a une explication très simple. Lorsque n devient très volumineux, la fonction log n va prendre plus de temps que nécessaire pour exécuter la fonction. La taille du "jeu d'entrée", n, est simplement la longueur de la liste.
En termes simples, la raison pour laquelle la recherche binaire est dans O (log n) est qu’elle divise par deux le jeu d’entrées à chaque itération. Il est plus facile d'y penser dans la situation inverse. Sur x itérations, combien de temps la liste de l'algorithme de recherche binaire à max peut-elle être examinée? La réponse est 2 ^ x. On peut en déduire que l'inverse est qu'en moyenne, l'algorithme de recherche binaire a besoin de log2 n itérations pour une liste de longueur n.
Si c'est pourquoi il s'agit de O (log n) et non de O (log2 n), c'est simplement pour le dire à nouveau - En utilisant les grosses notations O, les constantes ne comptent pas.
Log2 (n) est le nombre maximal de recherches nécessaires pour trouver quelque chose dans une recherche binaire. Le cas moyen implique des recherches log2 (n) -1. Voici plus d'informations:
Voici wikipedia entry
Si vous regardez l'approche itérative simple. Vous n'éliminez que la moitié des éléments à rechercher jusqu'à ce que vous trouviez l'élément dont vous avez besoin.
Voici l'explication de la façon dont nous trouvons la formule.
Supposons initialement que vous avez N nombre d'éléments, puis que vous faites est «N/2» lors d'une première tentative. Où N est la somme de la limite inférieure et de la limite supérieure. La première valeur temporelle de N serait égale à (L + H), L étant le premier index (0) et H le dernier index de la liste que vous recherchez. Si vous avez de la chance, l'élément que vous essayez de trouver sera au milieu [par exemple. Vous recherchez 18 dans la liste {16, 17, 18, 19, 20} puis vous calculez (0 + 4)/2⌋ = 2 où 0 est la limite inférieure (L - index du premier élément du tableau) et 4 est la borne supérieure (H - index du dernier élément du tableau). Dans le cas ci-dessus, L = 0 et H = 4. Maintenant, 2 est l'indice de l'élément 18 que vous recherchez. Bingo! Tu l'as trouvé.
Si le cas était un tableau différent {15,16,17,18,19} mais que vous recherchiez toujours 18 ans, vous ne seriez pas chanceux et vous feriez d'abord N/2 (qui est (0 + 4)/2⌋ = 2, puis réalisez que l’élément 17 de l’indice 2 n’est pas le nombre que vous recherchez. Vous savez maintenant que vous n’aurez pas à chercher au moins la moitié du tableau lors de votre prochaine tentative de recherche itérative. Donc, en gros, vous ne parcourez pas la moitié de la liste des éléments que vous avez recherchés précédemment, chaque fois que vous essayez de trouver l’élément que vous n’aviez pas pu trouver lors de votre précédente tentative.
Donc, le pire des cas serait
[N]/2 + [(N/2)]/2 + [((N/2)/2)]/2 .....
c'est à dire:
N/21 + N/22 + N/23 + ..... + N/2x … …__.
jusqu’à ce que… vous avez terminé votre recherche, où l’élément que vous essayez de trouver se trouve à la fin de la liste.
Cela montre que le pire des cas est lorsque vous atteignez N/2x où x est tel que 2x = N
Dans les autres cas, N/2x où x est tel que 2x <N La valeur minimale de x peut être 1, ce qui est le meilleur des cas.
Or, mathématiquement, le pire cas se produit lorsque la valeur de
2x = N
=> log2(2x) = log2(N)
=> x * log2(2) = log2(N)
=> x * 1 = log2(N)
=> Plus officiellement ⌊log2(N) + 1⌋
Puisque nous avons coupé une liste de moitié à chaque fois, nous devons simplement savoir en combien d’étapes nous obtenons 1 au fur et à mesure que nous divisons une liste par deux. Dans le calcul sous-donné, x indique le nombre de fois où nous divisons une liste jusqu'à obtenir un élément (dans le pire des cas).
1 = N/2x
2x = N
Prendre log2
log2 (2x) = log2 (N)
x * log2 (2) = log2 (n)
x = log2 (N)
Une recherche binaire fonctionne en divisant le problème en deux fois, comme ceci (détails omis):
Exemple recherchant 3 dans [4,1,3,8,5]
- Commandez votre liste d'articles [1,3,4,5,8]
- Regardez l'élément du milieu (4),
- Si c'est ce que vous cherchez, arrêtez
- Si c'est plus important, regardez la première moitié
- Si c'est moins, regardez la seconde moitié
- Répétez l’étape 2 avec la nouvelle liste [1, 3], trouvez 3 et arrêtez
C’est une recherche bi -nary lorsque vous divisez le problème en 2.
La recherche nécessite uniquement les étapes log2 (n) pour trouver la valeur correcte.
Je recommanderais Introduction aux algorithmes si vous voulez en savoir plus sur la complexité algorithmique.
ok see this
for(i=0;i<n;n=n/2)
{
i++;
}
1. Suppose at i=k the loop terminate. i.e. the loop execute k times.
2. at each iteration n is divided by half.
2.a n=n/2 .... AT I=1
2.b n=(n/2)/2=n/(2^2)
2.c n=((n/2)/2)/2=n/(2^3)....... aT I=3
2.d n=(((n/2)/2)/2)/2=n/(2^4)
So at i=k , n=1 which is obtain by dividing n 2^k times
n=2^k
1=n/2^k
k=log(N) //base 2
Disons que l'itération dans la recherche binaire se termine après k itérations. A chaque itération, le tableau est divisé par deux. Admettons donc que la longueur du tableau, quelle que soit l’itération, est n.
Length of array = n
A l'Itération 2,
Length of array = n⁄2
A l'itération 3,
Length of array = (n⁄2)⁄2 = n⁄22
Par conséquent, après l’itération k,
Length of array = n⁄2k
En outre, nous savons qu’après After k divisions, la longueur du tableau devient 1 Donc
Length of array = n⁄2k = 1
=> n = 2k
Application de la fonction de journalisation des deux côtés:
=> log2 (n) = log2 (2k)
=> log2 (n) = k log2 (2)
As (loga (a) = 1)
Donc,
As (loga (a) = 1)
k = log2 (n)
C’est pourquoi le temps complexe de la recherche binaire est
log2 (n)
Laissez-moi vous faciliter la tâche avec un exemple.
Par souci de simplicité, supposons qu'il y ait 32 éléments dans un tableau dans l'ordre de tri duquel nous recherchons un élément à l'aide de la recherche binaire.
1 2 3 4 5 6 ... 32
Supposons que nous recherchions 32. Après la première itération, il nous restera
17 18 19 20 .... 32
après la deuxième itération, il nous restera
25 26 27 28 .... 32
après la troisième itération, il nous restera
29 30 31 32
après la quatrième itération, il nous restera
31 32
Dans la cinquième itération, nous trouverons la valeur 32.
Donc, si nous convertissons cela en une équation mathématique, nous aurons
(32 X (1/25)) = 1
=> n X (2-k) = 1
=> (2k) = n
=> k journal22 = log2n
=> k = log2n
D'où la preuve.