【数据结构】：链表实现洗牌功能

此操作包含的基本功能有：

1. 组牌：组建 52 张扑克牌

• 四种花色：“♥️”，“♠️”，“⬛️”，“♣️”
• 每种花色 13 张牌：1~13

2. 洗牌：将 52 张扑克牌打乱顺序
3. 发牌：给三个人每人发 5 张牌

---

扩展功能：

• 清牌：将每人手中牌按照面值进行从大到小排序

Card 类

在此类中，我们将完成对每一张牌的构造

• 类中含有成员变量

  • 花色：suit
  • 面值：rank

• 带有一个含参的构造方法，用来之后传入对应参数进行新牌的构造

• 重写 toString() 方法，让输出的结果更美观

public class Card {
    public int rank;
    public String suit;

    public Card(int rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }


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

CardBox 类

所有的功能都将在这个类中进行具体地实现

组牌

组建 52 张牌：List<Card> buildCard()

1. 创建一个容量为 52，接收对象为 Card 的链表 cardList
2. 两个 for 循环，为 Card 类里面的两个成员变量造值
3. 随后依次为 Card 类实例化对象，将两个成员变量传入 Card 的构造方法中，创造出一张牌
4. 最后依次将实例化出来的对象加入链表

public class CardBox {
    public static final String[] suits = {"♥️", "♠️", "⬛️", "♣️"};

    public static List<Card> makeCard() {
        List<Card> cardList = new ArrayList<>(52);
        for (int i = 0; i < 4; i++) {
            for (int j = 1; j <= 13; j++) {
                int rank = j;
                String suit = suits[i];
                Card card = new Card(rank, suit);
                cardList.add(card);
            }
        }
        return cardList;
    }
}

洗牌

运用下标交换进行牌的打乱：void shuffle(List<Card> cardList)

1. 使用随机数函数 Random 进行下标交换匹配，用随机数函数创造一个范围内的下标 randomIndex
2. 再让随机数 randomIndex 下标在顺序表中对应的牌与目标牌进行交换
3. 交换需要用到一个自定义函数：void swap(List<Card> cardList, int i, int j)
   • 此函数对 cardList 链表进行操作，将其中 i 位置的数据与 j 位置的数据进行交换

 public static void shuffle(List<Card> cardList) {
    for (int i = cardList.size() - 1; i > 0; i--) {
        int randomIndex = new Random().nextInt(i);
        swap(cardList,randomIndex,i);
    }
}

private static void swap(List<Card> cardList, int i, int j){
    Card tmp = cardList.get(i);
    cardList.set(i,cardList.get(j));
    cardList.set(j,tmp);
}

发牌

将牌分发给三个人：void drawCard (List<Card> cardList)

1. 为四个人创建三个 Card 类型的链表，就相当于是“他们的手”，用来拿他们发到的牌
2. 再创建一个以“他们的手”为类型的链表，就相当于是“发牌人的手”，用来将发好的牌堆发给他们
3. 发牌的原理是依次移走下标为 0 的那张牌

public void drawCard (List<Card> cardList) {
    List<Card> hand1 = new ArrayList<>();
    List<Card> hand2 = new ArrayList<>();
    List<Card> hand3 = new ArrayList<>();

    List<List<Card>> hands = new ArrayList<>();
    hands.add(hand1);
    hands.add(hand2);
    hands.add(hand3);

    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 3; j++) {
            hands.get(j).add(cardList.remove(0));
        }
    }
}

扩展：清牌

在发牌之后，将每人手中牌按照面值进行从大到小排序：

1. 重写 Collection 接口中的 sort() 方法
2. 在参数中直接传入一个用来排序链表的比较器

public void drawCard (List<Card> cardList){
    List<Card> hand1 = new ArrayList<>();
    List<Card> hand2 = new ArrayList<>();
    List<Card> hand3 = new ArrayList<>();

    List<List<Card>> hands = new ArrayList<>();
    hands.add(hand1);
    hands.add(hand2);
    hands.add(hand3);

    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 3; j++) {
            hands.get(j).add(cardList.remove(0));
        }
    }
    for (int i = 0; i < 3; i++) {
        Collections.sort(hands.get(i), new Comparator<Card>() {
            @Override
            public int compare(Card o1, Card o2) {
                return o1.rank - o2.rank;
            }
        });

    }

    System.out.println("第一个人的牌"+hand1);
    System.out.println("第二个人的牌"+hand2);
    System.out.println("第三个人的牌"+hand3);
}

运行结果