Pobieranie prezentacji. Proszę czekać

Pobieranie prezentacji. Proszę czekać

Algorytmy i struktury danych Koszt zamortyzowany Drzewa dwumianowe Kopce dwumianowe Kopce Fibonacciego.

Podobne prezentacje


Prezentacja na temat: "Algorytmy i struktury danych Koszt zamortyzowany Drzewa dwumianowe Kopce dwumianowe Kopce Fibonacciego."— Zapis prezentacji:

1 Algorytmy i struktury danych Koszt zamortyzowany Drzewa dwumianowe Kopce dwumianowe Kopce Fibonacciego

2 Koszt zamortyzowany Średni koszt poj. operacji w kontekście całej sekwencji Koszt średni – wymaga rozkładu prawdopodobienstwa danych we. i probabilistycznej analizy czasu wykonania alg. Koszt zamortyzowany – rozważa sie np. wymagane sekwencje operacji i na tej postawie okresla koszt jednostkowej operacji Przyklad: ciąg operacji na stosie.

3 Kopce – koszt operacji Kopce binarne* / dwumianowe* / fibonacciego** wstawianie elementów (log n) / O(log n) / (1) znajdowanie minimalnego węzła (1) / O(log n) / (1) usuwanie minimalnego węzła (log n) / (log n) / O(log n) czas łączenia – (n) / O(log n) / (1) zmniejszanie klucza elementu (log n) / (log n) / (1) usuwanie węzła (log n) / (log n) / O(log n) * Koszt pesymistyczny **Koszt zamortyzowany

4 Drzewa dwumianowe B0B0 B k-1 BkBk B0B0 B1B1 B2B2 B3B3 B4B4 Definicja:

5 Drzewa dwumianowe – właściwości B k BkBk.. B k-1 B k-2 B2B2 B1B1 B0B0 Liczba węzłów = 2 k Wysokość = k Na głębokości i znajduje się węzłów Stopień korzenia jest k i jest największy w całym drzewie k i

6 Kopiec dwumianowy Każde drzewo w H jest uporządkowane kopcowo (klucz w węźle jest nie mniejszy niż klucz ojca) Dla każdego d 0 istnieje w H co najwyżej jedno drzewo którego korzeń ma stopień = d Reprezentacja poszczególnych drzew w notacji na lewo syn na prawo brat H

7 Kopce dwumianowe - deklaracja class BNNODE : key = None degree = 0 child = None sibling = None parent = None data = None root = None

8 Kopce dwumianowe - Min def MinBNHeap(heap): min = heap while heap != None: if heap.key < min.key: min = heap heap = heap.sibling return min

9 Kopce dwumianowe - TreeLink ByBy BzBz z z BzBz ByBy z y + y z = =

10 Kopce dwumianowe - TreeLink def LinkBNTree(newSon, newParent) newSon.parent = newParent newSon.sibling = newParent.child newParent.child = newSon newParent.degree = newParent.degree +1

11 Kopce dwumianowe - Union Scal listy drzew dla łączonych kopców (zachowując uporzadkowanie wg. stopni Tak długo jak na liscie są drzewa o jednakowych stopniach scalaj drzewa

12 Kopce dwumianowe - Union

13 Kopce dwumianowe - Union

14 Union - przypadki BkBk abcd BlBl ab 2 l > k XNextX l = k = m BmBm 1 3 l = k < m, a<=b 4 l = k b przejdz w prawo tj. X = NextX, NextX = NextX.sibling przejdz w prawo tj. X = NextX, NextX = NextX.sibling TreeLink(NextX, X) TreeLink(X, NextX)

15 Union - implementacja def MergeBNHeap(h1, h2) ret = None cur = None while h1!=None and h2!=None: if h1.degree<=h2.degree: next,h1 = h1,h1.sibling else: next,h2 = h2,h2.sibling if ret == None: ret, cur = next, next else: cur.sibling,cur = next,next if h1==None: h1,h2=h2,h1 if ret==None: return h1 else cur.sibling = h1 return ret def UnionBNHeap(y, z): ret = MergeBNHeap(y, z) if ret == None: return None prevX = None X = ret nextX = ret.sibling while nextX != None: # przypadki 1..4 return ret

16 Union – implementacja cd. if X.degree != nextX.degree or\ #przypadek 1 (nextX.sibling!=None and\ nextX.degree == nextX.sibling.degree): #przypadek 2 prevX,X,nextX = X,nextX,nextX.sibling elif X.key <= nextX.key: #przypadek 3 X.sibling = nextX.sibling nextX.sibling = None LinkBNTree(nextX, X) nextX=X.sibling else: # przypadek 4 if prevX==None: ret = nextX else: prevX.sibling = nextX LinkBNTree(X, nextX) x.sibling = None X,nextX = nextX,nextX.sibling

17 Kopce dwumianowe - Insert def InsertBNHeap(heap, key, data) node = PBNNODE() #node.sibling = node.parent = node.child = None #node.degree = 0 node.key = key node.data = data return UnionBNHeap(heap, node)

18 Kopce - ExtractMin

19 ExtractMin - Implementacja Dla minimalnego węzła MIN usun drzewo zaczynające się od MIN z kopca H Utwórz nowy kopiec H z synów MIN Wykonaj Union na H i H def ExtractMinBNHeap(heap): ret = MinBNHeap(heap) usun_ret_z_listy_korzeni_w_heap h1 = odwroc_kolejnosc_synow_ret_i_zwroc_ich_liste heap = UnionBNHeap(heap, h1) ret.sibling = None ret.child = None return heap,ret

20 Kopce – Decrease Key

21 Decrease Key - Implementacja Zmien klucz dla węzła w while w jest mniejszy od ojca: zamień oba węzły def DecKeyBNHeap(node, newKey): if newKey > node.key: ERROR node.key = newKey while node.parent!=None and node.key

22 Remove Node - Implementacja def RemoveBNHeap(heap, node): tmp = node.key DecKeyBNHeap(node, MINKEYVALUE) heap,node = ExtractMinBNHeap(heap) node.key = tmp return heap,node MINKEYVALUE musi byc MNIEJSZY od wszystkich kluczy lub można poszukać minimalnego klucza

23 Kopce Fibbonacciego Zbliżone do kopców dwumianowych, mają jednak luźniejszą strukturę. zamortyzowany czas wstawiania – O(1) zamortyzowany czas min– O(1) zamortyzowany czas łączenia – O(1) zamortyzowany czas zmniejszenia klucza – O(1) zamortyzowany czas usuwania i ExtractMin O(log n) Koszt zamortyzowany – w odróżnieniu od analizy średniego przypadku nie wymaga rozważań probabilistycznych.

24 Kopiec Fibonacciego Każde drzewo w H jest jest uporządkowane kopcowo (klucz w węźle jest nie mniejszy niż klucz ojca) a początek drzewa wskazuje na minimalny węzeł Drzewa nie są uporządkowane między sobą Reprezentacja poszczególnych drzew: listy cykliczne dla poziomów drzewa i wskaźnik do jednego z synów; usuwanie wierzchołka i sklejanie list = O(1) Zaznaczenie wybranych wierzchołków (węzły które utraciły syna od chwili kiedy ostatnio zostały synem) Maksymalny stopien D(n) = log f n ; f=(1+ 5) /2 HF

25 Sklejanie list cyklicznych def JoincycleLists(L1, L2): if L1==None: return L2 if L2==None: return L1 if L1.next==L1 : L1.prev = L2.prev #L1 miala 1 el. else: L1.next.prev = L2.prev if L2.prev==L2 : L2.next = L1.next #L2 miala 1 el. else: L2.prev.next = L1.next L1.next,L2.prev = L2, L1 data next prev data next prev data next prev data next prev data next prev data next prev L1 L2 data next prev L2'

26 52 Kopce Fibonacciego - deklaracja class HFNODE: key=None degree=0 child=None left=None right=None parent=None marked=False data=None HF=None size= HF

27 Kopce Fibonicciego - Insert Dodawany wezeł staje się oddzielnym drzewem i nie jest zaznaczony HF HF

28 Kopce Fibonicciego - Insert def InsertFibHeap(heap, key, size, data): node = PHFNODE() #node.parent = node.child = NULL #node.marked = false node.left = node node.right = node node.key = key node.data = data heap = JoinCycleLists( heap, node ) size = size+1 if heap.key

29 Kopce Fibonicciego - Union def UnionFibHeap (heap1, heap2, size1, size2): heap = JoinCycleLists( heap1, heap1) size = size1 + size2 if heap1.key < heap2.key: return heap1,size else return heap2,size

30 Kopce Fibonicciego - ExtractMin przenieś synów Min do H dopóki korzeń każdego drzewa w FH nie ma innego stopnia znajdź dwa korzenie x, y o tym samym stopniu, takie że x->key key usuń y z listy korzeni H dołącz y do x zwieksz stopien x FibHeapLink: Consolidate:

31 Kopce Fibonicciego - ExtractMin HF w,x x w x w x w 21

32 Kopce Fibonicciego - ExtractMin HF w,x w,x w,x 52

33 Kopce Fibonicciego - ExtractMin def ExtractMinFibHeap(heap, size): min = heap if min != None: heap = RemoveFromCycleList(heap, min) for c in all_children_of_min c.parent = None heap = JoinCycleList(heap, min.child) size = size-1 if heap != heap.left: heap = Consolidate(heap) return heap, size, min

34 Kopce Fibonicciego - Consolidate def Consolidate(heap, size): A = Array(D(size),None) for x in all_nodes_in_heap: d = x.degree; while A[d] != None: y = A[d] if x.key > y.key: x,y = y,x heap = FibHeapLink(heap, x, y) A[d] = None d = d+1 A[d] = x heap = None# merge nodes from A into heap for i in range(0, D(size)): if A[i] != NULL ): A[i].left = A[i] A[i].right = A[i] heap = JoinCycleList(heap, A[i]) if heap.key > A[i].key: heap = A[i]

35 Kopce Fibonicciego - Consolidate def FibHeapLink(heap, x, y): heap = RemoveNodeFromCycleList( heap, y ) x.child = JoinCycleList( x.child, y) x.degree = x.degree+1 y.mark = False return heap

36 Kopiec Fibonacciego Jeżeli nie wykonujemy operacji: ExtractMin Delete to drzewa w kopcu pozostają nieuporządkowanymi drzewami wielomianowymi Przy wykonywaniu ExtractMin i Delete maksymalny stopień węzła wynosi D(n) = D(n) = log f n ; f=(1+ 5) /2 i taki jest koszt zamortyzowany obu operacji

37 Kopce Fibonicciego - DecKey HF HF HF HF HF

38 Kopce Fibonicciego - ExtractMin parent = x.parent if parent != None and x.key < parent.key : przenieś_x_do_korzenia_kopca x.marked = False if parent.marked: powtorz_cala_procedure_rekurencyjnie dla parent else: parent.marked = True

39 Kopce Fibonicciego - DecKey def DecKeyFibHeap(heap, x, newK): if x.key key = newK p = x.parent if p != None and x.key < p.key: heap = CutFibHeap(heap, x, p) heap = CascadingCutFibHeap (heap,p) if x.key < heap.key: heap = x;

40 Kopce Fibonicciego – Cut def CutFibHeap(heap, x, p): RemoveFromCycleList(p.son, x) p.degree = p.degree –1 x.left, x.right = x, x heap = JoinCycleList(heap, x) x.parent = None x.mark = False def CascadingCutFibHeap(heap, p): z = p.parent if z != None: if not z.marked: z.marked = True else: CutFibHeap(heap, p, z ) CascadingCutFibHeap(heap, z)

41 Kopce Fibonicciego – DelKey Zmniejsz klucz do najmniejszej możliwej wartosci Wykonaj ExtractMin def DelKeyFibHeap(heap, x, size): heap = DecKeyFibHeap(heap, x, MINKEYVALUE) heap,size,x = ExtractMinFibHeap(heap, size) return heap,size MINKEYVALUE musi byc MNIEJSZY od wszystkich kluczy lub można poszukać minimalnego klucza


Pobierz ppt "Algorytmy i struktury danych Koszt zamortyzowany Drzewa dwumianowe Kopce dwumianowe Kopce Fibonacciego."

Podobne prezentacje


Reklamy Google