Decks, Shuffling, Selection Sort, and Merge Sort

1. Decks, Shuffling, Selection Sort, and Merge Sort

Title

Think Java 2e · Chapter 13 · Objects of Arrays

Sections 13.1-13.6 · pp. 217-224

2. What you will be able to do

Objectives

This lesson follows Think Java 2e, Chapter 13 (Objects of Arrays), Sections 13.1-13.6, pp. 217-224. Everything on these slides can be checked against those pages.

1. Write a class whose instance variable is an array, with more than one constructor.

2. Convert a static method into an instance method and explain why the code gets shorter.

3. Use pseudocode to design an algorithm and discover the helper methods it needs.

4. Explain what a helper method is and why helper methods are usually private.

5. Describe selection sort and explain why its cost is proportional to n².

6. Explain why merge sort's n log₂ n cost matters, and write subdeck without an off-by-one error.

• 13.1 — Decks of Cards
• 13.2 — Shuffling Decks
• 13.3 — Selection Sort
• 13.4 — Merge Sort
• 13.5 — Subdecks
• 13.6 — Merging Decks

3. Retrieve before you read

Warm-up

Chapter 13 picks up exactly where Chapter 12 stopped.

4. Objects of arrays

Concept

Chapter 12 was arrays of objects — an array whose elements are Cards. Chapter 13 is objects of arrays: an object whose instance variable is an array. Wrapping the array in a class gives every deck operation a place to live.

• 13.1 — the Deck class, and two constructors
• 13.2 — shuffling, pseudocode, and helper methods
• 13.3 — selection sort
• 13.4 — merge sort, and why n log n beats n²
• 13.5–13.6 — subdecks and merging: the pieces merge sort needs

Downey & Mayfield, Think Java, 2nd edition (Green Tea Press / O'Reilly, 2020) — Think Java 2e, Chapter 13 (Objects of Arrays), Sections 13.1-13.6, pp. 217-224 — Chapter 13 opens on printed page 217.

5. The Deck class

Section

Section 13.1

6. A class that encapsulates an array

Concept

Here is the beginning of a Deck class that encapsulates an array of Card objects. The instance variable is an array, and it is private — the same information-hiding decision as Lesson 11a.

public class Deck {
    private Card[] cards;

    public Deck(int n) {
        this.cards = new Card[n];
    }

    public Card[] getCards() {
        return this.cards;
    }
}

encapsulate — To wrap data inside a class so that the methods operating on it live alongside it and clients cannot reach it directly.

The constructor initialises the instance variable with an array of n cards, but it doesn't create any Card objects. That is Lesson 12b's null array, now hidden one level deeper.

7. An unpopulated Deck

Picture it

A Deck exists. Its array exists. There is not a single Card anywhere.

Two objects have been created — the Deck and the array — and the reference in each slot is null. This constructor is for building a deck you intend to fill yourself, which is exactly what subdeck will need in Section 13.5.

8. A second constructor for a full deck

Worked example

We'll add another constructor that creates a standard 52-card array and populates it with Card objects. The body is Lesson 12b's nested loop, moved inside the class.

public Deck() {
    this.cards = new Card[52];
    int index = 0;
    for (int suit = 0; suit <= 3; suit++) {
        for (int rank = 1; rank <= 13; rank++) {
            this.cards[index] = new Card(rank, suit);
            index++;
        }
    }
}

9. What does new Deck(5) create?

Prediction

Count the objects.

public Deck(int n) {
    this.cards = new Card[n];
}
Deck sub = new Deck(5);

10. printDeck becomes print

Concept

Now that we have a Deck class, we have a logical place to put methods that pertain to decks. Converting a static method to an instance method is Lesson 11b's three edits again.

public void print() {
    for (Card card : this.cards) {
        System.out.println(card);
    }
}

Notice that when we transform a static method into an instance method, the code is shorter. The parameter disappears because the object already carries the data — which is the argument for instance methods in one line.

11. A getter that hands out the array

Trap

public Card[] getCards() {
    return this.cards;
}

// so a client can do this:
Card[] c = deck.getCards();
c[0] = null;              // the deck's own array is now damaged

// the book's choice - Pile.addDeck needs to iterate the cards
public Card[] getCards() {
    return this.cards;
}

// the defensive alternative
public Card[] getCards() {
    return Arrays.copyOf(this.cards, this.cards.length);
}

12. Which constructor for which job?

Definition probe

Two constructors, two different needs.

13. Write the instance method

Fill the middle

print traverses the deck's own array.

14. Why is Deck a better home for print?

Explain it to yourself

The static version worked fine.

15. Shuffling and pseudocode

Section

Section 13.2

16. Write the algorithm before you write the Java

Concept

For most card games you have to shuffle the deck; that is, put the cards in a random order. Section 7.6 showed how to generate random numbers, but it is not obvious how to use them to shuffle a deck — so start with a sketch.

public void shuffle() {
    for each index i {
        // choose a random number between i and length - 1
        // swap the ith card and the randomly-chosen card
    }
}

pseudocode — A combination of Java statements and English comments used to outline an algorithm before writing it.

To outline this algorithm we'll use a combination of Java statements and English comments. This technique is sometimes called pseudocode. It compiles into nothing and it is still the most valuable thing you can write at this stage.

17. Why not shuffle like a human?

Notation

The obvious approach is to imitate people, and Think Java rejects it for a reason that is worth reading twice.

This is a general trap worth naming. Copying how humans do something can copy the mechanics and lose the point — and here it produces code that is deterministic while looking random.

18. Pseudocode reveals the helper methods

Worked example

The nice thing about pseudocode is that it often makes clear what other methods you are going to need. Read the two comments and the methods fall out.

private static int randomInt(int low, int high) {
    // return a random number between low and high,
    // including both
}

private void swapCards(int i, int j) {
    // swap the ith and the jth cards in the array
}

19. Why not simulate a human shuffle?

Prediction

A program can divide and interleave perfectly.

// perfect riffle shuffle, applied eight times
// to a 52-card deck

20. Helper methods and top-down design

Concept

Methods like randomInt and swapCards are called helper methods, because they help you solve parts of the problem.

helper method — A method that solves part of a larger problem, usually private because only methods in the same class need it.

top-down design — Writing pseudocode first, then writing the helper methods that make it work.

The process of writing pseudocode first and then writing helper methods to make it work is a kind of top-down design. It is an alternative to incremental development and encapsulation and generalization, the other design processes in this book — Lessons 4b and 5b respectively. Three processes, and you choose.

21. Writing the whole method at once

Trap

public void shuffle() {
    for (int i = 0; i < cards.length; i++) {
        int j = i + (int) (Math.random() * (cards.length - i));
        Card temp = cards[i];
        cards[i] = cards[j];
        cards[j] = temp;
    }
}

public void shuffle() {
    for (int i = 0; i < cards.length; i++) {
        int j = randomInt(i, cards.length - 1);
        swapCards(i, j);
    }
}

22. Static or instance?

Definition probe

The deciding question is whether the method touches this.cards.

23. Finish the shuffle

Fill the middle

Choose a random index and swap.

24. Why should helper methods be private?

Socratic

They work perfectly well as public methods.

25. Selection sort

Section

Section 13.3

26. Repeatedly select the lowest remaining card

Concept

Now that we have shuffled the deck, we need a way to put it back in order. There is an algorithm for sorting that is ironically similar to the algorithm for shuffling — it also traverses and swaps.

public void selectionSort() {
    for each index i {
        // find the lowest card at or to the right of i
        // swap the ith card and the lowest card found
    }
}

private int indexLowest(int low, int high) {
    // find the lowest card between low and high
}

selection sort — A sorting algorithm that traverses the array repeatedly, selecting the lowest remaining element each time and swapping it into place.

It's called selection sort because it works by traversing the array repeatedly and selecting the lowest (or highest) remaining card each time. During the ith iteration we find the lowest card to the right of i and swap it with the ith card.

27. The sorted region grows from the left

Picture it

After each pass, one more position is permanently correct — and everything to its left will never move again.

The searched region shrinks by one each pass, so the passes are not all the same length: the first examines n elements, the last examines two. That detail is what makes the total cost what it is.

28. Reusing swapCards

Worked example

Again, the pseudocode helps with the design of the helper methods. And this time one of them already exists.

// from Section 13.2, unchanged:
private void swapCards(int i, int j) { ... }

// the one new helper this algorithm needs:
private int indexLowest(int low, int high) {
    // find the lowest card between low and high
}

29. What is the lowest card after one pass?

Prediction

Selection sort, first iteration, on a shuffled deck.

int lowest = indexLowest(0, cards.length - 1);
swapCards(0, lowest);

30. Why selection sort is quadratic

Concept

Selection sort is a simple algorithm, but it is not very efficient. The cost follows directly from the shape of the two loops.

// to sort n items:
//   pass 1 examines n     elements
//   pass 2 examines n - 1
//   ...
//   pass n examines 1
//
// total ≈ n * n / 2, which is proportional to n squared

To sort n items it has to traverse the array n − 1 times. Each traversal takes an amount of time proportional to n. The total time, therefore, is proportional to n². Read the last row: half a trillion comparisons to sort a million cards.

31. Searching the whole array every pass

Trap

for (int i = 0; i < cards.length; i++) {
    int lowest = indexLowest(0, cards.length - 1);   // always from 0
    swapCards(i, lowest);
}

for (int i = 0; i < cards.length; i++) {
    int lowest = indexLowest(i, cards.length - 1);   // from i
    swapCards(i, lowest);
}

32. How many comparisons to sort 1000 items?

Prediction

Selection sort, worst case, roughly.

// n - 1 traversals, each proportional to n
// total proportional to n squared

33. Match the helper to its job

Matching

Three helpers across two algorithms.

34. Is selection sort ever the right choice?

Counterexample

Quadratic sounds like a verdict.

35. Merge sort

Section

Section 13.4

36. Merging two sorted decks is fast

Concept

We will develop a more efficient algorithm called merge sort. To sort n items, merge sort takes time proportional to n log₂ n. The idea behind it is one observation: if you have two decks, each of which has already been sorted, you can quickly merge them into a single sorted deck.

// try this with a real deck of cards:
// 1. form two decks of about 10 cards each and sort them,
//    face up with the lowest cards on top
// 2. compare the TOP card from each deck and choose the lower;
//    flip it over onto the merged deck
// 3. repeat until one deck is empty, then add the remaining cards

merge sort — A sorting algorithm that splits the collection in half, sorts each half, and merges the sorted halves.

You only ever look at the two top cards, and each comparison places one card permanently. Merging two sorted decks of ten cards takes about twenty comparisons, not two hundred.

37. Why n log n is not a small improvement

Notation

Think Java gives the arithmetic outright, and it is worth reading slowly.

Choosing an algorithm is a bigger decision than any amount of tuning. No amount of making selection sort's inner loop faster closes a factor of fifty thousand.

38. The shape of merge sort

Worked example

Merge sort is three steps, and each one is a method you can write separately.

public Deck almostMergeSort() {
    // divide the deck into two subdecks
    // sort the subdecks using selectionSort
    // merge the subdecks, return the result
}

39. How many comparisons to merge two sorted 10-card decks?

Prediction

Each comparison places one card.

// 20 cards total
// each comparison moves exactly one card to the result

40. The two costs side by side

Concept

Every row of this table is the same input sorted two different ways.

At n = 10 the difference barely matters. At a million it is the difference between a program that answers and one that does not — which is why the crossover point, not the formula, is what you actually care about in practice.

41. Merging decks that are not sorted

Trap

// d1 = 5♣ 2♣ 9♣   (NOT sorted)
// d2 = 3♣ 7♣ J♣

// compare tops: 5♣ vs 3♣ -> take 3♣
// compare tops: 5♣ vs 7♣ -> take 5♣
// compare tops: 2♣ vs 7♣ -> take 2♣   <- out of order!

// divide the deck into two subdecks
// SORT the subdecks
// merge the subdecks

42. Which algorithm's cost?

Definition probe

Two growth rates.

43. The three steps

Fill the middle

Merge sort in outline.

44. Why does splitting help at all?

Explain it to yourself

You still have to sort all 52 cards.

45. Subdecks and merging

Section

Sections 13.5-13.6

46. Splitting a deck: the + 1 that matters

Concept

The first step of merge sort is to split the deck into two subdecks, each with about half of the cards. So we need a method that takes a range of indexes and returns a new deck with that subset.

public Deck subdeck(int low, int high) {
    Deck sub = new Deck(high - low + 1);
    for (int i = 0; i < sub.cards.length; i++) {
        sub.cards[i] = this.cards[low + i];
    }
    return sub;
}

The length of the subdeck is high − low + 1, because both the low card and the high card are included. Think Java says this plainly: forgetting the '+ 1' often leads to off-by-one errors, and drawing a picture is usually the best way to avoid them.

47. The subdeck shares its cards

Picture it

The loop copies references, not cards. The result is a hand of five cards that are also still in the original deck.

The result is a hand with five cards that are shared with the original deck; that is, they are aliased. Two decks, one set of cards — and Lesson 10a said that was dangerous.

48. Why the aliasing is safe here

Worked example

Chapter 10 spent a whole section on why aliasing causes bugs. Chapter 13 aliases deliberately, and explains exactly why it is allowed to.

// from Lesson 12a:
public class Card {
    private final int rank;    // final - no method can change it
    private final int suit;
    // getters, no setters
}

49. How many cards in subdeck(0, 25)?

Prediction

Both endpoints are included.

Deck sub = new Deck(high - low + 1);
// low = 0, high = 25

50. The merge algorithm, in pseudocode

Concept

The next helper method we need is merge, which takes two sorted subdecks and returns a new deck containing all cards from both decks, in order.

private static Deck merge(Deck d1, Deck d2) {
    // create a new deck, d3, big enough for all the cards
    // use the index i to keep track of where we are at in
    // the first deck, and the index j for the second deck
    int i = 0;
    int j = 0;

    // the index k traverses the result deck
    for (int k = 0; k < d3.length; k++) {
        // if d1 is empty, use top card from d2
        // if d2 is empty, use top card from d1
        // otherwise, compare the top two cards
        // add lowest card to the new deck at k
        // increment i or j (depending on card)
    }
    // return the new deck
}

Three indexes, one per deck. k advances every iteration because a card is always placed; i and j advance only when a card is taken from their deck — which is the detail that makes merge work, and the reason Think Java warns it's a little tricky, so be sure to test it with different subdecks.

51. Getting subdeck's length wrong

Trap

Deck sub = new Deck(high - low);      // one too small

// subdeck(0, 4) makes a 4-card deck for 5 cards
// subdeck(0, 25) makes a 25-card deck for 26 cards

Deck sub = new Deck(high - low + 1);
for (int i = 0; i < sub.cards.length; i++) {
    sub.cards[i] = this.cards[low + i];
}

52. What happens if you sort a subdeck?

Prediction

The subdeck shares cards with the original.

Deck sub = deck.subdeck(0, 4);
sub.selectionSort();
deck.print();      // the original

53. Which index advances when?

Definition probe

merge keeps three of them.

54. Why does merge need a new deck at all?

Socratic

It could try to merge in place.

55. The two sorts, and the design processes

Comparison

Fill the blanks.

The fourth row is the one that keeps selection sort alive. Merge sort's speed is bought with memory, and for a small deck the trade is not obviously worth making.

56. The pattern to carry away

Pattern

Top-down design: write the outline, and let it tell you which methods to write.

// 1. write the algorithm as pseudocode
public void shuffle() {
    for each index i {
        // choose a random number between i and length - 1
        // swap the ith card and the randomly-chosen card
    }
}

// 2. each comment becomes a helper method signature
private static int randomInt(int low, int high) { }
private void swapCards(int i, int j) { }

// 3. fill in the helpers, then the outline becomes real code
public void shuffle() {
    for (int i = 0; i < cards.length; i++) {
        swapCards(i, randomInt(i, cards.length - 1));
    }
}

• Pseudocode makes clear which helper methods you need.
• Helper methods are usually private — they are steps, not services.
• A helper written once gets reused — swapCards serves both shuffle and selectionSort.
• A method that touches no instance variable should be static.
• high − low + 1 whenever both endpoints are included.

57. Check: the empty constructor

Check

Work it out before you click.

public Deck(int n) {
    this.cards = new Card[n];
}
Deck sub = new Deck(26);

58. Check: subdeck's length

Check

Work it out before you click.

Deck sub = new Deck(high - low + 1);
// subdeck(3, 3)

59. Check: cost

Check

Work it out before you click.

// a million items
// selection sort: proportional to n^2
// merge sort:     proportional to n log2 n
// log2 of a million is about 20

60. Pseudocode is not a beginner's tool

Real world

Writing the outline before the code is a habit that professionals keep.

61. How sure are you?

Commit first

Commit to an answer and to your confidence.

62. Explain it to someone else

Explain it

Two minutes, out loud.

63. Exit ticket

Exit ticket

One question before you close the deck.

64. Draw the whole lesson

Connect it up

One page, from memory.

65. Recap

Recap

Six sections that wrap an array in a class and then compare two ways of sorting it.

• A Deck is an object whose instance variable is an array — Chapter 12 reversed.
• Two constructors: one makes an empty deck of n slots, one makes a full 52.
• Converting a static method to an instance method makes it shorter, because the parameter becomes this.
• Pseudocode is Java statements plus English comments, and each comment becomes a helper method.
• Helper methods are usually private because only the class needs them.
• Selection sort repeatedly selects the lowest remaining card; its cost is proportional to n².
• Merge sort splits, sorts the halves and merges; its cost is proportional to n log₂ n.
• subdeck's length is high − low + 1, and its shared cards are safe because Card is immutable.