27.Prednaska/Cvicenie0: Rozdiel medzi revíziami

Z Pascal
Prejsť na: navigácia, hľadanie
(Domáca úloha)
Riadok 31: Riadok 31:
  
 
* vrchol ako objekt
 
* vrchol ako objekt
* metódy triedy '''TZoznam'''
 
** rôzne konštruktory: otvorené pole, textový/binárny súbor, reťazec, iný zoznam
 
** konštruktor generuje postupnosť
 
** deštruktor uloží do súboru
 
** funkcia vráti dynamické pole z hodnôt zoznamu
 
* udržiavať zoznam utriedený - pridávať na správne miesto (za menší pred väčší)
 
* minimálny prvok presťahuje na začiatok
 
* procedurálny typ
 
* metódy dvojsmerného spájaného zoznamu
 
* metódy cyklického spájaného zoznamu
 
  
Ďalšie námety na metódy pre triedu '''TZoznam''':
+
* pracujeme s triedou '''TVrchol''' - definujeme v '''Unit1.pas'''
* procedure VyhodZ;                    ''// vyhodí prvý prvok''
+
* procedure VyhodK;                    ''// vyhodí posledný prvok''
+
* procedure VyhodIty(Index: Integer);  ''// vyhodí prvok s indexom Index''
+
* procedure Vyhod(I: Integer);        ''// vyhodí prvok s Info I''
+
* procedure Prevrat;                  ''// prevráti poradie prvkov v zozname''
+
* function Najdi(I: Integer): Integer; ''// zistí index''
+
* procedure Utried;
+
** nájde minimum, dá ho na začiatok, znovu nájde minimum zo zvyšku, dá ho za minimum, ...
+
* procedure zarad(I: Integer);
+
** zaradí prvok do zoznamu, aby ostal zoznam utriedený
+
* procedure VyhodDuplikaty;
+
** vyhodí vrcholy s rovnakým Info - nechá len prvý z nich
+
* function Ity(I: Integer): TVrchol;    ''// vráti í-ty prvok''
+
* constructor Citaj(Stream: TStream);  ''// načíta zoznam z prúdu''
+
 
+
 
+
 
+
 
+
=== Domáca úloha ===
+
 
+
1. Vytvorte triedu '''TSlovnik''', ktorá do spájaného zoznamu načíta zo súboru (napr. '''slovnik.txt''') zoznam dvojíc slov (slovenské anglické), napr.
+
{{Prog}}
+
pes dog
+
macka cat
+
...
+
|}
+
* trieda '''TSlovnik''' je spájaným zoznamom, ktorý bude mať vrcholy utriedené podľa anglických slovíčok, napr.
+
{{Prog}}
+
 
  TVrchol = class
 
  TVrchol = class
   Slov, Angl: string;
+
   Info: Integer;
 
   Next: TVrchol;
 
   Next: TVrchol;
   ...
+
   constructor Create(I: Integer; N: TVrchol);
 +
  function Text: string;
 
  end;
 
  end;
 
   
 
   
  TSlovnik = class
+
  function TVrchol.Text: string
  Z: Tvrchol;
+
begin
   constructor Create(Subor: string);
+
   Result := ' ' + IntToStr(Info);
  procedure Vloz(S, A: string);     ''// vloží do zoznamu na správne miesto ďalšiu dvojicu slov''
+
  ...
+
 
  end;
 
  end;
|}
 
 
 
 
 
----
 
  
 
+
* otestujeme - vytvoriť premennú typu '''TVrchol''', vložiť trojprvkový zoznam a vypísať
1. pracujeme s triedou TVrchol v Unit1
+
  var
  TVrchol = class
+
   Z: TVrchol;
   Info:Integer;
+
  Next:TVrchol;
+
  constructor Create(I:Integer; N:TVrchol);
+
  function Text:String;
+
end;
+
+
function TVrchol.Text: String
+
 
  begin
 
  begin
   Writeln(Info);
+
   Z := TVrchol.Create(5, TVrchol.Create(7, TVrchol.Create(11, nil)));
end;
+
  Writeln(Z.Text, Z.Next.Text, Z.Next.Next.Text);
  
2. v novom module pouzijeme Unit1
+
* definovať triedu '''TZoznam''' (v Unit1.pas) okrem '''Z''' a '''K''' aj metódu '''PridajZ''' - pridá vrchol na začiatok
* vytvorit premennu typu TVrchol
+
* vlozit trojprvkovy zoznam a vypisat
+
Z:=TVrchol.Create(3,TVrchol.Create(2,TVrchol.Create(1,nil)));
+
Writeln(Z.Text, Z.Next.Text, Z.Next.Next.Text);
+
 
+
3. trieda TZoznam obsahujuca spajany zoznam.
+
* Obsahuje zaciatok a koniec a proceduru PridajZ, ktora prida vrchol na zaciatok
+
 
  TZoznam = class
 
  TZoznam = class
   Z, K:TVrchol;
+
   Z, K: TVrchol;
 +
  procedure PridajZ(I: Integer);
 
  end;
 
  end;
  procedure TZoznam:PridajZ(I:Integer);
+
 
 +
  procedure TZoznam.PridajZ(I: Integer);
 
  begin
 
  begin
   Z:=Vrchol.Create(I, Z);
+
   Z := Vrchol.Create(I, Z);
 
   if Z.Next = nil then
 
   if Z.Next = nil then
  K:=Z;
+
    K := Z;
 
  end;
 
  end;
  
4. metoda TZoznam.Vypis
+
* definovať metódu '''Vypis''' (u nás sa podarilo takéto chybné riešenie, tak sme ho ďalej takéto testovali)
* vypise zoznam od zaciatku po koniec
+
procedure TZoznam.Vypis;
* pozor na to, aby sme namiesto pomocnej premennej P nepracovali priamo so Z, aby potom nedoslo k strate informacie o zaciatku zoznamu
+
begin
  procedure TZoznam:Vypis;
+
  while Z <> nil do
  var P:TVrchol;
+
  begin
 +
    Write(Z.Text, ' -> ');
 +
    Z := P.Next;
 +
  end;
 +
  Writeln;
 +
end;
 +
 
 +
* test metód
 +
var
 +
  Zoznam: TZoznam;
 +
  I: Integer;
 +
begin
 +
  Zoznam := TZoznam.Create;
 +
  for I := 1 to 8 do
 +
    Zoznam.PridajZ(I);
 +
  Zoznam.Vypis;
 +
  Zoznam.PridajZ(9);
 +
  Zoznam.Vypis;
 +
 
 +
* po prvom výpise zoznamu je tento už prázdny (metóda '''Vypis''' okrem výpisu ho vyprázdni), treba si to zapamätať a teda opraviť
 +
  procedure TZoznam.Vypis;
 +
  var
 +
  P: TVrchol;
 
  begin
 
  begin
   P:=Z;
+
   P := Z;
 
   while P <> nil do
 
   while P <> nil do
 
   begin
 
   begin
 
     Write(P.Text, ' -> ');
 
     Write(P.Text, ' -> ');
     P:=P.Next;
+
     P := P.Next;
 
   end;
 
   end;
 
   Writeln;
 
   Writeln;
 
  end;
 
  end;
* test procedury v druhom module
 
Z:=TZoznam.Create;
 
for i:=1 to 8 do
 
  Z.PridajZ(i);
 
Z.Vypis;
 
Z.PridajZ(9);
 
Z.Vypis;
 
  
5. metoda TZoznam.PridajK
+
* metóda TZoznam.PridajK - pridá vrchol na koniec (aby sme predišli chybám, je dobre si situáciu nakresliť)
* prida vrchol na koniec
+
  procedure TZoznam.PridajK(I: Integer);
* aby sme predisli chybam je dobre situaciu si nakreslit
+
  var
  procedure TZoznam:PridajK;
+
  R: TVrchol;
  var R:Tvrchol;
+
 
  begin
 
  begin
   R:=Vrchol.Create(I, nil);
+
   R := Vrchol.Create(I, nil);
 
   if K = nil then
 
   if K = nil then
 
   begin
 
   begin
     Z:=R; K:=R;
+
     Z := R;
 +
    K := R;
 
   end
 
   end
 
   else
 
   else
     K.next:=R;
+
  begin
 +
     K.Next := R;
 +
    K := R;
 +
  end;
 
  end;
 
  end;
+
 
6. metoda TZoznam.VyhodZ
+
* metóda TZoznam.VyhodZ - vyhodí prvý vrchol
* vyhodi prvy vrchol
+
  procedure TZoznam.VyhodZ;
  procedure TZoznam:VyhodZ;
+
  var
  var P:Tvrchol;
+
  P: TVrchol;
 
  begin
 
  begin
  P:=Z;
+
   if Z <> nil then
   if P <> nil then
+
 
   begin
 
   begin
     P:=Z.Next;
+
     P := Z.Next;
 
     Z.Free;
 
     Z.Free;
     Z:=P;
+
     Z := P;
   
+
     if Z.Next = nil then
     if Z = nil then
+
       K := P;
       K:=P;
+
 
   end
 
   end
 
  end;
 
  end;
+
 
7. konstruktor
+
* deštruktor '''Dispose''' (aj pomocou '''VyhodZ''')
* bez parametra aj s parametrom
+
destructor TZoznam.Destroyô
 +
begin
 +
  while Z <> nil do
 +
    VyhodZ;
 +
end;
 +
 
 +
* trieda '''TZoznam''' môže mať viac konštruktorov - zatiaľ sme používali bez parametrov, ak chceme aj s parametrom (a aby fungoval aj bez parametrov) musíme zadefinovať oba
 
  class TZoznam
 
  class TZoznam
 
   constructor Create;
 
   constructor Create;
   constructor Create(N:integer);
+
   constructor Create(N: Integer);     ''// vytvorí zoznam čísel 1 -> 2 -> ... N ->''
 
   ...
 
   ...
 
+
&nbsp;
  constructor TZoznam.Create(N: integer);
+
constructor TZoznam.Create;
 +
begin
 +
end;
 +
&nbsp;
 +
  constructor TZoznam.Create(N: Integer);
 
  begin
 
  begin
 
   while N > 0 do
 
   while N > 0 do
Riadok 191: Riadok 160:
 
   end;
 
   end;
 
  end;
 
  end;
* v testovacom module mozeme for cyklus nahradit konstruktorom
 
Z:=TZoznam.Create(8);
 
  
8. Limitovat vypis na 100 prvkov
+
* chceme to otestovať pre veľké '''N''' - aby mal zmysel výpis metódou '''Vypis''' aj pre veľké N (napr. 1000000), upravíme túto metódu - výpis maximálne prvých 100 prvkov (ak pridlhý zoznam, tak len prvých 100)
  procedure TZoznam:Vypis;
+
  procedure TZoznam.Vypis;
  var  
+
  var
   P:TVrchol;
+
   P: TVrchol;
   i:integer;
+
   I: Integer;
 
  begin
 
  begin
   P:=Z;
+
   P := Z;
   i:=0;
+
   I := 0;
   while (P <> nil) and (i < 100) do
+
   while (P <> nil) and (I < 100) do
 
   begin
 
   begin
 
     Write(P.Text, ' -> ');
 
     Write(P.Text, ' -> ');
     P:=P.Next;
+
     P := P.Next;
     Inc(i);
+
     Inc(I);
 
   end;
 
   end;
   if (P <> nil)
+
   if P <> nil then
 
     Write('...');
 
     Write('...');
 
   Writeln;
 
   Writeln;
 
  end;
 
  end;
  
9. metoda TZoznam.pocet
+
* metóda '''Pocet''' zistí počet prvkov zoznamu
  function TZoznam:Pocet :integer;
+
  function TZoznam.Pocet: Integer;
  var  
+
  var
 
   P:TVrchol;
 
   P:TVrchol;
  i:integer;
 
 
  begin
 
  begin
   P:=Z;
+
   P := Z;
   i:=0;
+
   Result := 0;
   while (P <> nil) do
+
   while P <> nil do
 
   begin
 
   begin
     P:=P.Next;
+
     P := P.Next;
     Inc(i);
+
     Inc(Result);
 
   end;
 
   end;
  result := i;
 
 
  end;
 
  end;
* test
+
 
  Z:=TZoznam.Create(1000000);
+
* otestujeme
 +
  Z := TZoznam.Create(1000000);
 
  Z.Vypis;
 
  Z.Vypis;
  Z.Pridaj(9);
+
  Z.PridajZ(9);
 
  Z.Vypis;
 
  Z.Vypis;
 
  Writeln('Pocet = ', Z.Pocet);
 
  Writeln('Pocet = ', Z.Pocet);
  
10. konstruktor s otvorenym polom ako parametrom
+
* konštruktor s parametrom otvoreným poľom
  constructor TZoznam.Create(A:array of integer);
+
  constructor TZoznam.Create(A: array of Integer);
  var i:integer;
+
  var
 +
  I: Integer;
 
  begin
 
  begin
   for i := 0 to high(A) do
+
   for I := 0 to High(A) do
     PridajK(A[i]);
+
     PridajK(A[I]);
 
  end;
 
  end;
* ina moznost napisat for cyklus
+
 
  constructor TZoznam.Create(A:array of integer);
+
* iná možnosť napísať for-cyklus
  var i:integer;
+
  constructor TZoznam.Create(A: array of Integer);
 +
  var
 +
  I: Integer;
 
  begin
 
  begin
   for i in A do
+
   for I in A do
     PridajK(i);
+
     PridajK(I);
 
  end;
 
  end;
  
11. konstruktor, ktory dostava iny zoznam ako parameter a vytvori kopiu zoznamu
+
* konštruktor, ktorý dostáva iný zoznam ako parameter a vytvorí kópiu tohto zoznamu
  constructor TZoznam.Create(A:TZoznam);
+
  constructor TZoznam.Create(A: TZoznam);
  var  
+
  var
   P:TVrchol;
+
   P: TVrchol;
 
  begin
 
  begin
   P:=A.Z;
+
   P := A.Z;
 
   while P <> nil do
 
   while P <> nil do
 
   begin
 
   begin
Riadok 262: Riadok 231:
 
   end;
 
   end;
 
  end;
 
  end;
* test
+
 
  Z:=TZoznam.Create([2,3,5,7,11,13]);
+
* otestujeme, napr.
  R:=TZoznam.Create(Z);
+
  Z := TZoznam.Create([2, 3, 5, 7, 11, 13]);
 +
  R := TZoznam.Create(Z);
 
  R.PridajK(17);
 
  R.PridajK(17);
 
  Z.Vypis;
 
  Z.Vypis;
 
  R.Vypis;
 
  R.Vypis;
  
12. procedura append
+
* procedúra '''Append''' - pripojí iný zoznam na koniec svojho - robí pritom kópiu prvkov
  procedure TZoznam.Append(A:TZoznam);
+
  procedure TZoznam.Append(A: TZoznam);
  var  
+
  var
   P:TVrchol;
+
   P: TVrchol;
 
  begin
 
  begin
   P:=A.Z;
+
   P := A.Z;
 
   while P <> nil do
 
   while P <> nil do
 
   begin
 
   begin
Riadok 282: Riadok 252:
 
  end;
 
  end;
  
13. procedura append rychlejsie
+
* druhá verzia procedury '''Append''' - nerobí kópi prvkov, ale priamo si ho pripojí - iný zoznam pri tom zruší
  procedure TZoznam.Append(A:TZoznam);
+
  procedure TZoznam.Append(A: TZoznam);
  var  
+
  var
   P:TVrchol;
+
   P: TVrchol;
 
  begin
 
  begin
   if (z<>nil) and (Q.Z <> nil) then
+
   if (Z <> nil) and (Q.Z <> nil) then
 
   begin
 
   begin
 
     K.next:=A.Z;
 
     K.next:=A.Z;
Riadok 296: Riadok 266:
 
   ... zvysne kombinacie testov na nil
 
   ... zvysne kombinacie testov na nil
 
  end;
 
  end;
 +
 +
 +
{{Podnadpis|ďalšie námety}}
 +
 +
 +
* ďalšie konštruktory: textový/binárny súbor, reťazec s číslami oddelenými medzerami, iný zoznam v opačnom poradí prvkov
 +
* deštruktor uloží zoznam do súboru
 +
* funkcia '''VyrobPole''' vráti dynamické pole z hodnôt zoznamu
 +
* udržiavať zoznam utriedený - pridávať na správne miesto (za menší pred väčší)
 +
* minimálny prvok presťahuje na začiatok
 +
* '''VyhodK''' - vyhodí posledný prvok
 +
* '''VyhodIty(Index: Integer)''' - vyhodí prvok s indexom '''Index'''
 +
* '''Vyhod(I: Integer)''' - vyhodí prvok s daným Info
 +
* '''Prevrat''' - prevráti poradie prvkov v zozname
 +
* '''Najdi(I: Integer): Integer''' - zistí index
 +
* procedurálny typ ...
 +
* metódy dvojsmerného spájaného zoznamu
 +
* metódy cyklického spájaného zoznamu
 +
 +
 +
=== Domáca úloha ===
 +
 +
1. Vytvorte triedu '''TSlovnik''', ktorá do spájaného zoznamu načíta zo súboru (napr. '''slovnik.txt''') zoznam dvojíc slov (slovenské anglické), napr.
 +
{{Prog}}
 +
pes dog
 +
macka cat
 +
...
 +
|}
 +
* trieda '''TSlovnik''' je spájaným zoznamom, ktorý bude mať vrcholy utriedené podľa anglických slovíčok, napr.
 +
{{Prog}}
 +
TVrchol = class
 +
  Slov, Angl: string;
 +
  Next: TVrchol;
 +
  ...
 +
end;
 +
&nbsp;
 +
TSlovnik = class
 +
  Z: Tvrchol;
 +
  constructor Create(Subor: string);
 +
  procedure Vloz(S, A: string);    ''// vloží do zoznamu na správne miesto ďalšiu dvojicu slov''
 +
  ...
 +
end;
 +
|}

Verzia zo dňa a času 07:00, 5. marec 2013

27. Cvičenie


< 27.Prednáška | riešené úlohy


Rozcvička

1. pre spájaný zoznam

type
  PVrchol = ^TVrchol;
  TVrchol = record
    Info: Integer;
    Next: PVrchol;
  end;
  • napísať procedúru Urob(Z: PVrchol), ktorá za každý vrchol s párnou hodnotou vloží nový vrchol s nulovou hodnotou, napr. zo zoznamu
4 -> 5 -> 6 -> 7 -> 8 -> nil
vyrobí zoznam
4 -> 0 -> 5 -> 6 -> 0 -> 7 -> 8 -> 0 -> nil


Cvičenie

  • vrchol ako objekt
  • pracujeme s triedou TVrchol - definujeme v Unit1.pas
TVrchol = class
  Info: Integer;
  Next: TVrchol;
  constructor Create(I: Integer; N: TVrchol);
  function Text: string;
end;
 
function TVrchol.Text: string
begin
  Result := ' ' + IntToStr(Info);
end;
  • otestujeme - vytvoriť premennú typu TVrchol, vložiť trojprvkový zoznam a vypísať
var
  Z: TVrchol;
begin
  Z := TVrchol.Create(5, TVrchol.Create(7, TVrchol.Create(11, nil)));
  Writeln(Z.Text, Z.Next.Text, Z.Next.Next.Text);
  • definovať triedu TZoznam (v Unit1.pas) okrem Z a K aj metódu PridajZ - pridá vrchol na začiatok
TZoznam = class
  Z, K: TVrchol;
  procedure PridajZ(I: Integer);
end;
 
procedure TZoznam.PridajZ(I: Integer);
begin
  Z := Vrchol.Create(I, Z);
  if Z.Next = nil then
    K := Z;
end;
  • definovať metódu Vypis (u nás sa podarilo takéto chybné riešenie, tak sme ho ďalej takéto testovali)
procedure TZoznam.Vypis;
begin
  while Z <> nil do
  begin
    Write(Z.Text, ' -> ');
    Z := P.Next;
  end;
  Writeln;
end;
  • test metód
var
  Zoznam: TZoznam;
  I: Integer;
begin
  Zoznam := TZoznam.Create;
  for I := 1 to 8 do
    Zoznam.PridajZ(I);
  Zoznam.Vypis;
  Zoznam.PridajZ(9);
  Zoznam.Vypis;
  • po prvom výpise zoznamu je tento už prázdny (metóda Vypis okrem výpisu ho vyprázdni), treba si to zapamätať a teda opraviť
procedure TZoznam.Vypis;
var
  P: TVrchol;
begin
  P := Z;
  while P <> nil do
  begin
    Write(P.Text, ' -> ');
    P := P.Next;
  end;
  Writeln;
end;
  • metóda TZoznam.PridajK - pridá vrchol na koniec (aby sme predišli chybám, je dobre si situáciu nakresliť)
procedure TZoznam.PridajK(I: Integer);
var
  R: TVrchol;
begin
  R := Vrchol.Create(I, nil);
  if K = nil then
  begin
    Z := R;
    K := R;
  end
  else
  begin
    K.Next := R;
    K := R;
  end;
end;
  • metóda TZoznam.VyhodZ - vyhodí prvý vrchol
procedure TZoznam.VyhodZ;
var
  P: TVrchol;
begin
  if Z <> nil then
  begin
    P := Z.Next;
    Z.Free;
    Z := P;
    if Z.Next = nil then
      K := P;
  end
end;
  • deštruktor Dispose (aj pomocou VyhodZ)
destructor TZoznam.Destroyô
begin
  while Z <> nil do
    VyhodZ;
end;
  • trieda TZoznam môže mať viac konštruktorov - zatiaľ sme používali bez parametrov, ak chceme aj s parametrom (a aby fungoval aj bez parametrov) musíme zadefinovať oba
class TZoznam
  constructor Create;
  constructor Create(N: Integer);     // vytvorí zoznam čísel 1 -> 2 -> ... N ->
  ...
 
constructor TZoznam.Create;
begin
end;
 
constructor TZoznam.Create(N: Integer);
begin
  while N > 0 do
  begin
    PridajZ(N);
    Dec(N);
  end;
end;
  • chceme to otestovať pre veľké N - aby mal zmysel výpis metódou Vypis aj pre veľké N (napr. 1000000), upravíme túto metódu - výpis maximálne prvých 100 prvkov (ak pridlhý zoznam, tak len prvých 100)
procedure TZoznam.Vypis;
var
  P: TVrchol;
  I: Integer;
begin
  P := Z;
  I := 0;
  while (P <> nil) and (I < 100) do
  begin
    Write(P.Text, ' -> ');
    P := P.Next;
    Inc(I);
  end;
  if P <> nil then
    Write('...');
  Writeln;
end;
  • metóda Pocet zistí počet prvkov zoznamu
function TZoznam.Pocet: Integer;
var
  P:TVrchol;
begin
  P := Z;
  Result := 0;
  while P <> nil do
  begin
    P := P.Next;
    Inc(Result);
  end;
end;
  • otestujeme
Z := TZoznam.Create(1000000);
Z.Vypis;
Z.PridajZ(9);
Z.Vypis;
Writeln('Pocet = ', Z.Pocet);
  • konštruktor s parametrom otvoreným poľom
constructor TZoznam.Create(A: array of Integer);
var
  I: Integer;
begin
  for I := 0 to High(A) do
    PridajK(A[I]);
end;
  • iná možnosť napísať for-cyklus
constructor TZoznam.Create(A: array of Integer);
var
  I: Integer;
begin
  for I in A do
    PridajK(I);
end;
  • konštruktor, ktorý dostáva iný zoznam ako parameter a vytvorí kópiu tohto zoznamu
constructor TZoznam.Create(A: TZoznam);
var
  P: TVrchol;
begin
  P := A.Z;
  while P <> nil do
  begin
    PridajK(P.Info);
    P := P.Next;
  end;
end;
  • otestujeme, napr.
Z := TZoznam.Create([2, 3, 5, 7, 11, 13]);
R := TZoznam.Create(Z);
R.PridajK(17);
Z.Vypis;
R.Vypis;
  • procedúra Append - pripojí iný zoznam na koniec svojho - robí pritom kópiu prvkov
procedure TZoznam.Append(A: TZoznam);
var
  P: TVrchol;
begin
  P := A.Z;
  while P <> nil do
  begin
    PridajK(P.Info);
    P := P.Next;
  end;
end;
  • druhá verzia procedury Append - nerobí kópi prvkov, ale priamo si ho pripojí - iný zoznam pri tom zruší
procedure TZoznam.Append(A: TZoznam);
var
  P: TVrchol;
begin
  if (Z <> nil) and (Q.Z <> nil) then
  begin
    K.next:=A.Z;
    K:=Q.K;
    Q.Z:=nil;
    Q.K:=nil;
  end;
  ... zvysne kombinacie testov na nil
end;



ďalšie námety



  • ďalšie konštruktory: textový/binárny súbor, reťazec s číslami oddelenými medzerami, iný zoznam v opačnom poradí prvkov
  • deštruktor uloží zoznam do súboru
  • funkcia VyrobPole vráti dynamické pole z hodnôt zoznamu
  • udržiavať zoznam utriedený - pridávať na správne miesto (za menší pred väčší)
  • minimálny prvok presťahuje na začiatok
  • VyhodK - vyhodí posledný prvok
  • VyhodIty(Index: Integer) - vyhodí prvok s indexom Index
  • Vyhod(I: Integer) - vyhodí prvok s daným Info
  • Prevrat - prevráti poradie prvkov v zozname
  • Najdi(I: Integer): Integer - zistí index
  • procedurálny typ ...
  • metódy dvojsmerného spájaného zoznamu
  • metódy cyklického spájaného zoznamu


Domáca úloha

1. Vytvorte triedu TSlovnik, ktorá do spájaného zoznamu načíta zo súboru (napr. slovnik.txt) zoznam dvojíc slov (slovenské anglické), napr.

pes dog
macka cat
...
  • trieda TSlovnik je spájaným zoznamom, ktorý bude mať vrcholy utriedené podľa anglických slovíčok, napr.
TVrchol = class
  Slov, Angl: string;
  Next: TVrchol;
  ...
end;
 
TSlovnik = class
  Z: Tvrchol;
  constructor Create(Subor: string);
  procedure Vloz(S, A: string);     // vloží do zoznamu na správne miesto ďalšiu dvojicu slov
  ...
end;