DM550 Introduction to Programming part 2. Jan Baumbach.

Transcription

1 DM550 Introduction to Programming part 2 Jan Baumbach jan.baumbach@imada.sdu.dk

2 BINARY SORTING TREES 2

3 Binary Sort Tree special binary tree invariant for all subtrees: all elements smaller than root in left subtree all elements bigger than root in right subtree elements need to be comparable D interface Comparable B I use method compareto A C E our example tree is a sort tree nodes are of class Character G F H 3

4 SortTree ADT: Specification data are objects of some class E that extends Comparable operations are defined by the following interface public interface SortTree<E extends Comparable<E>> { public int size(); // number of elements public boolean contains(e elem); // true, if elem in tree public void add(e elem); // add elem to tree public void remove(e elem); // tremove elem from tree public List<E> traverse(); // in-order traversal public void balance(); // balance the tree } 4

5 SortTree ADT: Design & Implement. Design: use recursive data structure reuse class BinTreeNode<E> Implementation 1: public class BinSortTree<E extends Comparable<E>> implements SortTree<E> { private BinTreeNode<E> root = null; public int size() { return size(this.root); } private static <E extends Comparable<E>> int size(bintreenode<e> node) { if (node == null) { return 0; } return 1 + size(node.left) + size(node.right); } 5

6 SortTree ADT: Implementation Implementation 1 (continued): contains('g') D public boolean contains(e elem) { B I return contains(this.root, elem); } A C E private static <E extends Comparable<E>> boolean contains(bintreenode<e> node, E elem) { G if (node == null) { return false; } F switch (signum(elem.compareto(node.elem))) { case -1: return contains(node.left, elem); case 0: return true; case 1: return contains(node.right, elem); } throw new RuntimeException("compareTo error"); } H 6

7 SortTree ADT: Implementation Implementation 1 (continued): public void add(e elem) { this.root = add(this.root, elem); } private static int signum(int x) { return x == 0? 0 : (x > 0? 1 : -1); } private static <E extends Comparable<E>> BinTreeNode<E> add(bintreenode<e> node, E elem) { if (node == null) { return new BinTreeNode<E>(elem, null, null); } switch (signum(elem.compareto(node.elem))) { 7

8 SortTree ADT: Implementation Implementation 1 (continued): add('f') D case -1: node.left = add(node.left, elem); B I return node; A C E case 0: return node; case 1: G node.right = add(node.right, elem); return node; F H } throw new RuntimeException("compareTo error"); } 8

9 Binary Sort Tree: Removal first, find the node (as contains or add) four cases for node to be removed DC 1. no children delete('h') B I 2. only a left child 3. only a right child delete('g') A C EF 4. both left and right child easy to handle 1-3: 1. delete node delete('e') delete('d') F GF H 2. replace node by left child 3. replace node by right child 4. replace node by largest element in left subtree 9

10 SortTree ADT: Implementation Implementation 1 (continued): public void remove(e elem) { this.root = remove(this.root, elem); } private static <E extends Comparable<E>> E max(bintreenode<e> node) { return node.right == null? node.elem : max(node.right); } private static <E extends Comparable<E>> BinTreeNode<E> remove(bintreenode<e> node, E elem) { if (node == null) { return null; } switch (signum(elem.compareto(node.elem))) { 10

11 SortTree ADT: Implementation Implementation 1 (continued): case -1: return new BinTreeNode<E>(node.elem, remove(node.left, elem), node.right); case 0: if (node.left == null) { return node.right; } if (node.right == null) { return node.left; } E max = max(node.left); return new BinTreeNode<E>(max, remove(node.left, max), node.right); case 1: return new BinTreeNode<E>(node.elem, node.left, remove(node.right, elem)); } throw new RuntimeException("compareTo error"); } 11

12 SortTree ADT: Implementation Implementation 1 (continued): public java.util.list<e> traverse() { return traverse(this.root, new java.util.arraylist<e>()); } private static <E extends Comparable<E>> List<E> traverse(bintreenode<e> node, List<E> result) { if (node!= null) { traverse(node.left, result); result.add(node.elem); traverse(node.right, result); } return result; } 12

13 Sorting Tree Balancing A sorted tree is balanced iff for each node holds: Math.abs(size(node.left) - size(node.right)) <=1 Assume: size(node.right) > size(node.left)+1 i.e. more elements in the right subtree Idea: Move small elements from the right to the left subtree until balanced Recursively repeat for all nodes in the tree 13

14 Sorting Tree Balancing 1. Replace root node with smallest element in right subtree 2. Remove this smallest element from the right subtree 3. Add (former) root node to the left subtree 4. Repeat until balanced 5. Recursively repeat for subtrees to the left + right of the new root node 14

15 Sorting Tree Balancing lsize = 3 rsize = 7 D B I A C E N G M F H 15

16 Sorting Tree Balancing lsize = 3 rsize = 7 D B I A C E N Start with the root node. F G H M 16

17 Sorting Tree Balancing lsize = 3 rsize = 7 D B I A C E N rsize > lsize +1 F G H M à Find smallest element in right subgraph. 17

18 Sorting Tree Balancing lsize = 3 rsize = 7 D B I A C E N Replace root node with smallest element in right subgraph. F G H M 18

19 Sorting Tree Balancing lsize = 3 rsize = 7 E B I A C E N Replace root node with smallest element in right subgraph. F G H M 19

20 Sorting Tree Balancing lsize = 3 rsize = 7 E B I A C E N D G M Add (former) root node to the left subtree. F H 20

21 Sorting Tree Balancing lsize = 3 rsize = 7 E B I A C N D G M Remove (new) root node (= former smallest element of right subtree) from the right subtree. F H 21

22 Sorting Tree Balancing lsize = 4 rsize = 6 E B I A C N D G M Check if balanced. F H 22

23 Sorting Tree Balancing lsize = 4 rsize = 6 E B I A C N D G M No, as 6 > 4+1. F H à Start again with root node. 23

24 Sorting Tree Balancing lsize = 4 rsize = 6 E B I A C N D G M Find smallest element in right subtree. F H 24

25 Sorting Tree Balancing lsize = 4 rsize = 6 E B I A C N D G M Replace root node with this element. F H 25

26 Sorting Tree Balancing lsize = 4 rsize = 6 F B I A C N D G M Replace root node with this element. F H 26

27 Sorting Tree Balancing lsize = 4 rsize = 6 F B I A C N D G M Add (former) root to the left subtree. E F H 27

28 Sorting Tree Balancing lsize = 4 rsize = 6 F B I A C N D G M Remove (new) root from right subtree. E H 28

29 Sorting Tree Balancing lsize = 5 rsize = 5 F B I A C N D G M Check if balanced. E H 29

30 Sorting Tree Balancing lsize = 5 rsize = 5 F B I A C N D G M YES! à Repeat with left and right subtrees recursively. E H 30

31 Sorting Tree Balancing F lsize = 1 B rsize = 3 I A C N D G M Find smallest element in right subtree. E H 31

32 Sorting Tree Balancing F lsize = 1 C rsize = 3 I A D N B E G M 1. Replace root node with it. 2. Add (former) root to left subtree. 3. Remove it from the right subtree. H 32

33 Sorting Tree Balancing F lsize = 2 C rsize = 2 I A D N B E G M Balanced? H 33

34 Sorting Tree Balancing F lsize = 2 C rsize = 2 I A D N B E G M Balanced? H YES! à Check subtrees. 34

35 Sorting Tree Balancing F lsize = 2 C rsize = 2 I A D G N B E H M Continue until tree is balanced. 35

36 SortTree ADT: Implementation Implementation 1 (continued): public void balance() { this.root = balance(this.root); } private static <E extends Comparable<E>> E min(bintreenode<e> node) { return node.left == null? node.elem : min(node.left); } private static <E extends Comparable<E>> BinTreeNode<E> balance(bintreenode<e> node) { if (node == null) { return null; } int lsize = size(node.left); int rsize = size(node.right); 36

37 SortTree ADT: Implementation Implementation 1 (continued): while (lsize > rsize+1) { E max = max(node.left); lsize--; rsize++; node = new BinTreeNode<E>(max, remove(node.left, max), add(node.right, node.elem)); } while (rsize > lsize+1) { E min = min(node.right); rsize--; lsize++; node = new BinTreeNode<E>(min, add(node.left, node.elem), remove(node.right, min)); } return new BinTreeNode<E>(node.elem, balance(node.left), balance(node.right)); } } // DONE! 37

38 PROJECT 38

39 Organizational Details The project has to be passed to pass the course It has to be done individually. No co-operation! You may talk about the problem, however, and share ideas on how to solve it. Deliverables: Written 4-page report as specified in the project description Deadline: January 12, 2017, 23:59 ENOUGH - now for the ABSTRACT part 39

40 Sudoku solving Pen & paper game played on a 9 x 3 x 3 grid Goal: Distribute the numbers from 1-9 in each of the 3x3 fields such that in each 3x3-field, as well as in each 9er-row and each 9er-column every number occurs exactly once Task I: Implement ADT solving a given input game Task II: Implement a GUI 40

41 Sudoku solving 41

42 Sudoku solving 42

43 Sudoku solving X X 8 1 X X 5 X X 9 6 X X 8 X X X X X 5 X X 3 6 X 9 8 X X 7 X 6 9 X 1 2 X X 6 8 X 7 3 X X 8 1 X 4 5 X 6 X X 4 2 X 6 7 X X 8 X X X X X 4 X X 6 3 X X 5 X X 8 7 X X 43

44 Sudoku solving X X 8 1 X X 5 X X 9 6 X X 8 X X X X X 5 X X 3 6 X 9 8 X X 7 X 6 9 X 1 2 X X 6 8 X 7 3 X X 8 1 X 4 5 X 6 X X 4 2 X 6 7 X X 8 X X X X X 4 X X 6 3 X X 5 X X 8 7 X X

45 Sudoku solving Find the project description at df Task I: Implement ADT solving a given input game Task II: Implement a GUI Additional challenge: Use recursions in the solver! Hint: Use Java s SWING library when possible 45

46 THANKS! 46

47 MULTIVARIATE TREES 47

48 Multivariate Trees general class of trees nodes can have any number of children our application: k-permutations of n all sequences without repetition total of n elements sequences of length k < n Example: total of n = 3 elements sequences of length k = ,2 1,3 2,1 2,3 3,1 3,2 48

49 MTree ADT: Specification data are sequences of integers (List<Integer>) operations are defined by the following interface public interface MTreeADT extends javax.swing.tree.treemodel { public Object getroot(); public boolean isleaf(object node); public int getchildcount(object node); public Object getchild(object parent, int index); public int getindexofchild(object parent, Object child); } TreeModel specifies additional operations needed for JTree 49

50 MTree ADT: Design & Implement. Design: use recursive data structure Implementation: public class MTreeNode { private List<Integer> seq; // sequence of integers private List<MTreeNode> children = new ArrayList<MTreeNode>(); public MTreeNode(List<Integer> seq) { this.seq = seq; } public List<Integer> getseq() { return this.seq; } public List<MTreeNode> getchildren() { return this.children; } public String tostring() { return this.seq.tostring(); } } 50

51 MTree ADT: Implementation Implementation (continued): public class MTree implements MTreeADT { private MTreeNode root = new MTreeNode( new ArrayList<Integer>()); public Object getroot() { return this.root; } public boolean isleaf(object node) { return this.getchildcount(node) == 0; } public int getchildcount(object node) { return ((MTreeNode)node).getChildren().size(); } 51

52 MTree ADT: Implementation Implementation (continued) public class MTree implements MTreeADT { public Object getchild(object parent, int index) { return ((MTreeNode)parent).getChildren().get(index); } public int getindexofchild(object parent, Object child) { return ((MTreeNode)parent).getChildren().indexOf(child); } public void addtreemodellistener(treemodellistener l) {} public void removetreemodellistener(treemodellistener l) {} public void valueforpathchanged(treepath p, Object o) {} 52

53 MTree ADT: Implementation Implementation (continued) public class MTree implements MTreeADT { private static MTree maketree(string title) { MTree tree = new MTree(); JScrollPane content = new JScrollPane(new JTree(tree)); JFrame window = new JFrame(title); window.setcontentpane(content); window.setdefaultcloseoperation(jframe.exit_on_close); window.setsize(400,400); window.setvisible(true); return tree; } 53

54 MTree ADT: Implementation Implementation (continued) public class MTree implements MTreeADT { public static void main(string[] args) { int n = 3; int k = 2; MTree tree = maketree("mtree recursive"); tree.expandrecursively(n,k); } 54

55 MTree ADT: Implementation Implementation (continued) public class MTree implements MTreeADT { private void expandrecursively(int n, int k) { expandrecursively(this.root, n, k); } private List<Integer> copyadd(list<integer> seq, int i) { List<Integer> copyseq = new ArrayList<Integer>(seq); copyseq.add(i); return copyseq; } 55

56 MTree ADT: Implementation 56 Implementation (continued): private void expandrecursively(mtreenode node, List<Integer> seq = node.getseq(); if (seq.size() < k) { } } } } June 2009 for (int i = 1; i <= n; i++) { if (!seq.contains(i)) { int n, int k) { List<Integer> newseq = copyadd(seq, i); MTreeNode child = new MTreeNode(newSeq); node.getchildren().add(child); expandrecursively(child, n, k); ,2 1,3 2,1 2,3 3,1 3,2

57 MTree ADT: Implementation Implementation (continued): private void expandstack(int n, int k) { Stack<MTreeNode> stack = new LinkedStack<MTreeNode>(); stack.push(this.root); while (!stack.isempty()) { MTreeNode node = stack.pop(); List<Integer> seq = node.getseq(); if (seq.size()<k) { for (int i=1; i<=n; i++) { if (!seq.contains(i)) { MTreeNode child = new MTreeNode(copyAdd(seq, i)); node.getchildren().add(child); stack.push(child); }}} } } 57

58 MTree ADT: Implementation Implementation (continued): private void expandqueue(int n, int k) { Queue<MTreeNode> queue = new LinkedQueue<MTreeNode>(); queue.offer(this.root); while (!queue.isempty()) { MTreeNode node = queue.poll(); List<Integer> seq = node.getseq(); if (seq.size()<k) { for (int i=1; i<=n; i++) { if (!seq.contains(i)) { MTreeNode child = new MTreeNode(copyAdd(seq, i)); node.getchildren().add(child); queue.offer(child); }}} } } } // DONE! 58