to get the file

Podstawy programowania
Laboratorium 13
Powtórzenie
mgr inż. Tomasz Michno
1
Parametry procedur i funkcji
Istnieją 3 rodzaje przekazywanie parametrów do procedur i funkcji.
1.1
Przekazywanie przez wartość
Najczęściej spotykane przekazywanie parametrów, pozwala na przekazanie
wartości do procedury lub funkcji. Wartości te są reprezentowane przez
zmienne lokalne, dostępne tylko we wnętrzu procedury/funkcji, co oznacza
że wszelkie modyfikacje nie będą widoczne na zewnątrz.
procedure p r o c e d u r a ( w a r t o s c : integer ) ;
begin
inc ( wartosc ) ;
writeln ( ’ Wartosc ␣=␣ ’ , w a r t o s c ) ;
end ;
BEGIN
zmienna : = 2 ;
p r o c e d u r a ( zmienna ) ; { w y p i s z e Wartosc = 3}
writeln ( ’ Wartosc ␣=␣ ’ , zmienna ) ;
{ w y p i s z e Wartosc = 2}
END.
1.2
Przekazywanie przez stałą
Pozwala na przekazanie do wnętrza procedury/funkcji zmiennej, która jest
tylko do odczytu, co oznacza że wszelkie jej modyfikacje spowodują, że program się nie skompiluje.
procedure p r o c e d u r a ( const w a r t o s c : integer ) ;
begin
{ i n c ( w a r t o s c ) ; − spowoduje b l a d }
writeln ( ’ Wartosc ␣=␣ ’ , w a r t o s c ) ;
end ;
1.3
Przekazywanie przez zmienną (adres)
W przeciwieństwie do powyższych dwóch sposobów ten sposób przekazywania zmiennych do procedur/funkcji pozwala na korzystanie z nich w pełnym
zakresie - wszelkie modyfikacje będą widoczne poza wnętrzem procedury/funkcji.
procedure p r o c e d u r a ( var w a r t o s c : integer ) ;
begin
inc ( wartosc ) ;
writeln ( ’ Wartosc ␣=␣ ’ , w a r t o s c ) ;
end ;
BEGIN
zmienna : = 2 ;
p r o c e d u r a ( zmienna ) ; { w y p i s z e Wartosc = 3}
writeln ( ’ Wartosc ␣=␣ ’ , zmienna ) ;
{ w y p i s z e Wartosc = 3}
END.
2
Tablice
Deklaracja tablicy jednowymiarowej:
t a b l i c a : array [ 1 . . 5 ] of integer ;
t a b l i c a 2 : array [ − 1 0 0 . . 1 0 5 ] of byte ;
t a b l i c a 3 : array [ 0 . . 5 0 ] of char ;
Indeksem tablicy w Pascalu może być dowolna liczba całkowita (nawet ujemna),
a także znak (char), np.:
tablica
2.1
: array [ ’ a ’ . . ’ z ’ ] of integer ;
Tablice w parametrach procedur i funkcji
Aby użyć tablicy w parametrze należy najpierw zdefiniować jej typ w sekcji
type.
type
typTablicowy
= array [ 1 . . 5 ] of integer ;
procedure wypisz ( var t a b l i c a : typTablicowy ) ;
var
i : byte ;
begin
writeln ( ’ Zawartosc ␣ t a b l i c y : ’ ) ;
for i :=1 to 5 do
write ( t a b l i c a [ i ] , ’ ␣ ’ ) ;
writeln ;
end ;
2.2
Tablice nieposortowane
Ich wartości nie są uporządkowane, każdy element może posiadać inną wartość, należy jednak pamiętać że mogą się one również powatarzać.
2.2.1
Wartości minimalne i maksymalne
Najprostszy algorytm polega na przyjęciu, że pierwszy element jest minimalny/maksymalny. Następnie należy przejść po wszystkich następnych elementach i sprawdzić, czy któryś z nich nie jest mniejszy/większy:
type
TTablica = array [ 1 . . 5 ] of integer ;
...
procedure znajdzMinimum ( var tab : TTablica ) ;
var
min : integer ;
i
: integer ;
begin
min:= tab [ 1 ] ;
for i :=2 to 5 do
i f ( tab [ i ]<min ) then min:= tab [ i ] ;
writeln ( ’ Minimalna ␣ w a r t o s c ␣ t o ␣=␣ ’ , min ) ;
end ;
procedure znajdzMaximum ( var tab : TTablica ) ;
var
max : integer ;
i
: integer ;
begin
max:= tab [ 1 ] ;
for i :=2 to 5 do
i f ( tab [ i ]>max) then max:= tab [ i ] ;
writeln ( ’ Maksymalna␣ w a r t o s c ␣ t o ␣=␣ ’ , max ) ;
end ;
2.2.2
Wyszukiwanie elementu (Wyszukiwanie liniowe)
W celu znalezienia elementu należy przejść po wszystkich elementach tablicy
(stąd nazwa wyszukiwanie liniowe). Czas wykonania algorytmu wyszukiwania liniowego zależy od wielkości tablicy oraz położenia elementu.
Wersja 1 - Bez wartownika
procedure wys zuki wanie Lini owe ( var tab : TTablica ; element : integer ) ;
var
i : byte ;
begin
for i :=1 to 5 do
begin
i f ( tab [ i ]= element ) then
begin
writeln ( ’ Z n a l e z i o n o ␣ element ␣na␣ p o z y c j i : ␣ ’ , i ) ;
e x i t ; { wyjscie z procedury }
end ;
end ;
writeln ( ’ Nie ␣ z n a l e z i o n o . ’ ) ;
end ;
Wersja 2 - Z wartownikiem
Wartownik jest to specjalny element w tablicy, który najczęściej informuje, że
doszliśmy do jej końca. W przypadku wyszukiwania liniowego ma on wartość
szukanego elementu i jest dodawany na koniec tablicy. Dzięki temu łatwo
jest rozstrzygnąć, czy znaleziono szukaną wartość - jeżeli znaleziony indeks
będzie mniejszy niż ostatni indeks w tablicy, wtedy znaleziono element. W
przeciwnym wypadku algorytm znalazł wartownika, który został dodany na
koniec.
procedure wyszukiwanieLinioweZWartownikiem ( var tab :
TTablica ; element : integer ) ;
var
i
: byte ;
numerPozycji : byte ;
begin
tab [ 6 ] : = element ;
numerPozycji : = 1 ;
for i :=1 to 6 do
begin
i f ( tab [ i ]= element ) then
begin
numerPozycji := i ;
break ;
end ;
end ;
i f ( numerPozycji =6) then
writeln ( ’ Nie z n a l e z i o n o . ’ )
else
writeln ( ’ Z n a l e z i o n o na p o z y c j i : ’ , numerPozycji ) ;
end ;
2.3
2.3.1
Tablice posortowane
Sortowanie
Kody źródłowe algorytmów sortowania zostały zaczerpnięte z wykładów mgr
inż. Arkadiusza Chrobota z Podstaw programowania
Sortowanie przez wybór (ang. selection sort)
Algorytm sortowania przez wybór opiera się na znajdowaniu elementu minimalnego, można go zapisać następującymi krokami:
1. Do zmiennej i przypisz minimalny indeks tablicy.
2. Znajdź minimalny element w tablicy poczynając od elementu o indeksie
i (za każdym krokiem algorytmu będzie przeszukiwana mniejsza część
tablicy, znajdująca się „na prawo”).
3. Zamień miejscami element o indeksie i ze znalezionym elementem minimalnym.
4. Zwiększ zmienną i o 1 oraz sprawdź, czy i>= maksymalny indeks w
tablicy. Jeżeli nie, przejdź do kroku 2.
procedure s e l e c t i o n _ s o r t ( var t : t a b l i c a ) ;
var
i , j , k , tmp : byte ;
begin
for i := low ( t ) to hig h ( t )−1 do
begin
k:= i ;
for j := i +1 to hi gh ( t ) do
i f t [ k ] > t [ j ] then k:= j ;
i f i <>k then
begin
tmp:= t [ k ] ;
t [ k ]:= t [ i ] ;
t [ i ] : = tmp ;
end ;
end ;
end ;
Sortowanie przez wstawianie (ang. insertion sort)
Algorytm jest bardzo podobny do sortowania przez wybór, najłatwiej porównać go do sortowania kart do gry. Przeglądamy wszystkie elementy tablicy. Rozpatrywany element przesuwamy „na lewo”, aż do momentu gdy
znajdziemy elementy mniejsze od niego lub dojdziemy do początku tablicy.
procedure i n s e r t i o n _ s o r t ( var t : t a b l i c a ) ;
var
i , j , key : byte ;
begin
for j := low ( t )+1 to high ( t ) do
begin
key := t [ j ] ;
i := j −1;
while ( i >(low ( t ) −1) ) and ( t [ i ]> key ) do
begin
t [ i +1]:= t [ i ] ;
i := i −1;
end ;
t [ i +1]:= key ;
end ;
end ;
Sortowanie bąbelkowe (ang. bubble sort)
Jeden z najprostszych algorytmów sortowania, polega na wielokrotnym przeglądaniu tablicy i sortowaniu par elementów. Pierwszy krok polega na przeglądaniu tablicy od końca aż do napotkania drugiego elementu. Przy każdym
przejściu sprawdzamy, czy pary sąsiadujących elementów są uporządkowane
(jeśli nie, sortujemy je - zamieniamy miejscami). W kolejnym kroku również
przeglądamy tablicę od końca i sprawdzamy pary elementów, jednak zatrzymujemy się gdy napotkamy trzeci element. Kolejne kroki są analogiczne, za
każdym razem kończymy sprawdzanie o jeden element wcześniej. Algorytm
kończy się, gdy dojdziemy do ostatniego elementu.
procedure bubble_sort ( var t : t a b l i c a ) ;
var
i , j , tmp : byte ;
begin
for i := low ( t ) to hig h ( t )−1 do
for j := high ( t ) downto i +1 do
i f t [ j −1] > t [ j ] then
begin
tmp:= t [ j ] ;
t [ j ]:= t [ j −1];
t [ j −1]:=tmp ;
end ;
end ;
Sortowanie mieszane (ang. shake sort)
Algorytm działający bardzo podobnie do sortowania bąbelkowego, z tą różnicą, że zapamiętuje indeks elementu który został ostatnio zmodyfikowany.
Również tablica jest przegląda raz od tyłu, a raz od przodu, co powoduje że
na brzegach znajdują się posortowane elementy, natomiast w środku elementy
jeszcze nieuporządkowane.
procedure sh ake _s ort ( var t : t a b l i c a ) ;
var
j , k , u , d , key : byte ;
begin
d:= low ( t ) +1;
u:= hi gh ( t ) ;
repeat
for j :=u downto d do
i f t [ j −1] > t [ j ] then
begin
key := t [ j − 1 ] ;
t [ j −1]:= t [ j ] ;
t [ j ] : = key ;
k:= j ;
end ;
d:=k+1;
for j :=d to u do
i f t [ j −1]> t [ j ] then
begin
key := t [ j − 1 ] ;
t [ j −1]:= t [ j ] ;
t [ j ] : = key ;
k:= j ;
end ;
u:=k −1;
u n t i l d>u ;
end ;
2.3.2
Wartości minimalne i maksymalne
W tablicy posortowanej jest bardzo proste - elementem minimalnym jest element o najmniejszym indeksie (pierwszy), natomiast maksymalny jest elementem o największym indeksie (ostatni).
2.3.3
Wyszukiwanie binarne (ang. binary search)
Wyszukiwanie binarne jest bardzo szybkim i prostym algorytmem wyszukiwania elementów w posortowanej tablicy. Algorytm polega na znalezieniu
środka tablicy i sprawdzeniu czy nie jest to szukany element. Jeżeli nie,
sprawdzamy czy szukany element jest mniejszy od środkowego elementu jeśli tak, powtarzamy algorytm dla lewej połówki tablicy, jeśli większy, dla
prawej. Algorytm wykonuje się aż do napotkania sytuacji najprostszej - tablicy składającej się z jednego elementu.
procedure wyszukiwanieBinarne ( var tab : TTablica ;
element : integer ) ;
var
mid , p , k : byte ;
begin
p:= low ( tab ) ;
k:= high ( tab ) ;
mid :=( p+k ) div 2 ;
while ( p<=k ) do
begin
mid :=( p+k ) div 2 ;
i f ( tab [ mid]= element ) then
begin
writeln ( ’ Z n a l e z i o n o element na p o z y c j i : ’ ,
mid ) ;
e x i t ; { wyjscie z procedury }
end ;
i f ( tab [ mid]< element ) then
begin
p:=mid+1;
end
else
begin
k:=mid −1;
end ;
end ;
writeln ( ’ Nie z n a l e z i o n o ’ ) ;
end ;
2.4
Tablice wielowymiarowe
Deklaracja tablicy wielowymiarowej:
t a b l i c a : array [ 1 . . 5 , 1 . . 2 0 ] of integer ;
t a b l i c a 2 : array [ − 1 0 0 . . 1 0 5 , − 1 0 . . 2 3 , 1 0 0 . . 1 2 5 ]
of byte ;
t a b l i c a 3 : array [ 0 . . 5 0 ] of array [ 0 . . 2 4 ] of
char ;
3
Wcięcia
Pisząc programy pamiętajcie o wcięciach. Ułatwiają one czytanie programu
oraz utrudniają popełnianie błędu polegającego na niezamykaniu bloków
(brakująca instrukcja end;).