1. Winner trees. Loser Trees.
Tournament Trees
Winner trees.
Loser Trees.

2. Winner Tree – Definition
Complete binary tree with n-1 internal nodes and n external nodes.
External nodes represent tournament players.
Each internal node represents a match played between its two children; the winner of the match is stored at the internal node.
Root has overall winner.

3. Winner Tree For 16 Players
match node
Array representation.

4. Winner Tree For 16 Players2 3 1 2 2
Match nodes actually store pointer to winner. When implementing, easier to play matches from 15 down to 1. Winner tree for football playoffs. 3 6 1 3 2 4 2 5 4 3 6 8 1 5 7 3 2 6 9 4 5 2 5 8
Smaller element wins => min winner tree.

5. Winner Tree For 16 Players2 3 1 2 2
Can use min heap of pointers to front records of runs for k-way merge. Replay is also O(log n). Need to access 2 children of each node on downward reinsert path. Min heap doesn’t have well-defined tie breaker (i.e., leftmost wins), which is useful in certain applications like stable external sorting. 3 6 1 3 2 4 2 5 4 3 6 8 1 5 7 3 2 6 9 4 5 2 5 8
height is log2 n (excludes player level)

6. Complexity Of Initialize
O(1) time to play match at each match node.
n – 1 match nodes.
O(n) time to initialize n-player winner tree.

7. Winner Tree Operations
Initialize
O(n) time
Get winner
O(1) time
Replace winner and replay
O(log n) time
More precisely Theta(log n)
Tie breaker (player on left wins in case of a tie).

8. Replace Winner And Replay4 3 6 8 1 5 7 2 9
Replace winner with 6.

9. Replace Winner And Replay1 1 2 3 1 2 2 3 6 1 3 2 4 2 5 4 3 6 8 6 5 7 3 2 6 9 4 5 2 5 8
Replay matches on path to root.

10. Replace Winner And Replay1 1 2 3 1 2 2 3 6 1 3 2 4 2 5 4 3 6 8 6 5 7 3 2 6 9 4 5 2 5 8
Replay matches on path to root.

11. Replace Winner And Replay1 1 2 3 1 2 2 3 6 1 3 2 4 2 5 4 3 6 8 6 5 7 3 2 6 9 4 5 2 5 8
Opponent is player who lost last match played at this node.

12. Each match node stores the match loser rather than the match winner.
Loser Tree
Each match node stores the match loser rather than the match winner.

13. Min Loser Tree For 16 Players3 4 8 4 3 6 8 1 5 7 3 2 6 9 4 5 2 5 8

14. Min Loser Tree For 16 Players3 6 1 4 8 5 7 4 3 6 8 1 5 7 3 2 6 9 4 5 2 5 8

15. Min Loser Tree For 16 Players3 6 3 2 4 8 5 7 6 9 4 3 6 8 1 5 7 3 2 6 9 4 5 2 5 8

16. Min Loser Tree For 16 Players3 2 6 3 4 2 4 8 5 7 6 9 5 8 4 3 6 8 1 5 7 3 2 6 9 4 5 2 5 8

17. Min Loser Tree For 16 Players3 2 6 3 4 5 4 8 5 7 6 9 5 8 4 3 6 8 1 5 7 3 2 6 9 4 5 2 5 8

18. Min Loser Tree For 16 Players3 2 6 3 4 5 4 8 5 7 6 9 5 8 4 3 6 8 1 5 7 3 2 6 9 4 5 2 5 8

19. Min Loser Tree For 16 Players2 3 2 6 3 4 5 4 8 5 7 6 9 5 8 4 3 6 8 1 5 7 3 2 6 9 4 5 2 5 8

20. Winner 1 2 3 2 6 3 4 5 4 8 5 7 6 9 5 8 4 3 6 8 1 5 7 3 2 6 9 4 5 2 5 8

21. Complexity Of Loser Tree Initialize
Start with 2 credits at each match node.
Use one to pay for the match played at that node.
Use the other to pay for the store of a left child winner.
Total time is O(n).
More precisely Theta(n).
Start with 2 credits on each node; then charge match and store loser 1 unit to match node; store left child winner 1 unit to store node. Storing of overall winner is another cost of 1.
Can do also with 1 credit/node. Play match, store loser and winner = 1 unit of work.

22. Replace winner with 9 and replay matches.4 3 6 8 1 5 7 2 9 2 3 3 5 9 9
Replace winner with 9 and replay matches.

23. Complexity Of Replay One match at each level that has a match node.
O(log n)
More precisely Theta(log n).

24. Tournament Tree Applications
Run generation.
k-way merging of runs during an external merge sort.
Truck loading.

25. Truck Loading n packages to be loaded into trucks
each package has a weight
each truck has a capacity of c tons
minimize number of trucks

26. Bin Packing n items to be packed into bins each item has a size
each bin has a capacity of c
minimize number of bins
Memory allocation is a related problem. Best fit and first fit are 2 of the heuristics used in memory allocation.

27. Bin Packing Truck loading is same as bin packing.
Truck is a bin that is to be packed (loaded).
Package is an item/element.
Bin packing to minimize number of bins is NP-hard.
Several fast heuristics have been proposed.

28. Bin Packing Heuristics
First Fit.
Bins are arranged in left to right order.
Items are packed one at a time in given order.
Current item is packed into leftmost bin into which it fits.
If there is no bin into which current item fits, start a new bin.

29. Bin Packing Heuristics
First Fit Decreasing.
Items are sorted into decreasing order.
Then first fit is applied.

30. Bin Packing Heuristics
Best Fit.
Items are packed one at a time in given order.
To determine the bin for an item, first determine set S of bins into which the item fits.
If S is empty, then start a new bin and put item into this new bin.
Otherwise, pack into bin of S that has least available capacity.

31. Bin Packing Heuristics
Best Fit Decreasing.
Items are sorted into decreasing order.
Then best fit is applied.

32. Performance For first fit and best fit:
Heuristic Bins <= (17/10)(Minimum Bins) + 2
For first fit decreasing and best fit decreasing:
Heuristic Bins <= (11/9)(Minimum Bins) + 4

33. Max Winner-Tree For 16 Bins8 4 3 6 1 5 7 2 9
Use for first fit and first fit decreasing. Start with n bins with avail capacity c. Or, do some simple packing like examine objects left to right; put into bin 1 until you reach an item that doesn’t fit, then go to bin 2 but do not look back at bin 1. O(n) time. Use the number of bins obtained this way to start first fit in an attempt to do better. Or, when every object needs less than half a bin, FF needs at most n/2 bins and so on.
Item size = 7

34. Max Winner-Tree For 16 Bins9 7 9 6 7 9 8 4 6 5 7 6 9 5 8 4 3 6 1 1 5 7 3 2 6 9 4 5 2 5 8

35. Complexity Of First Fit
O(n log n), where n is the number of items.