I. NEUTRIEDENÝ SÚBOR S PRIAMYM PRÍSTUPOM (HEAP ...

I. NEUTRIEDENÝ SÚBOR S PRIAMYM PRÍSTUPOM (HEAP)
- implicitná neutriedená tabuľka na disku (neefektívne vyhľadávanie)
Organizácia:
- záznamy v ľubovoľnom poradí bez ohľadu na hodnotu kľúča
- manažment blokov statický (v ďalšom)
- po zrušení sa už miesto neprideľuje,ostáva nevyužité (zjednodušenie)
Spracovanie:
1) Priamy prístup
a) sprístupnenie podľa kľúča:
CitajHeap (Subor, K, Oblast) - záznam s kľúčom K Oblast (ak ex.)
a) sprístupnenie podľa poradia:
CitajHeapPor (Subor, I, Oblast) - I-tý záznam Oblast
ďalšie (dynamické) operácie:
ZapisHeap (Subor, Oblast)
ZrusHeap (Subor, K)
ModifHeap (Subor, Oblast) - ak ex. záznam s kľúčom Oblast.Kľúč,
nahraď ho záznamom Oblast
VytvorHeap
OtvorHeap organizačné operácie
ZatvorHeap
2) Sekvenčný prístup
operáciou OtvorHeapSeq otvoríme existujúci heap pre sekvenčné
čítanie (nastavia sa buffery a mechanizmy pre anticipovaný vstup)
operáciou CitajHeapSeq (Oblast) sa sprístupňujú nasledujúce záznamy
operáciou ZatvorHeapSeq sa ukončí možnosť sekvenč. prístupu
Takéto spracovanie v neutriedenom poradí sa nazýva aj „sériové“.
Zložitosť: Pri čítaní podľa kľúča sa v najhoršom prípade prenesú všetky
bloky, v priemernom prípade polovica.
Fixovanie: Záznamy môžu byť fixované.
Užitočnosť: pre malé súbory alebo ako súčasť inak organizovaných súborov
(pozri súbory s úplným indexom).
+Heap.doc Strana 1 z 5

Hlava (blok 0)
PocBlokov 5
PocZaz 5
AktBlok 2
AktZaznam 3
PoslBlok 3
PoslZaznam 2
Volny 3
Obsadeny 1
Heap -Štruktúra riadiaceho bloku (príklad)
0 1 1 1 1 3 3 66 7 15 16
1 1 1 1 1 2 25 14 13 50 99
0 1 1 1 1 3 3 66 7 15 16
1 1 0 0 0 4 0 37 38
0 0 0 0 0 5
0 0 0 0 0 0
Buffer
Data
AktBlok ... aktuálny blok (je v bufferi)
AktZaznam ... práve spracovávaný záznam
PoslBlok ... blok, do ktorého sa bude zapisovať (zápis na koniec)
PoslZaznam ... posledne zapísaný záznam
Volny ... zoznam blokov (DalsiVol), v ktorých je miesto na zápis
Obsadený ... zoznam blokov (DalsiObs), v ktorých je platný záznam na čítanie
type TypBloku = record
Platny: array [1..Faktor] of boolean;
Zaznam: array [1..Faktor] of TypZaznamu;
DalsiVol, DalsiObs: integer
end;
type TypRiadiaci = record
PocBlok, PocZaz, AktBlok, AktZaznam, PoslBlok, PoslZaznam,
Volny, Obsadeny : integer
end;
+Heap.doc Strana 2 z 5
B1
B2
B3
B4
B5

Heap - Implementácia niektorých operácií
procedure VytvorHeap (var Subor: TypHeap; Rozsah, Fakt: integer);
var i,j: integer;
begin
new (Subor);
with Subor↑ do
begin
rewrite (Data);
with Hlava do
begin {inicializacia poloziek Hlavy}
PocBlokov := Rozsah; PocZaz := Fakt;
AktBlok := 0; AktZaznam:= 0; PoslBlok:= 0; PoslZaznam:= 0;
Volny:= 1; Obsadeny:= 0
end;
ZapisBlok (Data, Hlava, AktBlok);
with Buffer do {inicializacia a zapis blokov}
for i:= 1 to Rozsah do
begin
for j:=1 to Fakt do Platny[j] := false;
inc (DalsiVol); DalsiObs := 0;
if DalsiVol > rozsah then DalsiVol:= 0;
ZapisBlok (Data, Buffer, i)
end
end
end;
procedure OtvorHeap (var Subor: TypHeap);
begin
with Subor↑ do
begin
reset (Data);
CitajBlok (Data, Hlava, 0)
end
end;
procedure ZatvorHeap (var Subor: TypHeap);
begin
with Subor↑ do
begin
if AktBlok =/= 0 then ZapisBlok (Data, Buffer, AktBlok);
AktBlok:= 0; AktZaznam:= 0;
close (Data)
end
end;
+Heap.doc Strana 3 z 5

procedure ZapisHeap (var Subor:= TypHeap, Oblast: TypZaznamu,
var Zapisany: boolean); {zapis vzdy na koniec suboru}
{bez kontroly duplicity}
begin
with Subor↑, Hlava do
begin
Zapisany:= false;
if PoslBlok = 0 then exit {subor je zaplneny}
if AktBlok =/= PoslBlok then
begin
if AktBlok =/= 0 then ZapisBlok (Data, Buffer, AktBlok);
CitajBlok (Data, Buffer, PoslBlok);
AktBlok:= PoslBlok; {v bufferi blok, do ktoreho zapiseme}
end; {nasleduje formovanie a zapis zaznamu}
inc (PoslZaznam); AktZaznam:= PoslZaznam;
Buffer.Zaznam [PoslZaznam]:= Oblast;
Buffer.Platny [PoslZaznam]:= true;
if PoslZaznam = PocZaz then {blok sa zaplnil}
begin
PoslBlok:= Buffer.DalsiVol {prechod na dalsi blok}
Volny:=PoslBlok;
Buffer.DalsiObs:= PoslBlok; PoslZaznam:= 0
end;
Zapisany:= true
end
end;
procedure CitajHeap (var Subor: TypHeap; K: TypKluca;
var Oblast: TypZaznamu; var Precitany: boolean);
var i, Zarazka: integer;
begin
with Subor↑ do
begin
Precitany:= false;
if Hlava.Obsadeny = 0 then exit {prazdny subor}
with Hlava do
if AktBlok = 0 then {Buffer prazdny}
begin
AktBlok:= Obsadeny;
CitajBlok (Data, Buffer, AktBlok)
end else
begin
ZapisBlok (Data, Buffer, AktBlok); {zachrana aktualneho pred prepisom}
Zarazka:= AktBlok {bude cyklicka prehliadka blokov od AktBlok}
end;
+Heap.doc Strana 4 z 5

with Buffer do {zaciatok cyklickej prehliadky}
repeat {pre kazdy blok suboru}
i:= 0;
repeat {prehliadni Buffer}
inc (i);
if Platny [i] then if Zaznam [i].Kluc=K then Precitany:= true
until (i >= Hlava.PocZaz) or Precitany;
if not Precitany then
begin
if aktBlok =/= Zarazka then
if DalsiObs =/= 0 then AktBlok:= DalsiObs
else AktBlok:= Hlava.Obsadeny;
CitajBlok (Data, Buffer, AktBlok)
end else exit
until Precitany;
Precitany:= true;
Oblast:= Buffer.Zaznam[i];
Hlava. AktZaznam:=i
end
end;
procedure CitajHeapPor (var Subor: TypHeap; I: integer;
var Oblast: TypZaznamu; var Precitany:
boolean);
{ v poradi I-ty zaznam do Oblast}
var Blok, Zazn: integer;
begin
with Subor↑ do
begin
Precitany:= false;
if Obsadeny = 0 then exit {prazdny subor}
Blok:= (I div PocZaz) +1; Zazn:= I mod PocZaz;
if Blok =/= AktBlok then
begin
ZapisBlok (Data, Buffer, AktBlok);
AktBlok:= Blok;
CitajBlok (Data, Buffer, AktBlok)
end;
AktZaznam:= Zazn;
if Platny [AktZaznam] then
begin
Oblast:= Buffer.Zaznam [AktZaznam];
Precitany:= true
end
end
end;
+Heap.doc Strana 5 z 5