27.Prednaska/Cvicenie0: Rozdiel medzi revíziami

Z Pascal
Prejsť na: navigácia, hľadanie
 
(12 intermediate revisions by 2 users not shown)
Riadok 8: Riadok 8:
  
 
1. pre spájaný zoznam
 
1. pre spájaný zoznam
 +
{{Prog}}
 
  type
 
  type
 
   PVrchol = ^TVrchol;
 
   PVrchol = ^TVrchol;
Riadok 14: Riadok 15:
 
     Next: PVrchol;
 
     Next: PVrchol;
 
   end;
 
   end;
* napísať procedúru '''Pridaj(Z: PVrchol)''', ktorá za každý vrchol s párnou hodnotou vloží nový vrchol s nulovou hodnotou, napr. zo zoznamu
+
|}
 +
* 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
 
{{Prog}}
 
{{Prog}}
  4 -> 5 -> 6 -> 7 -> 8 ->  
+
  4 -> 5 -> 6 -> 7 -> 8 -> nil
 
|}
 
|}
 
:vyrobí zoznam
 
:vyrobí zoznam
 
{{Prog}}
 
{{Prog}}
  4 -> 0 -> 5 -> 6 -> 0 -> 7 -> 8 -> 0 ->
+
  4 -> 0 -> 5 -> 6 -> 0 -> 7 -> 8 -> 0 -> nil
 
|}
 
|}
  
Riadok 28: Riadok 30:
  
  
* vrchol ako objekt
+
* vrchol ako objekt - pracujeme s triedou '''TVrchol''' - definujeme v '''Unit1.pas'''
* 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
+
 
+
=== Domáca úloha ===
+
 
+
1. Z textového súboru slovnik.txt (dvojice slov: slovenské anglické - bez diakritiky). vytvoriť usporiadaný zoznam podľa anglického slova. Do triedy TSlovnik (spájaný zoznam) dodefinujte metódy na načítanie zo súboru a tiež na zápis do súboru, slová do zoznamu pridávajte metódou Zarad, ktorá zaradí dvojicu slov na správne miesto do slovníka, aby bol stále usporiadaný podľa anglického slova.
+
 
+
 
+
 
+
 
+
 
+
{{Nadpis| 27. Cvičenie}}
+
[[27.Prednaska|< 27.Prednáška]] | [[27.Prednaska/Ulohy|riešené úlohy]]
+
 
+
 
+
 
+
=== Rozcvička ===
+
 
+
PVrchol = ^TVrchol;
+
TVrchol = record
+
  Info:Integer;
+
  Next:PVrchol;
+
end;
+
 
+
* dany je spajany zoznam
+
* funkcia Urob(Z);
+
* za parnu hodnotu vrcholu prida dalsi s hodnotou 0
+
1 -> 2 -> 3 -> 4 -> nil
+
1 -> '''2''' -> 0 -> 3 -> '''4''' -> 0 -> nil
+
 
+
 
+
=== Cvičenie ===
+
 
+
 
+
1. pracujeme s triedou TVrchol v Unit1
+
 
  TVrchol = class
 
  TVrchol = class
   Info:Integer;
+
   Info: Integer;
   Next:TVrchol;
+
   Next: TVrchol;
   constructor Create(I:Integer; N:TVrchol);
+
   constructor Create(I: Integer; N: TVrchol);
   function Text:String;
+
   function Text: string;
 
  end;
 
  end;
   
+
  &nbsp;
  function TVrchol.Text: String
+
  function TVrchol.Text: string
 
  begin
 
  begin
   Writeln(Info);
+
   Result := ' ' + IntToStr(Info);
 
  end;
 
  end;
  
2. v novom module pouzijeme Unit1
+
* otestujeme - vytvoriť premennú typu '''TVrchol''', vložiť trojprvkový zoznam a vypísať
* vytvorit premennu typu TVrchol
+
  var
* vlozit trojprvkovy zoznam a vypisat
+
  Z: TVrchol;
  Z:=TVrchol.Create(3,TVrchol.Create(2,TVrchol.Create(1,nil)));
+
begin
Writeln(Z.Text, Z.Next.Text, Z.Next.Next.Text);
+
  Z := TVrchol.Create(5, TVrchol.Create(7, TVrchol.Create(11, nil)));
 +
  Writeln(Z.Text, Z.Next.Text, Z.Next.Next.Text);
  
3. trieda TZoznam obsahujuca spajany zoznam.
+
* definovať triedu '''TZoznam''' (v Unit1.pas) okrem '''Z''' a '''K''' aj metódu '''PridajZ''' - pridá vrchol na začiatok
* 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);
+
&nbsp;
 +
  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
+
  procedure TZoznam:Vypis;
+
var P:TVrchol;
+
 
  begin
 
  begin
   P:=Z;
+
  while Z <> nil do
 +
  begin
 +
    Write(Z.Text, ' -> ');
 +
    Z := Z.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
 
   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 TVrchol.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 171: Riadok 158:
 
   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 242: Riadok 229:
 
   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 262: Riadok 250:
 
  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
+
  P:TVrchol;
+
 
  begin
 
  begin
   if (z<>nil) and (Q.Z <> nil) then
+
   if A.Z <> nil then
 
   begin
 
   begin
     K.next:=A.Z;
+
     if Z = nil then
     K:=Q.K;
+
      Z := A.Z
     Q.Z:=nil;
+
    else
     Q.K:=nil;
+
      K.Next := A.Z;
 +
     K := A.K;
 +
     A.Z := nil;
 +
     A.K := nil;
 
   end;
 
   end;
  ... 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 ===
 
=== 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.
1. Vytvorte triedu TSlovnik, ktora do spajaneho zoznamu nacita zo suboru zoznam dvojic slov
+
{{Prog}}
 
  pes dog
 
  pes dog
 
  macka cat
 
  macka cat
  ...  
+
  ...
* zoznam v triede TSlovnik udrzujte utriedeny podla anglickych slovicok
+
|}
 +
* 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;
+
   Slov, Angl: string;
   Next:TVrchol;
+
   Next: TVrchol;
 
   ...
 
   ...
 
  end;
 
  end;
   
+
  &nbsp;
 
  TSlovnik = class
 
  TSlovnik = class
   Z:Tvrchol;
+
   Z: Tvrchol;
   constructor Create(subor:string);
+
   constructor Create(Subor: string);
   procedure Vloz(s, a:string);
+
   procedure Vloz(S, A: string);     ''// vloží do zoznamu na správne miesto ďalšiu dvojicu slov''
 +
  ...
 
  end;
 
  end;
 +
|}

Aktuálna revízia z 15:54, 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 := Z.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);
begin
  if A.Z <> nil then
  begin
    if Z = nil then
      Z := A.Z
    else
      K.Next := A.Z;
    K := A.K;
    A.Z := nil;
    A.K := nil;
  end;
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;