Java 使用自定义排序算法对卡片组进行排序

我试图在一副卡片上实现不同的排序算法。我已经使用enum实现了一个基本的card类来构建西装和面孔。我的课程基于Ditel和Ditel的Java书籍。然而，我正在努力将卡片组传递到我实现的排序算法中，因为我无法传递一个可以排序的数组。我不知道我的方法是否正确，我已经阅读了stackexchange上的许多帖子，其中有人建议使用Comparable（），我看不到它能与我的排序算法一起工作。请参见（）和（）以及（）。通过让DeckOfcard返回一个数字序列，例如1.1、1.2、1.3，我认为我有一个可以排序的序列。我也读过关于序号的文章，但所有关于序号的评论似乎都反对这种方法。感谢您对此尝试的任何帮助。请注意，我以同样的方式实现了合并排序和选择排序，这是同一个问题——我显然遗漏了一些东西

下面是我的代码：

//卡片类

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();    
 }
 }

类卡
{    
/公共静态Enm面{ACE，Deuce，三，四，五，六，七，八，九，十，杰克，皇后，King }；
公开静态枚举面{Ace（1）、国王（2）、王后（3）、杰克（4）、十（5）、九（6）、八（7）、七（8）、六（9）、五（10）、四（11）、三（12）、平手（13）；
整数秩；
面（int r）{rank=r；}
int getRank（）{return rank；}
}
//公共静态枚举套装{梅花、钻石、红心、黑桃}；
公开静态枚举套装{黑桃（1）、红桃（2）、钻石（3）、梅花（4）；
整数阶；
诉讼（into）{order=o；}
int getOrder（）{return order；}
}
私有最终面；//卡的面
私人最终诉讼；//信用卡诉讼
//双参数构造函数
公共卡（脸牌、西装牌）
{   
face=cardFace；//初始化卡的面
suit=cardSuit；//初始化卡套
}
//卡片的背面
公共面getFace（）{return Face；}
//退卡
公诉状getSuit（）{return Suit；}
//卡片的返回字符串表示法
公共字符串toString（）
{
//返回String.format（“%s.%s”，suit.getOrder（），face.getRank（））；
返回String.format（“%s.%s”，套装，正面）；
}
}
//信用证类别声明
公营甲板
{
私有列表List；//声明将存储卡的列表
//设置一副牌并洗牌
公共甲板
{
卡片[]卡片组=新卡片[52]；
int count=0；//卡数
//用卡片对象填充卡片组
对于（Card.Suit Suit:Card.Suit.values（））
{
对于（Card.Face:Card.Face.values（））
{
牌组[计数]=新卡（face.getRank（），suit.getOrder（））；
计数++；
}
}
list=Arrays.asList（deck）；//获取列表
//集合。洗牌（列表）；//洗牌牌组
}
//输出甲板
公共印刷卡（
{
//在两列中显示52张卡片
对于（int i=0；i

//插入排序

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);
        }
    }
}

publicstaticvoidinsertionsort（DeckOfCards[]listToSort）
{
对于（int i=0；i0；k--）
{
if（listToSort[k]

listToSort

是一个

DeckOfCards

数组。在标有

//此处代码中断的行上

您试图比较两个

DeckOfCards

对象，这在java中是做不到的（其他语言中的运算符重载允许您这样做）

不如编写一个方法，比如

.getSortValue（）

，为您提供一个排序依据的值。或者，您可以编写一些内容来比较卡中的值，如：

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

if（listToSort[k].getSuit（）.getOrder（）*13+listToSort[k].getFace（）.getOrder（）

…有点长，但我想你想做什么就做什么

注意，

*13

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

TLDR：

---

如果你想按任何其他顺序进行排序，你必须从每张卡片中找出一个值，以便进行适当的比较。正确的方法是将整副卡片拆分为套装，然后分别对每个套装进行排序。您的插入排序版本不起作用，因为排序是使用面值完成的，即ACE、2、3、4。。。我不会把这算作一副牌的分类

私有HashMap组

//扫描整个甲板

for（inti=0；i<52；++i）{

}

//现在进行排序

sort（deck.get（Suite.Aces））

sort（deck.get（Suite.Diamond））
问题在于
listToSort[k]
试图使用
比较两个DeckOfCards对象，您可以使用@4castle“我正在尝试实现不同的排序算法”，“我的类”。似乎使用现有的排序方法不是OP在这里想要的。这是否意味着我必须继承getSuit（）和getFace（）方法？调用DeckOfCards类中的另一个构造函数？由于getSuit和getFace方法是在Card类中实现的——很抱歉，我对Java没有太多经验
listToSort[k]
提供数组中“DeckOfCards”的“第k个”实例
listToSort
。这意味着您可以从排序代码所在的位置调用它的任何公共方法。构造
    `switch(cards[i]) {`

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

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

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

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;
            }
        }
    }
}