it-swarm.com.de

so berechnen Sie die binäre Suchkomplexität

Ich hörte jemanden sagen, dass die binäre Suche die Eingabe für die Suche halbiert und daher der log (n) -Algorithmus ist. Da ich kein mathematischer Hintergrund bin, kann ich mich nicht darauf beziehen. Kann jemand das etwas genauer erklären? hat es etwas mit der logarithmischen serie zu tun? 

114
Bunny Rabbit

Hier eine mathematischere Sichtweise, wenn auch nicht wirklich kompliziert. IMO viel klarer als informelle:

Die Frage ist, wie oft können Sie N durch 2 teilen, bis Sie 1 haben? Dies bedeutet im Wesentlichen, führen Sie eine binäre Suche durch (die Hälfte der Elemente), bis Sie sie gefunden haben. In einer Formel wäre dies so:

1 = N/2x

mit 2 multiplizierenx:

2x = N

jetzt mach das Protokoll2:

log2(2x) = Log2 N
x * log2(2) = log2 N
x * 1 = log2 N

das bedeutet, Sie können log N mal teilen, bis Sie alles geteilt haben. Das bedeutet, dass Sie log N ("binären Suchschritt ausführen") aufteilen müssen, bis Sie Ihr Element gefunden haben.

336
duedl0r

Für die binäre Suche ist T (N) = T(N/2) + O(1) // die Wiederholungsbeziehung

Anwenden des Mastersatzes zur Berechnung der Laufzeitkomplexität der Wiederholungsbeziehungen: T (N) = aT (N/b) + f (N)

Hier ist a = 1, b = 2 => Log (eine Basis b) = 1

auch hier f(N) = n ^ c log ^ k (n) // k = 0 & c = log (eine Basis b)

Also ist T(N) = O (N ^ c log ^ (k + 1) N) = O (log (N))

Quelle: http://en.wikipedia.org/wiki/Master_theorem

19
Karshit

T (n) = T (n/2) + 1

T (n/2) = T (n/4) + 1 + 1

Setze den Wert von (n/2) so ein, dass T (n) = T (n/4) + 1 + 1 /2^k)+1+1+1.....+1

= T (2 ^ k/2 ^ k) + 1 + 1 .... + 1 bis k

= T (1) + k

Da haben wir 2 ^ k = n genommen

K = log n

Zeitkomplexität ist also O (log n)

13
Dhiren Biren

Es ist keine halbe Suchzeit, das würde es nicht protokollieren (n). Es verringert es logarithmisch. Denken Sie einen Moment darüber nach. Wenn Sie 128 Einträge in einer Tabelle hätten und linear nach Ihrem Wert suchen müssten, müssten Sie durchschnittlich etwa 64 Einträge benötigen, um Ihren Wert zu ermitteln. Das ist n/2 oder lineare Zeit. Bei einer binären Suche eliminieren Sie bei jeder Iteration die Hälfte der möglichen Einträge, sodass höchstens 7 Vergleiche erforderlich sind, um Ihren Wert zu ermitteln (Protokollbasis 2 von 128 ist 7 oder 2, die 7 ist 128.) die Macht der binären Suche.

10
Michael Dorgan

Die zeitliche Komplexität des binären Suchalgorithmus gehört zur Klasse O (log n). Dies wird als big O-Notation bezeichnet. Sie sollten dies so interpretieren, dass das asymptotische Wachstum der Zeit, die die Funktion benötigt, um einen Eingabesatz der Größe n auszuführen, log n nicht überschreitet.

Dies ist nur eine formale mathematische Sprache, um Aussagen usw. beweisen zu können. Sie hat eine sehr einfache Erklärung. Wenn n sehr groß wird, verkürzt sich die Zeit für die Ausführung der Funktion mit der Funktion log n. Die Größe des "Eingabesets", n, ist nur die Länge der Liste.

Vereinfacht gesagt, der Grund für die binäre Suche in O (log n) ist, dass die Eingabe in jeder Iteration halbiert wird. Es ist einfacher, in der umgekehrten Situation darüber nachzudenken. Wie lange kann der binäre Suchalgorithmus bei x-Iterationen bei max untersucht werden? Die Antwort lautet 2 ^ x. Daraus geht hervor, dass der binäre Suchalgorithmus im Durchschnitt log2n-Iterationen für eine Liste der Länge n benötigt.

Wenn es sich um O (log n) und nicht um O (log2 n) handelt, wird es einfach wieder eingefügt - Die Konstanten der großen O-Notation zählen nicht.

5
vidstige

Log2 (n) ist die maximale Anzahl von Suchen, die erforderlich sind, um bei einer binären Suche etwas zu finden. Der durchschnittliche Fall umfasst log2 (n) -1-Suchen. Hier gibt es mehr Infos:

http://en.wikipedia.org/wiki/Binary_search#Performance

3
Jonathan M

Hier ist wikipedia Eintrag

Wenn Sie sich den einfachen iterativen Ansatz anschauen. Sie eliminieren nur die Hälfte der Elemente, nach denen gesucht werden soll, bis Sie das gewünschte Element gefunden haben. 

Hier ist die Erklärung, wie wir mit der Formel kommen.

Nehmen wir an, Sie haben N Anzahl der Elemente und dann machen Sie als ersten Versuch ⌊N/2⌋. Dabei ist N die Summe aus Untergrenze und Obergrenze. Der erste Zeitwert von N wäre gleich (L + H), wobei L der erste Index (0) und H der letzte Index der Liste ist, nach der Sie suchen. Wenn Sie Glück haben, befindet sich das Element, das Sie zu finden versuchen, in der Mitte. Sie suchen nach 18 in der Liste {16, 17, 18, 19, 20} und berechnen dann ⌊ (0 + 4)/2⌋ = 2, wobei 0 die untere Grenze ist (L - Index des ersten Elements des Arrays). und 4 ist die höhere Grenze (H - Index des letzten Elements des Arrays). Im obigen Fall ist L = 0 und H = 4. Nun ist 2 der Index des Elements 18, das Sie suchen. Bingo! Du hast es gefunden.

Wenn der Fall ein anderes Array war {15,16,17,18,19}, aber Sie suchten immer noch nach 18, dann hätten Sie kein Glück und würden zuerst N/2 machen (was ⌊ (0 + 4)/ist. 2 = 2 und erst dann erkennen, dass Element 17 am Index 2 nicht die gesuchte Zahl ist. Jetzt wissen Sie, dass Sie beim nächsten Versuch, iterativ zu suchen, nicht mindestens die Hälfte des Arrays suchen müssen Der Suchaufwand ist halbiert, dh Sie suchen grundsätzlich nicht die Hälfte der Liste der Elemente, die Sie zuvor gesucht haben, jedes Mal, wenn Sie versuchen, das Element zu finden, das Sie bei Ihrem vorherigen Versuch nicht finden konnten. 

Der schlimmste Fall wäre also 

[N]/2 + [(N/2)]/2 + [((N/2)/2)]/2 .....
 
N/21 + N/22 + N/23 + ..... + N/2x … ..

bis… Sie die Suche beendet haben, wo sich das Element, das Sie suchen, am Ende der Liste befindet.

Das zeigt, dass der schlimmste Fall ist, wenn Sie N/2 erreichenx wobei x so ist, dass 2x = N

In anderen Fällen N/2x wobei x so ist, dass 2x <N Der Mindestwert von x kann 1 sein, was der beste Fall ist.

Nun da mathematisch der schlimmste Fall ist, wenn der Wert von
2x = N 
=> log2(2x) = log2(N) 
=> x * log2(2) = log2(N) 
=> x * 1 = log2(N) 
=> Formal ⌊log2(N) + 1⌋

3
RajKon

Da wir jedes Mal eine Liste auf die Hälfte reduzieren, müssen wir nur wissen, in wie vielen Schritten wir 1 erhalten, wenn wir eine Liste durch zwei teilen. In der unter gegebenen Berechnung bezeichnet x die Anzahl der Zeiten, in denen wir eine Liste teilen, bis wir ein Element erhalten (im schlimmsten Fall).

1 = N/2x

2x = N

Log2 nehmen

log2 (2x) = log2 (N) 

x * log2 (2) = log2 (N)

x = log2 (N)

1
Abdul Malik

T (N) = T(N/2) + 1

T (N) = T(N/2) + 1 = (T (N/4) + 1) + 1

...

T (N) = T(N/N) + (1 + 1 + 1 + ... + 1) = 1 + logN (Basis 2 log) = 1 + logN

Die zeitliche Komplexität der binären Suche ist also O (logN)

1
TizeeU0U

Eine binäre Suche funktioniert, indem das Problem wiederholt in zwei Hälften geteilt wird, etwa wie folgt (Details weggelassen):

Beispiel für 3 in [4,1,3,8,5]

  1. Bestellen Sie Ihre Artikelliste [1,3,4,5,8]
  2. Betrachte den mittleren Punkt (4),
    • Wenn es das ist, wonach Sie suchen, hören Sie auf
    • Wenn es größer ist, schauen Sie sich die erste Hälfte an
    • Wenn es weniger ist, schauen Sie sich die zweite Hälfte an
  3. Wiederholen Sie Schritt 2 mit der neuen Liste [1, 3], suchen Sie 3 und halten Sie an

Es ist eine bi -Nary-Suche, wenn Sie das Problem in 2 teilen.

Die Suche erfordert nur log2 (n) Schritte, um den korrekten Wert zu finden.

Ich würde empfehlen Einführung in Algorithmen wenn Sie etwas über algorithmische Komplexität erfahren möchten.

1
Silas Parker
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
0
Piyush Jain

Angenommen, die Iteration in der binären Suche wird nach k Iterationen beendet. Bei jeder Iteration wird das Array durch die Hälfte geteilt. Nehmen wir also an, dass die Länge des Arrays bei jeder Iteration n ist. Bei Iteration 1

Length of array = n

Bei Iteration 2

Length of array = n⁄2

Bei Iteration 3

Length of array = (n⁄2)⁄2 = n⁄22

Daher ist nach Iteration k

Length of array = n⁄2k

Wir wissen auch, dass nach k Divisionen die Länge des Arrays wird 1 Daher

Length of array = n⁄2k = 1
=> n = 2k

Log-Funktion auf beiden Seiten anwenden:

=> log2 (n) = log2 (2k)
=> log2 (n) = k log2 (2)
As (loga (a) = 1)

Deshalb,

As (loga (a) = 1)
k = log2 (n)

Daher ist die Zeitkomplexität der binären Suche

log2 (n)
0
SirPhemmiey

Lassen Sie es mich Ihnen allen mit einem Beispiel leicht machen.

Nehmen wir der Einfachheit halber an, dass ein Array 32 Elemente in der sortierten Reihenfolge enthält, aus der heraus mit der binären Suche nach einem Element gesucht wird.

1 2 3 4 5 6 ... 32

Angenommen, wir suchen nach 32. Nach der ersten Iteration bleiben wir mit

17 18 19 20 .... 32

nach der zweiten Iteration bleiben wir mit

25 26 27 28 .... 32

nach der dritten Iteration bleiben wir mit

29 30 31 32

nach der vierten Iteration bleiben wir mit

31 32

In der fünften Iteration finden wir den Wert 32.

Wenn wir dies in eine mathematische Gleichung umwandeln, erhalten wir

(32 X (1/25)) = 1

=> n X (2-k) = 1

=> (2k) = n

=> k log22 = log2n

=> k = log2n

Daher der Beweis.

0
Sumukha H S