Prezentace se nahrává, počkejte prosím

Prezentace se nahrává, počkejte prosím

1 / 6X36DSA 2005The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log.

Podobné prezentace


Prezentace na téma: "1 / 6X36DSA 2005The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log."— Transkript prezentace:

1 1 / 6X36DSA 2005The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … DSA Různé algoritmy mají různou složitost

2 2 / 6X36DSA 2005The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … DSA The complexity of different algorithms varies

3 3 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … QuickSort Random array QuickSort progress Example Pivot = 1 st in the section X36DSA 2005

4 4 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … QuickSort X36DSA 2005

5 5 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Trees node, vertex edge leaf internal node strom uzel, vrchol hrana vnitřní uzel list tree X36DSA 2005

6 6 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Trees examples příklady X36DSA 2005

7 7 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Trees R R a b c d e f g h i j kl m b a c d ef n njim klh g predecessor, parent rooted tree root successor, child ji rooted treekořenový strom kořen předchůdce, rodič následník, potomek X36DSA 2005

8 8 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Trees tree depth R b a c d ef njim klh g node depth hloubka uzluhloubka stromu X36DSA 2005

9 9 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Trees binary (rooted!!) tree 0, 1 or 2 successors x subtree of x …………... left ………… right binární (kořenový!!) strom 0, 1 nebo 2 následníci podstrom uzlu x …………... levý …..……. pravý X36DSA 2005

10 10 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Trees regular binary tree 0 or 2 successors balanced tree All leaf depths are (more or less) equal. pravidelný binární strom 0 nebo 2 následníci vyvážený strom Hloubky všech listů jsou (víceméně) stejné. X36DSA 2005

11 11 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Trees depthnodes k2k2k balanced tree: depth ~ log 2 (nodes) 2 k (2 (tree depth)+1 – 1) ~ nodes tree depth ~ log 2 (nodes+1) - 1 X36DSA 2005

12 12 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Trees depthnodes k k 2 2 2k-1 2(depth)-1 ~ nodes depth ~ (nodes+1)/2 extremely unbalanced regular tree: depth ~ (nodes+1)/2 X36DSA 2005

13 13 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Trees regular tree depth =  (nodes) hloubka pravidelného stromu =  (počet uzlů) usually obvykle regular tree depth =  (log 2 (nodes)) hloubka pravidelného stromu =  (log 2 (počet uzlů)) Complexity summary X36DSA 2005

14 14 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Simple recursion example void ruler(int val) { if (val < 1) return; ruler(val-1); print(val); ruler(val-1); } Call: ruler(4); a ruler pravítko ruler marks mark heights rysky pravítka délky rysek ruler code kód pravítka X36DSA 2005

15 15 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Simple recursion example ruler(1); print(2); ruler(1); ruler(0); print(1); ruler(0); ruler(2); print(3); ruler(2); ruler(3); print(4); ruler(3); return; if (val < 1) return; ruler(val-1); print(val); ruler(val-1); Start X36DSA 2005

16 16 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Simple recursion example if (val < 1) return; ruler(val-1); print(val); ruler(val-1); X36DSA 2005

17 17 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Tree implementation  C key leftright typedef struct node { int key; struct node *left; struct node *right; } NODE; X36DSA 2005

18 18 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … public class Node { public Node left; public Node right; public int key; public Node(int k) { key = k; left = null; right = null; } public class Tree { public Node root; public Tree() { root = null; } Tree implementation  Java X36DSA 2005

19 19 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Building a random binary tree  C NODE *randTree(int depth) { NODE *pnode; if ((depth 7)) return (NULL); //stop recursion pnode = (NODE *) malloc(sizeof(NODE)); // create node if (pnode == NULL) { printf("%s", "No memory."); return NULL; } pnode->left = randTree(depth-1); // make left subtree pnode->key = random(100); // some value pnode->right = randTree(depth-1); // make right subtree return pnode; // all done } NODE *root; root = randTree(4); X36DSA 2005

20 20 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Building a random binary tree  Java public Node randTree(int depth) { Node node; if ((depth 7) return null; // create node with a key value node = new Node((int)(Math.random()*100)); if (node == null) { System.out.println("No memory."); return null; } node.left = randTree(depth-1); // make left subtree node.right = randTree(depth-1); // make right subtree return node; // all done } Node root; root = randTree(4); X36DSA 2005

21 21 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Random binary tree tree tree representation X36DSA 2005

22 22 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Inorder traversing void listInorder( NODE *ptr) { if (ptr == NULL) return; listInorder(ptr->left); printf("%d ", ptr->key); listInorder(ptr->right); } INORDER tree traversing procedure Tree Output X36DSA 2005

23 23 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Inorder traversing recursive flow A BC DEFG HIJKLMNO HDIBJE L KAFMNCGO listInorder(ptr->left); printf("%d ", ptr->key); listInorder(ptr->right); X36DSA 2005

24 24 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Preorder traversing void listPreorder( NODE *ptr) { if (ptr == NULL) return; printf("%d ", ptr->key); listPreorder(ptr->left); listPreorder(ptr->right); } PREORDER tree traversing procedure Tree Output X36DSA 2005

25 25 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Preorder traversing recursive flow A BC DEFG HIJKLMNO ABDHIECJKFLGMNO printf("%d ", ptr->key); listPreorder(ptr->left); listPreorder(ptr->right); X36DSA 2005

26 POSTORDER tree traversing procedure Tree Output 26 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Postorder traversing void listPostorder( NODE *ptr) { if (ptr == NULL) return; listPostorder(ptr->left); listPostorder(ptr->right); printf("%d ", ptr->key); } X36DSA 2005

27 listPostorder(ptr->left); listPostorder(ptr->right); printf("%d ", ptr->key); 27 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Postorder traversing recursive flow A BC DEFG HIJKLMNO HIDJKEMBLFNGOCA X36DSA 2005

28 28 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Tree size recursively int count(NODE *ptr) { if (ptr == NULL) return (0); return (count(ptr->left) + count(ptr->right)+1); } n nodes m nodes m+n+1 nodes X36DSA 2005

29 29 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Tree depth recursively int depth(NODE *ptr) { if (ptr == NULL) return (-1); return ( max(depth(ptr->left), depth(ptr->right) )+1 ); } m n n+1 = max(m,n)+1 X36DSA 2005

30 30 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Stack implements recursion node A visited 0x node A visited 1x A node A visited 2x ruler with no recursion X36DSA 2005

31 31 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Stack implements recursion stack 3 top bottom A0/1/2 (value)(visits) A X36DSA 2005

32 32 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Stack implements recursion When using the stack: If possible, always process the data on the stack only. Při používání zásobníku: Je-li to možné, zpracovávej jen data ze zásobníku. Technical advice Technická rada X36DSA 2005

33 33 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Stack implements recursion stack valuevisits 40 Start: approaching the root push(4,0) Each slide in the following sequence depicts the situation BEFORE the node is processed. Each slide in the following sequence depicts the situation BEFORE the node is processed. Každý záběr v následující sekvenci předvádí situaci PŘED zpracováním uzlu. Každý záběr v následující sekvenci předvádí situaci PŘED zpracováním uzlu. X36DSA 2005

34 34 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Stack implements recursion stack valuevisits leaving 4 & approaching 3 push(3,0) X36DSA 2005

35 35 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Stack implements recursion stack valuevisits leaving 3 & approaching 2 push(2,0) X36DSA 2005

36 36 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Stack implements recursion stack valuevisits leaving 2 & approaching 1 push(1,0) 1 0 X36DSA 2005

37 37 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Stack implements recursion stack valuevisits leaving 1 & approaching 0 push(0,0) X36DSA 2005

38 38 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Stack implements recursion stack valuevisits leaving 0 & approaching pop() X36DSA 2005

39 39 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Stack implements recursion stack valuevisits leaving 1 & approaching push(0,0) 00 1 X36DSA 2005

40 40 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Stack implements recursion stack valuevisits leaving 0 & approaching pop() 1 X36DSA 2005

41 41 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Stack implements recursion stack valuevisits leaving 1 & approaching 2 12 pop() 1 X36DSA 2005

42 42 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Stack implements recursion stack valuevisits leaving 2 & approaching 1 10 push(1,0) et cetera… X36DSA 2005

43 43 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Stack implements recursion stack valuevisits leaving 2 & coming to 3 pop() 1 … after a while… … po chvíli … X36DSA 2005

44 44 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Stack implements recursion stack valuevisits leaving 2 & approaching 3 1 et cetera… 3 20 push(2,0) X36DSA 2005

45 45 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Stack implements recursion stack valuevisits 42 Finis (empty == true) pop() 4 X36DSA 2005

46 46 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Stack implements recursion // Ruler recursion simulation with no recursive call // Pseudocode description while (stack.empty == false) { if (stack.top.value == 0) stack.pop(); if (stack.top.visit == 0) { stack.top.visit++; stack.push(stack.top.value-1,0); } if (stack.top.visit == 1) { print(stack.top.value); stack.top.visit++; stack.push(stack.top.value-1,0); } if (stack.top.visit==2) stack.pop(); } X36DSA 2005

47 47 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Stack implements recursion int stVal[10]; int stVis[10]; int SP; void ruler2() { while (SP >= 0) { if (stVal[SP] == 0) SP--; // pop empty node if (stVis[SP] == 0) { // first visit stVis[SP]++; SP++; stVal[SP] = stVal[SP-1]-1; // go left stVis[SP] = 0; } if (stVis[SP] == 1) { // second visit printf("%d%s", stVal[SP], " ");// process node stVis[SP]++; SP++; stVal[SP] = stVal[SP-1]-1; // go right stVis[SP] = 0; } if (stVis[SP] == 2) SP --; // pop finished node } X36DSA 2005

48 48 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … X36DSA 2005

49 49 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … X36DSA 2005

50 50 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … X36DSA 2005

51 51 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Recursively defined terrain X36DSA 2005

52 52 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Easy backtrack x y y x Eight queens problem X36DSA 2005

53 53 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Easy backtrack X36DSA 2005

54 54 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Easy backtrack X36DSA 2005

55 55 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Easy backtrack Stop! X36DSA 2005

56 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Easy backtrack SpeedupNSolutions Brute force (n n )Backtrack Queen position tests Tab 6.1 Eight queens solution speed comparison X36DSA 2005

57 57 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Easy backtrack int posOK( int x, int y) { int i; for (i = 0; i < x; i++) if ((xPosArr[i] == y) || // same row (abs(x-i) == abs(xPosArr[i]-y) )) // same diagonal return false; return true; } void tryPutColumn(int y) { int x; if (y >= N ) print_yPosArr(); // solution found ? else for (x = 0; x < N; x++) // check each column if (posOK(y, x) == true) { // if free, xPosArr[y] = x; // put a queen there tryPutColumn(y + 1); // recursive call } } Call: tryPutColumn(0); X36DSA 2005

58 58 / 6 The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Salvador Dalí The Face of War ( ) X36DSA 2005

59 59 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Salvador Dalí The Face of War ( ) -- right eye detail X36DSA 2005

60 60 / 6 The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Salvador Dalí The Face of War ( ) X36DSA 2005

61 61 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … DSA Různé algoritmy mají různou složitost X36DSA 2005

62 62 / 6The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … DSA The complexity of different algorithms varies X36DSA 2005


Stáhnout ppt "1 / 6X36DSA 2005The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log."

Podobné prezentace


Reklamy Google