Merge Two Halves Into One Sorted Array

[Recaip Sanli]

So cardArray is an object. I get each elements of this objects through getRank, getSuit methods in Card object. There is no setSuit and setRank. When I merge, as far as I know, I need to override values and swap them therefore I need setSuit and setRank methods. Below code fails with the error at the bottom and I am thinking because I am not able to use setSuit, setRank methods. Any ideas?

public class SortingAlgs 
{
    // card comparison
    public int compares(Card c1, Card c2)
    {
        // TODO: implement this method
        int cardOneRank = c1.getRank();
        int cardOneSuit = c1.getSuit();
        int cardTwoRank = c2.getRank();
        int cardTwoSuit = c2.getSuit();
        int result = 2;
        
        if(cardOneSuit == cardTwoSuit)
        {
            if(cardOneRank < cardTwoRank)
               return -1;
            else if (cardOneRank > cardTwoRank)
               return 1;
            else
               return 0;
        } 
        else if(cardOneSuit < cardTwoSuit)
           return -1; 
        else
           return 1;        
    }
    
    // selection sort
    public void selectionSort(Card[] cardArray)
    {
        // TODO: implement this method
        int last = cardArray.length - 1;
        
        for(int i=0;i<last;i++)
        {
            int indMin = minIndex(cardArray, i, last);
            Card temp = cardArray[i];
            cardArray[i] = cardArray[indMin];
            cardArray[indMin] = temp;
        }
    }
    
    // find the index of the smallest element in the specified range
    public int minIndex(Card[] cardArray, int startIndex, int endIndex)
    {
        // TODO: implement this method
        int indMin = startIndex;
        int compare = 0;
        
        for(int i = startIndex + 1; i <= endIndex; i++)
        {
            compare = compares(cardArray[indMin],cardArray[i]);
               if(compare == 1)
                  indMin = i;
        }
        
        return indMin; // replace this statement with your own return
    }    

    // merge sort
    public void mergeSort(Card[] cardArray)
    {
        mergeSortRec(cardArray, 0, cardArray.length - 1);
    } 
    
    // recursive helper recursive method for mergeSort
    public void mergeSortRec(Card[] cardArray, int startIndex, int endIndex)
    {
        if (startIndex < endIndex)
        {
            int midIndex = (startIndex + endIndex) / 2;
            mergeSortRec(cardArray, startIndex, midIndex);
            mergeSortRec(cardArray, midIndex + 1, endIndex);
            merge(cardArray, startIndex, endIndex);
        }
    } 
    
    // merge two sorted halves into one sorted array
    public void merge(Card[] cardArray, int startIndex, int endIndex)
    {        
        // TODO: implement this method
        int mid = ( startIndex + endIndex ) / 2;
        int n = endIndex - startIndex + 1;
        int[] tempArray = new int[n];
        int i1 = startIndex;
        int i2 = mid + 1;
        int j = 0;
        
        while (i1 <= mid && i2 <= endIndex)
        {
            if(compares(cardArray[i1],cardArray[i2]) == -1)
            {
               tempArray[j] = cardArray[i1].getSuit() + cardArray[i1].getRank();
               i1++;
            } 
            else
            {
               tempArray[j] = cardArray[i2].getSuit() + cardArray[i2].getRank();
               i2++;
            } 
            j++;
        }
        
        while(i1 <= mid)
        {
            tempArray[j] = cardArray[i1].getSuit() + cardArray[i1].getRank();
            i1++;
            j++;
        }
        
        while(i2 <= endIndex)
        {
            tempArray[j] = cardArray[i2].getSuit() + cardArray[i2].getRank();
            i2++;
            j++;
        }
        
        for (j = 0; j < n; j++)
            cardArray[startIndex + j] = tempArray[j];
        
    }  
}

Deck

// The Deck class that represents decks
// Do not make any changes to this file!
// Xiwei Wang

import java.io.*;

public class Deck implements Serializable
{
    // instance variables
    private Card[][] myCards;
    private int m_numCards; // the number of card that are picked up to build the partial deck
    private String m_sortedDeck;
    
    // constructor
    public Deck()
    {
        myCards = new Card[4][13];
        
        // populate the card array
        for (int i = 0; i < 4; i++)               
            for (int j = 0; j < 13; j++)
                myCards[i][j] = new Card(i, j);
    }
      
    // shuffle the deck
    public void shuffle(int numShuffles)
    {
        for (int i = 0; i < numShuffles; i++)
        {
            // generate random positions
            int suit1 = (int)(Math.random() * 4);
            int suit2 = (int)(Math.random() * 4);
            int rank1 = (int)(Math.random() * 13);
            int rank2 = (int)(Math.random() * 13);
            
            // swap the cards
            Card temp = myCards[suit1][rank1];
            myCards[suit1][rank1] = myCards[suit2][rank2];
            myCards[suit2][rank2] = temp;
        }
    }
    
    // return a particular card in the deck
    public Card getCard(int suit, int rank)
    {
        return myCards[suit][rank];
    }
    
    // return a specific number of cards as a card array
    public Card[] getPartialDeck(int numCards)
    {
        Card[] partialDeck = new Card[numCards];
        int counter = 0;
        
        for (int i = 0; i < 4; i++)
            for (int j = 0; j < 13; j++)
            {
                partialDeck[counter] = myCards[i][j];
                counter++;
                
                if (counter == numCards)
                    return partialDeck;
            }
        
        return partialDeck;
    }
    
    // return a string reprentation of the deck
    public String toString()
    {
        String deckContent = "";
        
        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j < 13; j++)
                deckContent += myCards[i][j].toString() + " ";
            
            deckContent += "\n";
        }
        
        return deckContent;
    }
    
    // set the number of cards that would be picked up and the sorted deck string
    public void setVars(int numCards, String sortedDeck)
    {
        m_numCards = numCards;
        m_sortedDeck = sortedDeck;       
    }
 
    // return the number of cards that would be picked up
    public int getnumCards()
    {
        return m_numCards;
    }
    
    // return the sorted deck string
    public String getSortedDeck()
    {
        return m_sortedDeck;
    }
}

Card

// The Card class that represents cards
// Do not make any changes to this file!
// Xiwei Wang

import java.io.*;

public class Card implements Serializable
{
    // instance variables
    private int m_suit;
    private int m_rank;
    
    // constructor
    public Card(int suit, int rank)
    {
        m_suit = suit;
        m_rank = rank;
    }
    
    // getters
    public int getSuit()
    {
        return m_suit;
    }
    
    public int getRank()
    {
        return m_rank;
    }   

    // return a string representation of the card
    public String toString()
    {
        String[] suitChars = {"C", "D", "H", "S"};
        String[] rankChars = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};
        
        return suitChars[m_suit] + rankChars[m_rank];
    }
}

TestDrive

// Test driver for the SortingAlgs class
// Do not make any changes to this file!
// Xiwei Wang

import java.io.*;
import java.util.Arrays;

public class TestCardSorting
{	
    public static void main(String[] args)
    {        
        SortingAlgs mySort = new SortingAlgs();
       
        try
        {
            // read the decks from file
            ObjectInputStream in = new ObjectInputStream(new FileInputStream("Decks.dat"));
            Deck[] myDeck = new Deck[5];
            myDeck = (Deck[])in.readObject();

            for (int i = 0; i < 5; i++)
            {
                Card[] myCards = myDeck[i].getPartialDeck(myDeck[i].getnumCards());
                String before = Arrays.toString(myCards);
				
                System.out.println("Test " + (i + 1) + ":");  
                System.out.println("The cards before sorting are\n" + before);
                System.out.println("------------------------------------");
                
                Card[] testCards = myCards.clone();
                mySort.selectionSort(testCards);
                String after = Arrays.toString(testCards);

                System.out.println("The cards after Selection Sort are\n" + after);
                if (after.equals(myDeck[i].getSortedDeck()))
                    System.out.println("Your Selection Sort works correctly.\n");
                else
                    System.out.println("Something is wrong with your Selection Sort.\n");
                
                testCards = myCards.clone();
                mySort.mergeSort(testCards);
                after = Arrays.toString(testCards);

                System.out.println("The cards after Merge Sort are\n" + after); 
                if (after.equals(myDeck[i].getSortedDeck()))
                    System.out.println("Your Merge Sort works correctly.");
                else
                    System.out.println("Something is wrong with your Merge Sort.");  
                
                System.out.println("====================================\n");
            }
          
        }
        catch (Exception e)
        {
          System.out.println("Error occurred: " + e.getMessage());   
        }        
    }
    
}

Error

SortingAlgs.java:122: error: incompatible types: int cannot be converted to Card
            cardArray[startIndex + j] = tempArray[j];
                                                 ^
1 error

 ----jGRASP wedge2: exit code for process is 1.
 ----jGRASP: operation complete.

[Junilu Lacar]

You should be swapping Card objects, not the values of the ranks and suits.

Edit: Yup, it seems you haven't quite grasped the concept of object-orientation. You are reaching far too deep into the details and you're attempting to use a 2D array to represent combinations of ranks and suits. That is not what you're supposed to do. Go back over your notes and review the concept of "Encapsulation".  A Card object encapsulates the rank and suit values.  Once you create a Card with a specific rank and suit, there is absolutely no need to change it.  A real world analogy would be if you had a bunch of real playing cards, you are essentially trying to take an eraser and rub out the markings on each card so you can write over it with a pencil. If you saw someone in the real world trying to do that, you'd probably think they have a screw loose or something, so why would you do essentially the same thing in your program?

[Recaip Sanli]

This is an homework given to me, I didn't really plan this program.

But it does make sense that I need to replace cardArray objects.

I don't know why would anyone write a code to go through merge sort method of each individual cardArray objects. It's totally unuseful and not helpful to understand the concept of merge sort whatsoever.

Thank you!

[Recaip Sanli]

Now that I am thinking though, I don't need to swap, I need to override actual array.

In the above code, I am using tempArray to write down the correct sorted object Card array. All I need to do at the end is copy over all tempArray values over to Card object.

How would I do that without setSuit and setRank though?

[Junilu Lacar]

I couldn't tell you, honestly. That's like asking me how to drive on the wrong side of the road or clean a gun while it was loaded. It would be irresponsible for me to tell you because you just might go out and do it and get yourself killed or something.

For me, the only reasonable and sensible answer is this: DON'T do it that way. Go back and look for object-oriented examples of Card/Rank/Suit.  Rank and Suit are normally implemented as enums. A Card is immutable, once you create it with a given Rank and Suit, it can't be changed. Did you not understand my analogy with real-world cards?

[Junilu Lacar]

Here, have a look at the object-oriented way to write a Card class below. The CardDemo is just a quick-and-dirty way to show how to use the Card class, create instances, put them in a Collection, display, shuffle, sort them. I will leave it up to you to implement a proper Deck class that would manage a bunch of Card objects, allow those Card objects to be shuffled, ordered, dealt in hands, etc.

package com.javaranch.beginner;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import com.javaranch.beginner.Card.Rank;
import com.javaranch.beginner.Card.Suit;

public class CardDemo {
    public static void main(String[] args) {
        List<Card> standardDeck = createStandardDeck();

        display(standardDeck);

        displayShuffled(standardDeck);

        displaySorted(standardDeck);
    }

    private static void displaySorted(List<Card> deck) {
        Collections.sort(deck);

        System.out.println("\nAfter sorting again:");
        showCards(deck);
    }

    private static void displayShuffled(List<Card> deck) {
        Collections.shuffle(deck);

        System.out.println("\nAfter shuffling:");
        showCards(deck);
    }

    private static void display(List<Card> deck) {
        System.out.println("Brand new, out of the box:");
        showCards(deck);
    }

    private static List<Card> createStandardDeck() {
        List<Card> deck = new ArrayList<>();

        for (Suit suit : Suit.values())
            for (Rank rank : Rank.values())
                deck.add(new Card(rank, suit));

        return deck;
    }

    private static void showCards(List<Card> deck) {
        deck.stream()
            .map(c -> String.format("%s (%s)", c, c.name()))
            .forEach(System.out::println);
    }
}

final class Card implements Comparable<Card> {

    public static enum Rank {
        ACE("A"), TWO("2"), THREE("3"), FOUR("4"), FIVE("5"), 
        SIX("6"), SEVEN("7"), EIGHT("8"), NINE("9"), TEN("10"), 
        JACK("J"), QUEEN("Q"), KING("K");

        private String symbol;

        private Rank(String symbol) {
            this.symbol = symbol;
        }
    }

    public static enum Suit {
        SPADES('\u2660'), HEARTS('\u2665'), CLUBS('\u2663'), DIAMONDS('\u2666');

        private char symbol;

        private Suit(char symbol) {
            this.symbol = symbol;
        }
    }

    private final Rank rank;
    private final Suit suit;

    public Card(Rank rank, Suit suit) {
        this.rank = rank;
        this.suit = suit;
    }

    @Override
    public int compareTo(Card o) {
        int suitComparison = suit.compareTo(o.suit);
        if (suitComparison != 0) {
            return suitComparison;
        }
        return rank.compareTo(o.rank);
    }

    @Override
    public String toString() {
        return rank.symbol + suit.symbol;
    }

    public String name() {
        return rank.name() + " of " + suit.name();
    }
}

[Recaip Sanli]

Thank you @Junilu Lacar, your cardDemo is much better than the one teacher gave me.

I just hope I won't end up getting a 0 by not figuring out a way to handle what he asked based on the way he's making me do it.

This is why it's better to learn coding yourself rather go to school. You learn from one another group of people and knowledge versus teacher make you code certain way you never really learn how to do certain things better.

[Junilu Lacar]

Recaip Sanli wrote:Thank you @Junilu Lacar, your cardDemo is much better than the one teacher gave me.

It's the least I could do for you. Are you taking an online course or are you actually going to a brick-and-mortar school? If that was my instructor, I'd be on the phone with the school administration / department chair and giving them an earful.

[Junilu Lacar]

Here's a challenge for you: How would you change the code I gave so that you could program a classic Solitaire game? In Classic Solitaire, open cards must alternate between red suits and black suits and they must be in rank order, with cards with lower ranks being placed on top of cards with the next higher rank, e.g. a black 10 can only be placed on top of a red Jack which can only be placed on top of a black Queen. How would you validate that a move was legal?

Hint: It might help if you added these methods:

private boolean canPut(Card card, Card onTopOf) {
   ...
}

public boolean isBlack() {
   ...
}

public boolean isRed() {
   ...
}

One part of this challenge is to decide where to put these methods (they probably wouldn't all go in the same place).