Algorytmy i struktury danych

Prezentacja na temat: "Algorytmy i struktury danych"— Zapis prezentacji:

1 Algorytmy i struktury danych
Drzewa ukorzenione, Drzewa wyszukiwawcze Wzbogacone drzewa, Drzewa TRIE

2 Drzewo ukorzenione Drzewo - każdy węzeł może mieć conajwyżej 2 lub więcej węzłów potomnych (następników), nie ma cykli Drzewo ukorzenione = drzewo z wyróżnionym jednym węzłem – korzeniem Drzewo binarne węzeł zawiera dokładnie dwa wskaźniki do węzłów potomnych Dla wygodnego trwersowania zwykle dodaje się wskaźnik do rodzica class Node: key = None data = None parent = None left = None right = None

3 Drzewo binarne root

4 Breadth First Search def BFS(node, key): "funkcja przeglada drzewo wszerz" toTraverse = Put(None, node) while toTraverse != None : toTraverse, node = Get(toTraverse) if node == None : continue #Process(node) if node.key == key: return node toTraverse = Put(toTraverse, node.left) toTraverse = Put(toTraverse, node.right) return None Brak sprawdzania czy odwiedzony?

5 Depth First Search def DFS(node, key): "funkcja przeglada drzewo wglab" toTraverse = Push(None, node) while toTraverse != None : toTraverse, node = Pop(toTraverse) if node == None : continue #Process(node); if node.key == key: return node toTraverse = Push(toTraverse, node.left) toTraverse = Push(toTraverse, node.right) return None Jaki jest dokładnie porządek przeglądania? Czy można go zmienić?

6 Depth First Search - rekursyjnie
def DFSRec (node, key): """funkcja przeglada drzewo w głab – w.rekurencyjna""" if node == None: return None #Process(node) if node.key == key: return node ret = DFSRec (node.left, key) if ret != None : return ret else : return DFSRec (node.right, key)

7 Drzewo k-narne Drzewo k-narne węzeł zawiera co najwyżej k wskaźników do węzłów potomnych Drzewo ogólne można reprezentować przy pomocy notacji „na prawo brat, na lewo syn”

8 Przegladanie drzewa k-narnego
class NODE: data = None sons = None # = [None, None, None ....] # fragment funkcja przeszukującej k-drzewo # stary kod toTraverse = Put(toTraverse, node.left) toTraverse = Put(toTraverse, node.right) # nowy kod for son in node.sons: toTraverse = Put(toTraverse, son)

9 Drzewo ogólne

10 Breadth First Search def BFSBrotherSon (node, key):
"""funkcja przeszukuje wszerz drzewo w postaci B-S"" toTraverse = Put(None, node) while toTraverse != None: toTraverse, node = Get(toTraverse) while node != None: #Process(node) if node.key == key: return node toTraverse = Put(toTraverse, node.left) node = node.right return node

11 Depth First Search def DFSBrotherSon (node, key):
"""funkcja przeszukuje wglab drzewo w postaci B-S""" toTraverse = Push(None, node) while toTraverse != None: toTraverse, node = Pop(toTraverse) while node != None: #Process(node) if node.key == key: return node toTraverse = Push(toTraverse, node.right) node = node.left return None Porządek przeglądania? Czy można go zmienić?

12 Depth First Search - rekursyjnie
def DFSBrotherSonRec(node, key): """funkcja przeszukuje rekursyjnie wglab drzewo BS""" if node == None: return None #Process(node) if node.key == key: return node ret = DFSBrotherSonRec(node.left, key) if ret != None : return ret else: return DFSBrotherSonRec(node.right,key) Czy można zaimplementować rekurencyjnie BFSBrotherSonRec ?

13 Binarne drzewo poszukiwań
5 2 3 3 7 7 2 6 8 6 8 h=2 5 h=4 y=Left(x)  y.key<x.key y=Right(x)  y.key≥ x. key

14 Drukowanie drzewa Binarnego
# funkcja wypisuje zawartość drzewa # w porządku pre-order def BSTPreorderPrint(node): if node != None : print node.key," ",node.data BSTPreorderPrint(node.left) BSTPreorderPrint(node. right) # w porządku in-order def BSTInorderPrint(node): if node != None: BSTInorderPrint(node.left) print node.key," ",node.data BSTInorderPrint(node.right)

15 16 10 19 5 12 17 20 1 6 14 13 15 h=4 max=20 min=1 13: 1610 12 14  13

16 Szukanie w drzewie BST O(h(T))
def BSTSearchRec(node, key): """Funkcja szuka klucza w BST. Moze zwrocic None jesli nie ma klucza k Wersja rekurencyjna.""" if node == None or node.key == key: return node if key < node.key: return BSTSearch(node.left, key) else: return BSTSearch(node.right, key) O(h(T))

17 Szukanie w drzewie BST O(h(T))
def BSTSearch(node, key): """Funkcja szuka klucza w BST. Moze zwrocic None jeśli nie ma klucza k Wersja iteracyjna.""" while node != None and node.key != key: if key < node.key : node = node.left else : node = node.right return node O(h(T))

18 Min/Max w drzewie BST O(h(T)) O(h(T)) #rekurencyjna wersja
def BSTMinimumRec(node): if node.left == None: return node else: return BSTMinimum(node.left) #iteracyjna wersja def BSTMinimum(node): while node.left != None: node = node.left return node O(h(T)) O(h(T))

19 Następnik w drzewie BST
# f. zwraca None jezeli node.key jest MAX def BSTSuccesor(node): if node.right != None: return BSTMinimum(node.right) tmp = node.parent while tmp != None and node == tmp.right: node = tmp tmp = tmp.parent return tmp O(h(T))

20 Wstawianie węzła 16 10 19 5 12 17 20 1 6 14 18 13 15 Wstawiany węzeł jest zawsze liściem Postępuj tak jak przy szukaniu. Przy napotkaniu NULL wstaw nowy węzeł.

21 Wstawianie do drzewia BST
def BSTInsertNode (root, node): if root == None : node.parent = None node.left = None node.right = None return node tmp = root # i.e. root != None while tmp!= None: parent = tmp if node.key < tmp.key: tmp = tmp.left else: tmp = tmp.right node.parent = parent if node.key < parent.key: parent.left = node else: parent.right = node return root O(h(T))

22 Usuwanie węzła - brak synów
5 12 1 6 14 13 17 20 16 10 19 15 5 12 1 6 14 13 17 20 16 10 19 Usuwany węzeł jest liściem – zastępujemy go przez None

23 Usuwanie węzła - jeden syn
5 12 1 6 14 13 17 20 16 10 19 15 5 1 6 14 13 17 20 16 10 19 15 Usuwany węzeł ma dokladnie jednego syna – usuwamy go „kompresując gałąź” w drzewie

24 Usuwanie węzła – dwóch synów
x 16 17 10 19 10 19 12 5 17 20 12 5 20 18 1 6 18 11 1 6 11 Usuwany węzeł ma dwóch synów – usuwamy inny węzeł, który potrafimy (następnik(x) lub poprzednik(x) ) przepisujemy wartość z usuniętego węzła x

25 Usuwanie z drzewa BST O(h(T))
def BSTDeleteNode(root, node): ret = root if node.left==None or node.right==None: todel = node else: todel = BSTSuccesor(node) if todel.left!=None: son = todel.left else: son = todel.right if son!=None: son.parent = todel.parent if todel.parent == None: ret=son elif todel == todel.parent.left: todel.parent.left = son # todel is lson else: todel.parent.right = son # todel is rson if todel != node: node.key = todel.key node.data = todel.data return ret O(h(T))

26 Złożoność operacji BST
Wszystkie kluczowe operacja na drzewach mają złożoność – odpowiadającą wysokości drzewa. Istotne jest utrzymanie jak namniejszej wysokości drzewa. W dowolnym węźle - poddrzewa: lewe i prawe - powinny mieć zbliżony rozmiar (drzewa zrównoważone) O(h(T))

27 Wzbogacanie struktury
Wybór struktury podstawowej Określenie dodatkowych informacji Sprawdzenie czasu niezbędnego do aktualizacji dodatkowych informacji Zaprojektowanie nowych operacji

28 Drzewa statystyk pozycyjnych
Dodatkowy element – rozmiar poddrzewa Zastosowania: Wyznaczanie statystyk pozycyjnych w czasie log(n) Wyznaczanie pozycji elementu w czasie log(n)

29 Drzewo statystyk pozycyjnych
21 20 26 15 12 40 7 17 41 47 2 10 7 25 4 18 4 14 21 30 47 5 4 11 2 16 2 20 1 23 1 27 2 10 16 19 23 28 38 4 2 46 1 7 7 1 12 17 1 20 29 1 39 12 1 3 1 def GetSize(node): if node==None: return 0 else: return node.size x.size = GetSize(x.left) + GetSize(x.right) +1

30 Drzewo przedziałowe W drzewie przechowywane są odcinki [a, b]
Kluczem będzie lewy koniec odcinka tj. a Dodatkowy atrybut – max dla wszystkich prawych końców (tj. Max = Max(b)) w danym poddrzewie Aktualizacja max w czasie log(n) Zastosowania: Poszukiwanie przedziału zawierającego dany punkt Poszukiwanie przedziału mającego niepuste przecięcie z danym odcinkiem

31 Drzewo przedziałowe def Interval_search(root, a, b ): x = root while (x!=None && ([a,b]  [x.a, x.b] == )): if (x.left && x.left.max >= a): x = x.left else: x = x.right return x

32 Trie – od reTRIEval A B I F A B F I E U Y O R N N R S T T S N R S T E
 E U Y O R N N R S T T S   N R S T E U Y O R  N S T D E E T Y R O S     D E  E T Y R O  S M M Kolejne sekwencje mogą być reprezentowane przez: wierzchołki krawędzie

33 Trie – KOMPRESJA WEZLOW
SAMO SAMO S A L O C LOT CH A O L C H M T O H Ó O ODY ÓD M O T D O Ó D L O C Y D D O L C H Y T O H Ó O T O Ó D D Kompresja utrudnia modyfikację drzewa Y D D Y

34 Drzewo heterogeniczne
TRIE A C NIEC HNĄĆ BST LIA RKA HAWKA HÓRZ MA