ALGORYTMY I STRUKTURY DANYCH
WYKŁAD 06 Podstawowe struktury danych.
Grażyna Mirkowska PJWSTK, 2003/2004
Plan wykładu
Stosy
– Własności – implementacja – Przykład: turniej
Kolejki
– Własności – implementacja
– Przykład : sito Eratostenesa
Listy
Przykład zastosowań
– Obliczanie wartości wyrażeń
MOTTO Struktury danych modyfikują świat, w którym realizowany jest algorytm, usprawniają działanie,
ułatwiają zrozumienie algorytmu.
Podstawowe struktury danych
Algorytmy + struktury Danych = Programy
e1, e2, e3, ..., en
początek koniec
Operacje na listach Operacje na listach
Pobranie elementu z listy.
Wstawianie elementu na listę.
Usuwanie elementu z listy.
top push pop
rear inject eject
Operacje na lewym
końcu listy
Operacje na prawym końcu listy
Stos i jego własności
< S E, push, pop, top, empty>
push(s, e) = (e, e1,e2,..., en) pop(s) = (e2,..., en), o ile n>1 top(s) = e1
empty(s) wttw n = 0
s = (e1,e2,..., en)
top(push(s,e)) = e op(push(s,e)) = s
empty(s) => push(pop(s),top(s)) = s
while not empty(s) do s:=pop(s)od ma własność stopu
element1 next element2
next element3
next
Twierdzenie
Dowolna struktura danych, w której prawdziwe są własności (*) jest izomorficzna z pewną strukturą standardową.
ogniwo
Abstrakcyjna struktura kolejek
Początek kolejki
Koniec kolejki
Standardowa struktura kolejek
first(e1,...en) = e1 , gdy n>0 i nieokr. w p.p.
in((e1,...,en),e) = (e1,e2,...,en,e)
out(e1,...en) = (e2,...,en) , gdy n>0 i nieokr. w p.p.
empty(e) wttw e jest ciągiem pustym
pokaz
Specyfikacja kolejek FIFO
Q = E Q , in, out, first, empty, = Sygnatura
in : E Q Q out : Q Q
first Q E empty : Q Bo
empty(in(e,q))
empty(q) out(in(e,q)) = q empty(q) first(in(e,q)) = e
empty(q) first(in(e,q)) = first(q) empty(q) in(e,out(q)) = out(in(e,q))
while empty(q) do q := out(q) od ten program nie zapętla się
q =q’ wttw P (empty(q) empty(q’) b)
P = { b:= true;
while
(empty(q) empty(q’) b) do b := (first(q)=first(q’));
q := out(q);
q’:= out(q’) ; od
}
Twierdzenie
Każda struktura danych ze
zbiorem elementów E, w której prawdziwe są wszystkie
wymienione aksjomaty kolejek jest izomorficzna z modelem
standardowym kolejek Q(E).
Impelementacja kolejek
e1
Początek Koniec
e2 e3 ... en
Public class kolejka( ){
ogniwo poczatek;
ogniwo koniec;
...
}
public kolejka in (int e; kolejka q){
o = New ogniwo(e);
o. next = null;
if (q = null) {q = New kolejka();
q.początek = o;}
else q.koniec.next = o;
q.koniec = o;
return q
Public class ogniwo (int e){
ogniwo next; ...
}
Listy
Kolejki i Stosy są przykładami struktur listowych.
Operacje na listach
• Dostęp do elementu listy
• Podlista
• Złożenie
• wkładanie elementu
• Usuwanie elementu
Realizacje :
- Tablicowa - dowiązaniowa
...
Lista : jednokierunkowa, cykliczna
dwukierunkowa
Przykład : ‘Turniej’
Zadanie polega na znalezieniu elementu drugiego co do wielkości. Metoda – algorytm turniej (por. wykład 03)
2 3
4 5 7 8 1 6
4 5 8 6
5 8
8 5
6 7
Struktura danych dla algorytmu ‘Turniej’
Następny element głównej listy
Lista elementów, które
przegrały z e (kandydaci do drugiego miejsca)
e’ next e” next
w next
stosp OGNIWO listy
a stospnext
Algorytm ‘Turniej’ - implementacja
for i := 1 to n div 2 do if e[i] > e[i+1] then L:= push(i,L);
L.stosp := push(i+1, L.stosp);
else
L:= push(i+1, L);
L.stosp := push(i, L.stosp);
fi;
od;
Tworzenie wyników pierwszej rundy
i+3
i+2
i L i+1
e[i] e[i+1]e[i+2]e[i+3]
...
k
l
...
Wkładam na stos element, który przegrał.
Budowa drzewa turnieju
while not empty(L.next) do x := L;
while not empty(x) do y := x.next;
if e[x.w] > e[y.w] then
x.stosp := push (x.stosp, y.w) else
y.stosp := push(y.stosp, x.w);
x.w := y.w;
x.stosp := y.stosp fi;
x.next := y.next;
x := x.next od
od;
Dołącz y do elementów, które przegrały z x
Dołącz x do elementów, które przegrały z y
Rozważmy pierwszy element następnej pary
x y
{
z := L.stos;
drugi := z.w; z :=pop(z);
while not empty(z) do
if e[drugi ] < e[top(z)] then drugi := top(z)
fi;
z := pop(z);
od }
{
for i := 2 to n do tab[i] := i od;
for i := 2 to n do
if tab[i] <>0 then
for j := i+1 to n do
if ( tab[j] mod i = 0) then tab[j] := 0;
fi;
od;
fi od }
Tablica wszystkich liczb naturalnych n
Wykreślam z tablicy wszystkie liczby podzielne przez i
tab[i] , o ile nie jest zerem, jest liczbą pierwszą
Wszystkie elementy tablicy różne od zera na pozycjach < i są liczbami pierwszymi
Sito Eratostenesa
Sito Eratostenesa
{ poczatek := new ogniwo(2);
x := początek;
for i := 3 to n do
x.next:= new ogniwo(i); x:= x.next; od;
x := początek;
while x<>null do w:= x.wartość;
poprzedni := x; y :=x.next;
while y<>null do if ( y.wartość mod w = 0) then poprzedni.next := y.next;
else poprzedni := y;
fi;
y := y.next;
od;
x:= x.next;
od }
Wartość=2 next Wartość=3
next Wartość=4
next Wartość=5
next
początek
x
y
poprzedni
y
Sito Eratostenesa
Sito Eratostenesa
Znaleźć wszystkie liczby pierwsze n.{ p:= null; wynik := null;
for i := 2 to n do p := in(i,p) od;
while not empty(p) do i := first(p);
wynik := in(i,wynik);
p := out(p);
q:= null;
while not empty(p) do
if (first(p) mod i <>0) then q := in(first(p), q)
fi;
p := out(p) od;
p := q
Kolejka wynik zawiera
wszystkie liczby pierwsze <
first(p).
Kolejka p zawiera liczby
n, które nie dzielą się przez żadną z liczb x należących do kolejki wynik
Usuwamy z kolejki p wszystkie liczby podzielne przez i Znaleźć wszystkie liczby pierwsze n.
Sito Eratostenesa
Zbiorem wyrażeń algebraicznych WA nazywać
będziemy najmniejszy zbiór napisów nad alfabetem {x,y,z,u} {+,* -} {(,)} taki, że
(1) x,y, z, u WA
(2) jeśli w1, w2 WA , to (w1+w2) oraz (w1*w2) należą do WA,
(3) Jeśli w WA, to (-w) WA.
Obliczyć wartość danego wyrażenia algebraicznego.
Uwagi -założenia : 1. Wyrażenie jest zapisane w tablicy znakowej o elementach s[1],...,s[n].
2. Wartości zmiennych są zapisane w obiekcie v, którego atrybutami
Obliczanie wartości wyrażeń
Czytamy kolejno znaki wyrażenia i kolejne argumenty operacji wpisujemy na stos argumentów, a kolejno spotkane operacje wpisujemy na stos operacji. Pojawienie się ‘)’ sygnalizuje, że można wykonać ostatnio zapamiętaną operację.
((x+(y*z))+(-u))
Stos argumentów
Stos operacji
x
+ y
* z
+ y*zx
x+(y*z)
+-
u x+(y*z)-u
+
x+(y*z)+(-u)
Opis metody
Wpisz s[i] na stos operacji
s[i] jest operacją
włóż wartość s[i] na stos argumentów
s[i] jest zmienną i := 1
tak
tak
nie
nie s[i] =‘)’
Weź operację o ze stosu Weź ze stosu odpowiednią liczbę argumentów.
Oblicz wynik operacji o na tych argumentach.
Usuń ze stosu
tak
i:=i+1
nie i<n+1
Schemat algorytmu
OP :=push(s[i],OP)
ARG:= push(val(s[i]),ARG)
i := 1
tak
tak
nie
nie
O := top(OP);
OP :=pop(OP);
a := top(ARG);
ARG := pop(ARG);
b:= top(ARG);
ARG := pop(ARG);
a:= O(a,b)
tak
a := O(a)
i:=i+1
nie
O dwuargumentowa nie tak
i < n+1
cd.
s[i] =‘)’
s[i] jest zmienną s[i] jest operacją
tak
nie
