Results 1 to 6 of 6

Thread: Bepalen volgorde waarden in array

  1. #1

    Bepalen volgorde waarden in array

    Ik heb een array met waarden, zoals hieronder, waarvan ik de volgorde van grote moet hebben. En deze moet in de tweede regel van de array komen zoals hieronder
    Code:
    3.54 3.51 3.46 3.49 3.48 3.41 3.15 3.31
    1    2    5    3    4    6    8    7
    In een grijs verleden hebben we dit ooit gehad bij wiskunde. Maar ik heb geen idee meer hoe we dit deden. De vraag is hoe krijg ik dit het eenvoudigst in een procedure.
    Niets is zo gemakkelijk als het lijkt.

  2. #2
    Wiskunde???? O, ja, dat bestaat ook nog

    Je kunt het in Delphi vrij makkelijk zonder wiskunde doen:
    Delphi Code:
    1. uses System.Generics.Collections, System.Generics.Defaults;
    2.  
    3. // ...
    4.  
    5. TArray.Sort<Double>(mArr, TComparer<Double>.Construct(
    6.   function(const Left, Right: Double): Integer
    7.   begin
    8.     Result := TComparer<Double>.Default.Compare(Left, Right);
    9.   end));
    10. // nu is mArr gesorteerd (echter wel van laag naar hoog)
    (mArr is dan een array of double)

    mArr wordt gesorteerd van laag naar hoog. Als je van hoog naar laag wilt moet je Left en Right even omdraaien in de TComparer.
    TComparer<Double>.Default.Compare(Right, Left);

    Als je perse met de QuickSort e.d. aan de gang wilt gaan kan dat natuurlijk ook:
    Delphi Code:
    1. procedure QSort(var A: array of Double);
    2.  
    3.   procedure QuickSort(var A: array of Double; iLo, iHi: Integer);
    4.   var
    5.     Lo, Hi: Integer;
    6.     Mid, T: Double;
    7.   begin
    8.     Lo := iLo;
    9.     Hi := iHi;
    10.     Mid := A[(Lo + Hi) div 2];
    11.     repeat
    12.       while A[Lo] < Mid do
    13.           Inc(Lo);
    14.       while A[Hi] > Mid do
    15.           Dec(Hi);
    16.       if Lo <= Hi then
    17.       begin
    18.         T := A[Lo];
    19.         A[Lo] := A[Hi];
    20.         A[Hi] := T;
    21.         Inc(Lo);
    22.         Dec(Hi);
    23.       end;
    24.     until Lo > Hi;
    25.     if Hi > iLo then
    26.         QuickSort(A, iLo, Hi);
    27.     if Lo < iHi then
    28.         QuickSort(A, Lo, iHi);
    29.   end;
    30.  
    31. begin
    32.   QuickSort(A, Low(A), High(A));
    33. end;
    34.  
    35. // ...
    36.  
    37. QSort(mArr);
    38. // nu is mArr gesorteerd (echter wel van laag naar hoog)

  3. #3
    Senior Member EricLang's Avatar
    Join Date
    May 2002
    Location
    Holland
    Posts
    3,077
    Standaard sort kan zo:

    Code:
    TArray.Sort<Double>(mArr);

  4. #4
    Quote Originally Posted by EricLang View Post
    Standaard sort kan zo:
    Code:
    TArray.Sort<Double>(mArr);
    Rats... Die had ik als eerste geprobeerd maar gaf een foutmelding dacht ik. Maar nu werkt die inderdaad wel.
    (ik dacht even dat er geen standaard sort voor Double was)

    Maar als je omgekeerd wilt sorteren zul je toch zelf met een TComparer<Double> aan de gang moeten en die Left en Right omdraaien.

  5. #5
    Senior Member EricLang's Avatar
    Join Date
    May 2002
    Location
    Holland
    Posts
    3,077
    Je vergat nog bubble sort :-))

  6. #6
    Hm, zat dus al weer veel te moeilijk te doen. Bedankt jongens. Werkt :-)
    Niets is zo gemakkelijk als het lijkt.

Thread Information

Users Browsing this Thread

There are currently 1 users browsing this thread. (0 members and 1 guests)

Bookmarks

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •