[C#] BinarySearch help

[Verwijderd]

Ik heb in mijn code:

code:

int geogetal = Int32.Parse(geo) + 1;
int uitkomst = 0;
int[] getal = new int[999];
int[] graden = new int[999];
int retVal = 0;

getal[1] = 6;
graden[1] = 6;
int i = 2;
while(i != 20) //<-- Is tijdelijk voor test
{
    uitkomst = graden[i-1]*geogetal;
    while(uitkomst > 360)
    {
        uitkomst = uitkomst - 360;
    }
    graden[i] = uitkomst;
    getal[i] = uitkomst;
    while(getal[i] > 30)
    {
        getal[i] = getal[i] - 30;
    }
    retVal = Array.BinarySearch(graden, graden[i]);
    if(retVal < 0)
    {
        MessageBox.Show(retVal.ToString());
    }
    else
    {
        MessageBox.Show(retVal.ToString());
    }
    MessageBox.Show(getal[i].ToString() + " : " + graden[i].ToString());
    i++;
}

Ik wil straks deze code laten draaien totdat de waarde van graden voor de 2de keer voorkomt. Hij moet deze 2de keer nog wel toevoegen aan de array maar moet daarna stoppen met z'n while loop. Om dit te doen moet ik neem ik aan controleren of een waarde al bestaat in een array. Dit te doen via
BinarySearch. Ik heb meerdere informatie hierover gevonden, heb hier ook een dik boek met daarin een stukje uitleg daarover en daaruit heb ik het idee dat ik niks fout doe.

Het probleem is namelijk: De binarysearch blijft ten alletijden een waarde hebben van -1000 deze wijzigd niet. Mijn vraag is kan iemand mij vertellen waar het fout gaat en vooral waarom het fout gaat?

Websites waar ik uitleg hierover vond:
http://www.c-sharpcorner....uly/WorkingWithArrays.asp
http://www.google.nl/sear...q=binarysearch+c%23&meta=

[Daos]

Waarschijnlijk is het dit:
msdn:

Searches an entire one-dimensional SORTED Array for a specific element

Binairy search werkt ongeveer zo:
Neem array = [1 2 3 4 5 6 7 8] en zoek bv 7.
Verdeel array in tweeen
[1 2 3 4] en [5 6 7 8]
getal <= 4 ga verder met linkerdeel, getal > 4 ga verder met rechterdeel.

Neem array = [5 6 7 8]
Verdeel array in tweeen
[5 6] [7 8]
getal <= 6 ga verder met linkerdeel, getal > 6 ga verder met rechterdeel.
enz. tot je 0 of 1 getallen overhoudt.

Dit hele algoritme heeft een complexiteit van O(log(n)).


Als het array niet gesorteerd is, dan is het beste wat je kan krijgen een complexiteit van O(n). Dit gaat gewoon met de linear search methode, oftewel aflopen van het hele array. Je kan ook de IndexOf methode gebruiken.

[ Voor 20% gewijzigd door Daos op 21-08-2005 20:35 ]

[whoami]

Een binary search kan je idd enkel doen op een gesorteerde lijst van gegevens.

Bij een binary search, ga je nl. die lijst in 2 gelijke delen gaan delen, en dan ga je nagaan in welk deel jouw element zou moeten voorkomen.
Dan ga je dat deel opnieuw in 2 gelijke delen opsplitsen, enz.... Dit lukt dus enkel maar als je lijst gesorteerd is.