1:
2:
3:

16 * N ?<? logN * N
16 ?<? logN
2^16 ?<? N					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:

type
  TMusikInfo=record
    DateiPfad: String;
    Titel: String;
    Interpret: String;
    Album: String;
    Genre: String;
    Jahr: Integer;
    TitelNr: Integer;
    Kommentar: String;
    Komponist: String;
    Encoder: String;
    Copyright: String;
    Sprache: String;
    Link: String;
    Format: String;
  end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:

unit U_Musikinfo;

interface

uses
  SysUtils, Classes;

type
  TMusikInfo=Class
    DateiPfad: String;  
    Titel: String;  
    Interpret: String;  
    Album: String;  
    Genre: String;
    Jahr: Integer;  
    TitelNr: Integer;  
    Kommentar: String;  
    Komponist: String;  
    Encoder: String;  
    Copyright: String;  
    Sprache: String;  
    Link: String;  
    Format: String;  
  end;

type TMusikInfos=class
  private
    FItems:TList;
    function GetItems(Index: Integer): TMusikInfo;
    procedure SetItems(Index: Integer; const Value: TMusikInfo);
    function GetCount: Integer;
  public
    function Add:TMusikInfo;
    procedure Delete(Index:Integer);
    procedure Clear;
    property Items[Index:Integer]:TMusikInfo read GetItems write SetItems;
    property Count:Integer read GetCount;

    procedure SortierenNachDateiPfad;
    procedure SortierenNachTitel;

    constructor Create; virtual;
    destructor Destroy; override;
end;

implementation

{$R *.dfm}

//Interne Funktionen zum Vergleichen

function Vergleich_Titel(Item1, Item2: Pointer): Integer;
var I1,I2:TMusikInfo;
begin
  I1:=TMusikInfo(Item1);
  I2:=TMusikInfo(Item2);

  Result:=0;
  if I1.Titel<I2.Titel then
    Result:=-1
  else
  if I1.Titel>I2.Titel then
    Result:=1
end;

function Vergleich_DateiPfad(Item1, Item2: Pointer): Integer;
var I1,I2:TMusikInfo;
begin
  I1:=TMusikInfo(Item1);
  I2:=TMusikInfo(Item2);

  Result:=0;
  if I1.DateiPfad<I2.DateiPfad then
    Result:=-1
  else
  if I1.DateiPfad>I2.DateiPfad then
    Result:=1
end;

{ TMusikInfos }

function TMusikInfos.GetItems(Index: Integer): TMusikInfo;
begin
  //Listenobjekt ausgeben
  Result:=TMusikInfo(FItems[Index]);
end;

procedure TMusikInfos.SetItems(Index: Integer; const Value: TMusikInfo);
begin
  //Listenobjekt setzen
  FItems[Index]:=Value;
end;

function TMusikInfos.Add: TMusikInfo;
begin
  //Neues Element erstellen und in Liste einfügen
  Result:=TMusikInfo.Create;
  FItems.Add(Result);
end;

procedure TMusikInfos.Delete(Index: Integer);
begin
  //Element entfernen (dabei freigeben)
  TMusikInfo(FItems[Index]).Free;
  FItems.Delete(Index);
end;

procedure TMusikInfos.Clear;
begin
  //Liste leeren (dabei Elemente freigeben)
  While FItems.Count>0 do
    Delete(0);
end;

function TMusikInfos.GetCount: Integer;
begin
  //Anzahl der Elemente zuückgeben
  Result:=FItems.Count;
end;

constructor TMusikInfos.Create;
begin
  //Interne Liste erstellen
  FItems:=TList.Create;
end;

destructor TMusikInfos.Destroy;
begin
  //Alle Elemente freigeben
  Clear;
  //interne Liste freigeben
  FItems.Free;
  inherited;
end;

procedure TMusikInfos.SortierenNachTitel;
begin
  FItems.Sort(Vergleich_Titel);
end;

procedure TMusikInfos.SortierenNachDateiPfad;
begin
  FItems.Sort(Vergleich_DateiPfad);
end;

end.					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:

procedure QuickSortIt (a : TIntegerArray; L,R : Integer);
var
  sp, I, J,p,t: Integer;
  s : Array [0..100,0..1] Of Integer; // Stack

begin
  fillchar (s,sizeOf(s),0);
  sp := 1;
  s[0,0] := L;
  s[0,1] := R;
  While sp>0 Do Begin           // solange noch Teillisten abzuarbeiten sind ...
    dec (sp);                   // Hole nächste Teillösung von Stack
    l := s[sp,0];
    r := s[sp,1];

    repeat                      // --------- Quicksort Anfang
      I := L;
      J := R;
      P := a[(L + R) shr 1];
      repeat
        while a[i]<p do inc (i);
        while a[j]>p do dec (j);
        if I <= J then
        begin
          T := a[I];a[I] := a[J];a[J] := T;
          Inc(I);
          Dec(J);
        end;
      until I > J;
      if L < J then begin       // Statt rekursivem Aufruf wird die Teilliste
        s[sp,0] := l; s[sp,1] := j; // auf den Stack geschoben und später
        inc (sp);               // sortiert
        End;
      L := I;
    until I >= R;               // --------- Quicksort Ende
    End;
end;