Problem beim Löschen aus einer TempList

[lblbw]

Hallo,

ich habe eine Firma, die Anzeigetafeln für den Kampfsport entwickelt und herstellt.
Die Kämpfer werden von der Software erfasst. Diese müssen dann zum wiegen, ob sie auch noch die gleiche Gewichtsklasse haben. Dabei kann es vorkommen, das noch Kämpfer nachgetragen werden müssen. Nun will ich diese Kämpfer nach Vereine sortieren. Aber die nachgetragenen Kämpfer stehen dann in der ListBox als seperater Verein drin. Die soll aber verhindert werden, und da ist mein Problem, entweder ist der Listenindex außerhalb oder das Programm stützt ab. Der Quelltext löscht die vorhanden doppelte Vereine, soweit sie alle untereinander stehen.

...

Delphi-Quellcode:

I:=0;
J := 0;
repeat
I := J;
repeat
Text1 := TempList2[I]
if Text1 = Templist2[I+1] then
begin
 TempList2.Delete(I+1);
end
else
begin
 I := I+1;
end;
until I = TempList2.Count-1;
J := J+1;
until J = TempList2.Count-1;
ListBox4.Items:=TempList2

Wusste jetzt nicht, wo ich das reinschreiben sollte

[atreju2oo0]

Irgendwie weiß ich immer noch nicht was genau das Problem ist...
Aber ich tipp mal so ins blaue hinein...

Falls im eigentlich letzten Durchgang der Schleife noch was gelöscht wird dann bringt

until I = TempList2.Count-1;

leider nix. Vielmehr müsste es dann heißen

until I >= TempList2.Count-1;

Genauso natürlich in der Abfrage darunter. Aber ob das des Rätsels Lösung ist weiß ich nicht, da ich keine Ahnung
habe was I, J oder TempList ist...
Außerdem ist es der Übersicht halber besser einzurücken... :zwinker:
Beschreibs einfach noch nen bissle genauer.

[lblbw]

Ich will die Vereine sortiert angeben, nur soll jeder jeweils nur 1 mal erscheinen, da ist das Problem. Wenn ein Kämpfer nachgetragen wird, dann erscheint dieser, als seperater Verein. D.h. es erscheinen 2 Vereine mit dem selben Namen. Und da liegt mein Problem.

edit: I,J sind Integerzahlen, TempList sind Strings
Brauche es dringends, wenns geht bis morgen früh

[Binärbaum]

Zitat:

Zitat von lblbw

Ich will die Vereine sortiert angeben, nur soll jeder jeweils nur 1 mal erscheinen, da ist das Problem. Wenn ein Kämpfer nachgetragen wird, dann erscheint dieser, als seperater Verein. D.h. es erscheinen 2 Vereine mit dem selben Namen. Und da liegt mein Problem.

Da kann man in in einer (For-)Schleife die Templist durchlaufen und (vor dem Eintragen) prüfen, ob der Verein schon eingetragen ist. Falls dies der Fall ist, trägt man den Verein nicht nochmals ein; wenn er nicht vorhanden ist, dann trägt man ihn in die Liste ein.

MfG
Binärbaum

[lblbw]

nein, so meinte ich das nicht. Nehmen wir mal jetzt diese Liste:, die er mir anzeigt

• JLC
• GHS
• HJC
• OBJ

So und dann wird beim wiegen ein Kämpfer nachgetragen, die unter ein unterprogramm eingetragen werden muss. Als beispiel jetzt ein Kämpfer wird von GHS nachgetragen. Soll er jetzt wieder nach den Vereinen laden, dann entsteht folgende Liste:

• JLC
• GHS
• HJC
• OBJ
• GHS

.

UND das ist das Problem

[sniper_w]

Schon mal was von Binary Trees gehört. Das wäre für dich eine Idealle lösung.
Hier ein Beispiel :

Delphi-Quellcode:

type
  PbinNode = ^TbinNode;
  TbinNode = packed record
    Word:string;              // Frei auszuwählende Variablen und deren Typen...
    Number:integer;           // Frei auszuwählende Variablen und deren Typen...
    left_child : PbinNode;
    right_child : PbinNode;
    parent : PbinNode;
  end;

function FindNode( p : Pbinnode; _text_ : string; var Node:pbinnode ):boolean;
function FindNode_n( p : Pbinnode; _text_ : string; var Node:pbinnode ):boolean;

function AddNode( p : Pbinnode; _text_ : string; parent_ : Pbinnode = nil):PbinNode;
procedure TreePrint( p : PbinNode);

var
  WordList : TStringList; // must be cleared before use of TreePrint procedure --->WordList.Clear;
                          // it is automatic created and destroyed..

implementation

(*
  Finds a node with the condition '_text_' = p^.Word.
  Returns true if the word _text_ exists in the tree
*)

// normal, no recursion, witch is much better

function FindNode_n( p : Pbinnode; _text_ : string; var Node:pbinnode ):boolean;
 var tempnode : Pbinnode;
begin
 tempnode := p;   // not really necessary or yes ? I think yes because p is a pointer...

 find_counter := 0;

 while (true) do
 begin

  inc (find_counter);

  if tempnode = nil then         // if we are in a dead end
          begin                  // if so, nothing found
           Result := False;
           Node := nil;
           Exit;
          end;

  if _text_ = tempnode^.Word then   // we fond it
        begin
         Node := tempnode;
         Result := True;
         Exit;
        end;

  // look on left
  if _text_ <  tempnode^.Word
        then tempnode := tempnode^.left_child

  else
  // look on right
  tempnode := tempnode^.right_child;

 end;
end;

function FindNode( p : Pbinnode; _text_ : string; var Node:pbinnode ):boolean; // recursive
begin
 inc (find_counter);
 if p = nil then
 begin                  // nothing found
  Result := False;
  Node := nil;
 end

        else
         // we found it
         if _text_ = p^.Word then
                begin
                 Node := p;
                 Result := true;
               end
        else
        // look on left
        if (_text_ < p^.Word) then Result := FindNode(p^.left_child, _text_, Node )

        else
        // look on right
        Result := FindNode(p^.right_child, _text_, Node);
end;

function AddNode( p : Pbinnode; _text_ : string; parent_ : Pbinnode = nil):PbinNode;
begin
  if p = nil then
  begin
    New(p);
    p^.Word := _text_;
    p^.Number := 1;
    p^.left_child := nil;
    p^.right_child := nil;
    p^.parent := parent_;
    inc(count);
  end

  else
        if (_text_ = p^.Word) then
                 Inc(p^.Number)// nothing happens
  else
        if (_text_ < p^.Word) then
                 p^.left_child := AddNode(p^.left_child, _text_, p)
  else
         p^.right_child := AddNode(p^.right_child,_text_, p);
  result := p;
end;

(*
 Puts the content of the tree in a string list as a sorted list of entries
 No dupicates are found in created list
*)

procedure TreePrint( p : PbinNode); // 0,1,2,3,4,5,6....
begin
  if (p <> nil) then
  begin
    TreePrint(p^.left_child);
    WordList.Add(p^.Word);
    TreePrint(p^.right_child);
  end;
end;

initialization

 WordList := TStringList.Create();
 WordList.Clear();      // there is no real need for this but never the less

finalization

 WordList.Free();

[teebee]

Du kannst von vorneherein verhindern, dass Duplikate von der ListBox akzeptiert werden:

Delphi-Quellcode:

ListBox.Items.Sorted := True; // ist Voraussetzung für die nächste Zeile
ListBox.Items.Duplicates := dupIgnore; // keine doppelten Einträge

Als Nebeneffekt ist die ListBox dann alphabetisch sortiert...

Gruß, teebee

[teebee]

Habe gerade schmerzlich bemerken müssen, dass es 'Duplicates' in einer ListBox leider nicht gibt. Ist also Quatsch, was ich oben geschrieben habe...
Aber so geht es natürlich auch:

Delphi-Quellcode:

If ListBox.Items.IndexOf(sVerein)=-1 Then
  ListBox.Items.Add(sVerein);

Gruß, teebee

[lblbw]

danke für eure Hilfen, habe den Quellcode von Teebee eingebaut, und sie funktioniert danke.