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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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

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

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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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

/ 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 / 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 / 6 The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Salvador Dalí The Face of War ( ) X36DSA 2005

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 / 6 The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Salvador Dalí The Face of War ( ) X36DSA 2005

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 / 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