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.

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 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 11 12 9 9 8 8 7 7 5 5 3 3 6 6 1 1 10 4 4 11 2 2 7 7 2 2 5 5 3 3 6 6 1 1 4 4 2 2 4 4 1 1 5 5 3 3 6 6 4 4 5 5 3 3 6 6 2 2 4 4 2 2 3 3 2 2 3 3 9 9 10 8 8 12 11 12 5 5 6 6 8 8 9 9 9 9 10 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 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 11 12 9 9 8 8 10 11 7 7 5 5 3 3 6 6 1 1 4 4 2 2 7 7 2 2 5 5 3 3 6 6 1 1 4 4 1 1 2 2 4 4 5 5 3 3 6 6 4 4 3 3 2 2 4 4 2 2 3 3 9 9 10 8 8 11 12 5 5 6 6 8 8 9 9 10 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 0 1 2 3 44 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 0 1 2 3 4 1 2 4 8 16 k2k2k balanced tree: depth ~ log 2 (nodes) 2 k+1 - 1 (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 0 1 2 3 k-1 1 2 2 2 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 121312114211321 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 121312114211321 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); 4 33 2222 11111111 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 4 33 2222 11111111 121312114211321 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 84 9871 39 13 83 28 5 58 13835828539847198 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 84 9871 39 13 83 28 5 58 void listInorder( NODE *ptr) { if (ptr == NULL) return; listInorder(ptr->left); printf("%d ", ptr->key); listInorder(ptr->right); } 98847139135828583 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 84 9871 39 13 83 28 5 58 void listPreorder( NODE *ptr) { if (ptr == NULL) return; printf("%d ", ptr->key); listPreorder(ptr->left); listPreorder(ptr->right); } 13398498718328585 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 84 9871 39 13 83 28 5 58 void listPostorder( NODE *ptr) { if (ptr == NULL) return; listPostorder(ptr->left); listPostorder(ptr->right); printf("%d ", ptr->key); } 98718439558132883 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 84 9871 39 13 83 28 5 58 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 1 1 3 44 9 12 1 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 84 9871 39 13 83 28 5 58 int depth(NODE *ptr) { if (ptr == NULL) return (-1); return ( max(depth(ptr->left), depth(ptr->right) )+1 ); } 33 2 11 0 2 2 3 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 1 1 1 1 1 2 2 2 2 2 2 0 0 node A visited 2x 4 33 2222 11111111 3 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 1 1 1 1 1 2 2 2 2 2 2 0 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 4 3 22 1111 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 4 3 22 1111 stack valuevisits 41 30 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 4 3 22 1111 stack valuevisits 41 31 20 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 4 3 22 1111 stack valuevisits 41 31 21 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 4 3 22 1111 stack valuevisits 41 31 21 leaving 1 & approaching 0 push(0,0) 11 00 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 4 3 22 1111 stack valuevisits 41 31 21 leaving 0 & approaching 1 1 1 00pop() 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 4 3 22 1111 stack valuevisits 41 31 21 leaving 1 & approaching 0 1 2 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 4 3 22 1111 stack valuevisits 41 31 21 leaving 0 & approaching 1 1 2 00pop() 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 4 3 22 1111 stack valuevisits 41 31 21 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 4 3 22 12 1111 stack valuevisits 41 3 2 1 2 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 4 3 22 12 1111 stack valuevisits 41 3 2 1 2 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 4 3 22 12 1111 stack valuevisits 41 32 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 3 2 111 stack valuevisits 42 Finis (empty == true) 121312114211321 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 0 4 7 5 2 6 1 3 12345670 6 5 4 3 2 1 0 7 5 2 6 3 0 7 1 4 x y y 12345670 x 6 5 4 3 2 1 0 7 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 42256240 5103 1251 100 6446 6565 364 740823 54325 088 89216 777 216125 760 9352387 420 489651 402 1072410 000 000 0003 481 500 112 680285 311 670 61119 873 766 1214 2008 916 100 448 256121 246 416 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 1.07 2.84 8.70 32.83 133.41 594.75 2872.33 14 356.20 73 537.00 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 (1940-1941) X36DSA 2005

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