使用自定义排序算法对纸牌进行排序

Question

我正在尝试在一副纸牌上实现不同的排序算法。我已经使用枚举实现了一个基卡类来构建西装和面孔。我的课程基于 Dietel 和 Dietel 的 Java Book。但是，我在将一副纸牌传递给我实现的排序算法时遇到了困难，因为我无法传递一个可以排序的数组。我不知道我的方法是否正确，我已经阅读了 stackexchange 上的许多帖子，其中一些建议使用 Comparable (Implementing a Deck of Cards in Java)，但我看不到使用我的排序算法。请参阅 (How to Sort the Cards. (Is my code wrong?)) 和 (Implementing a Deck of Cards in Java) 和 (Java Sorting object in ArrayList)。通过让 DeckOfCards 返回一系列数字，例如1.1、1.2、1.3，我想我有一个可以排序的序列。我还阅读了关于序数的文章，但所有关于这些的 cmets 似乎都反对这种方法。感谢对此尝试的任何帮助。请注意，我已经以相同的方式实现了合并排序和选择排序，并且存在相同的问题 - 我显然在这里遗漏了一些东西！

下面是我的代码：

//卡片类

class Card
{    
     //public static enum Face {Ace, Deuce, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King};
     public static enum Face {Ace(1), King(2), Queen(3), Jack(4), Ten(5), Nine(6), Eight(7), Seven(8), Six(9), Five(10), Four(11), Three(12), Deuce(13);
     int rank;
     Face(int r){ rank = r;}
     int getRank() {return rank;}
}
//public static enum Suit {Clubs, Diamonds, Hearts, Spades };
public static enum Suit {Spades(1), Hearts(2), Diamonds(3), Clubs(4);
   int order;
   Suit(int o){ order = o;}
   int getOrder() {return order;}
}

private final Face face; // face of card
private final Suit suit; // suit of card

// two-argument constructor
public Card( Face cardFace, Suit cardSuit ) 
{   
    face = cardFace; // initialize face of card
    suit = cardSuit; // initialize suit of card
}

// return face of the card
public Face getFace() { return face;}

// return suit of Card
public Suit getSuit() { return suit;}

// return String representation of Card
public String toString()
{
   //return String.format( "%s.%s", suit.getOrder(), face.getRank() );
   return String.format( "%s.%s", suit, face );
}
}

 // class DeckOfCards declaration
 public class DeckOfCards 
{
   private List< Card > list; // declare List that will store Cards

   // set up deck of Cards and shuffle
   public DeckOfCards()
  {
     Card[] deck = new Card[ 52 ];
     int count = 0; // number of cards

     // populate deck with Card objects
     for ( Card.Suit suit : Card.Suit.values() )  
     {
         for ( Card.Face face : Card.Face.values() )   
        {
            deck[ count ] = new Card( face.getRank(), suit.getOrder() );
            count++;
        }
     }

     list = Arrays.asList( deck ); // get List
     //Collections.shuffle( list );  // shuffle deck
   }

   // output deck
   public void printCards()
  {
      // display 52 cards in two columns
      for ( int i = 0; i < list.size(); i++ )
      System.out.printf( "%-20s%s", list.get( i ),
          ( ( i + 1 ) % 2 == 0 ) ? "\n" : "" );
  }

  public static void main( String[] args )
 {
     DeckOfCards cards = new DeckOfCards();
     cards.printCards();
    //cards.InsertionSort();    
 }
 }

//插入排序

public static void insertionSort(DeckOfCards[] listToSort) 
{
    for (int i = 0; i < listToSort.length-1; i++) 
    {
        for (int k = i+1; k>0; k--) 
       {
           if(listToSort[k] < listToSort[k-1]) //Code breaks here
           {
                swap(listToSort, k, k-1);
            }
            else 
            {
                break;
            }
            print(listToSort);
        }
    }
}

Answer 1

listToSort 是DeckOfCards 的数组。在//Code breaks here 指示的行上，您正在尝试比较两个DeckOfCards 对象，而这在java 中是无法做到的（其他语言中的运算符重载将允许您这样做）。

你写一个方法怎么样，比如.getSortValue()给你一个值来排序。或者，您可以编写一些内容来比较卡片中的值，例如：

if(listToSort[k].getSuit().getOrder()*13+listToSort[k].getFace().getOrder() < listToSort[k- 1].getSuit().getOrder()*13+listToSort[k-1].getFace().getOrder())

...这有点长，但我会假设你想要什么。

注意*13 表示西装和脸型的每种组合都是独一无二的

TLDR： 如果您想以任何其他顺序对其进行排序，则必须从每张卡片中得出一个可以正确比较的值

Answer 2

正确的方法是将整个套牌分成几套，然后分别对每套进行分类。您的插入排序版本不起作用，因为排序是使用面值完成的，即 ace, 2,3,4 ... 而且我不会将其视为对甲板进行排序。

private HashMap<Suite,ArrayList<Cards>> deck ;

//scan through the whole deck

for(int i = 0;i < 52; ++i) {

    `switch(cards[i]) {`

      `case Aces :`
        deck.put(Suite.Aces,cards[i]) ;
        break;
    .....
}

}

//Now sort

sort(deck.get(Suite.Aces)) ;

sort(deck.get(Suite.Diamond)) ;

Answer 3

问题在于listToSort[k] < listToSort[k-1] 正在尝试使用< 运算符比较两个 DeckOfCards 对象，这在 Java 中是不允许的 - 请参阅：Compare two objects with or operators in Java。

---

正如该帖子指出的那样，您应该使用 Comparator 作为 Card 对象。

public class CardComparator implements Comparator<Card> {
    @Override
    public int compare(Card o1, Card o2) {
        // ...
        // Use Card.getFace().getRank() and Card.getSuit().getOrder()
        // ...
    }
}

在您的 DeckOfCards 类中，我还建议添加一个方法，例如：

public List<Card> getCards() { ... }

返回牌组中的牌列表。然后，在您的insertionSort 方法中，您将拥有listToSort.getCards().get(k)，而不是listToSort[k]。此外，您可以使用CardComparator 的新实例来确定是否交换卡片，而不是使用<。

public static void insertionSort(DeckOfCards cardsToSort) {
    final Comparator cardComparator = new CardComparator();
    for (int i = 0; i < cardsToSort.size() - 1; i++) {
        for (int k = i + 1; k > 0; k--) {
            final Card card1 = cardsToSort.getCards().get(k);
            final Card card2 = cardsToSort.getCards().get(k - 1);
            if(cardComparator.compare(card1, card2) < 0) {
                swap(cardsToSort, k, k-1);
            } else {
                break;
            }
        }
    }
}