斗地主算法的设计与实现–对牌进行排序

在判断牌的类型的时候,比如判断387654的牌型的时候,需要首先对牌进行排序,这样才能判断这6张牌是个顺子。

本篇简要介绍下 如何对一手牌或很多牌进行排序。

在前几篇定义牌Card的属性的时候,有个grade字段,这个字段就是用来对牌进行比较和排序的。

比如大王的grade是17,小王的grade是16,这样大王>小王,其它单张牌的比较是类似的。

1.根据牌的id,获得一张牌的等级

[java][/java]

view plaincopy

  1. /**
  2.     * 根据牌的id,获得一张牌的等级
  3.     *
  4.     * @param id
  5.     *            牌的id
  6.     * @return 与牌数字对应的等级
  7.     */
  8.    public static int getGrade(int id) {
  9.        if (id < 1 || id > 54) {
  10.            throw new RuntimeException(“牌的数字不合法”);
  11.        }
  12.        int grade = 0;
  13.        // 2个王必须放在前边判断
  14.        if (id == 53) {
  15.            grade = 16;
  16.        } else if (id == 54) {
  17.            grade = 17;
  18.        }
  19.        else {
  20.            int modResult = id % 13;
  21.            if (modResult == 1) {
  22.                grade = 14;
  23.            } else if (modResult == 2) {
  24.                grade = 15;
  25.            } else if (modResult == 3) {
  26.                grade = 3;
  27.            } else if (modResult == 4) {
  28.                grade = 4;
  29.            } else if (modResult == 5) {
  30.                grade = 5;
  31.            } else if (modResult == 6) {
  32.                grade = 6;
  33.            } else if (modResult == 7) {
  34.                grade = 7;
  35.            } else if (modResult == 8) {
  36.                grade = 8;
  37.            } else if (modResult == 9) {
  38.                grade = 9;
  39.            } else if (modResult == 10) {
  40.                grade = 10;
  41.            } else if (modResult == 11) {
  42.                grade = 11;
  43.            } else if (modResult == 12) {
  44.                grade = 12;
  45.            } else if (modResult == 0) {
  46.                grade = 13;
  47.            }
  48.        }
  49.        return grade;
  50.    }

2.对牌进行排序,从小到大,使用冒泡排序

[java][/java]

view plaincopy

  1. /**
  2.      * 对牌进行排序,从小到大,使用冒泡排序,此种方法不是很好
  3.      *
  4.      * @param cards
  5.      *            牌
  6.      */
  7.     public static boolean bubbleSortCards(List<Card> cards) {
  8.         if (cards == null) {
  9.             return false;
  10.         }
  11.         int size = cards.size();
  12.         // 冒泡排序,从左到右,从小到大
  13.         for (int i = 0; i < size; i++) {
  14.             for (int j = 0; j < size – i – 1; j++) {
  15.                 int gradeOne = cards.get(j).grade;
  16.                 int gradeTwo = cards.get(j + 1).grade;
  17.                 boolean isExchange = false;
  18.                 if (gradeOne > gradeTwo) {
  19.                     isExchange = true;
  20.                 } else if (gradeOne == gradeTwo) {
  21.                     // 2张牌的grade相同
  22.                     CardBigType type1 = cards.get(j).bigType;
  23.                     CardBigType type2 = cards.get(j + 1).bigType;
  24.                     // 从做到右,方块、梅花、红桃、黑桃
  25.                     if (type1.equals(CardBigType.HEI_TAO)) {
  26.                         isExchange = true;
  27.                     } else if (type1.equals(CardBigType.HONG_TAO)) {
  28.                         if (type2.equals(CardBigType.MEI_HUA)
  29.                                 || type2.equals(CardBigType.FANG_KUAI)) {
  30.                             isExchange = true;
  31.                         }
  32.                     } else if (type1.equals(CardBigType.MEI_HUA)) {
  33.                         if (type2.equals(CardBigType.FANG_KUAI)) {
  34.                             isExchange = true;
  35.                         }
  36.                     }
  37.                 }
  38.                 if (isExchange) {
  39.                     Card cardOne = cards.get(j);
  40.                     Card cardTwo = cards.get(j + 1);
  41.                     // 交换
  42.                     cards.set(j + 1, cardOne);
  43.                     cards.set(j, cardTwo);
  44.                 }
  45.             }
  46.         }
  47.         return true;
  48.     }

3.使用JDK自带的类库进行排序

[java][/java]

view plaincopy

  1.   /**
  2.      * 对牌进行排序,从小到大,比较器为CardComparator
  3.      *
  4.      * @param cards
  5.      *            牌的集合
  6.      */
  7.     public static void sortCards(List<Card> cards) {
  8.         // 策略模式;复用已有类;
  9.         Collections.sort(cards, new CardComparator());
  10.     }
  11. public class CardComparator implements Comparator<Card> {
  12.     public int compare(Card card1, Card card2) {
  13.         int result = -1;
  14.         int grade1 = card1.grade;
  15.         int grade2 = card2.grade;
  16.         if (grade1 > grade2) {
  17.             result = 1;
  18.         } else if (grade1 < grade2) {
  19.             result = -1;
  20.         } else {
  21.             // 等级相同的情况,比如都是9
  22.             CardBigType bigType1 = card1.bigType;
  23.             CardBigType bigType2 = card2.bigType;
  24.             // 从左到右,方块、梅花、红桃、黑桃
  25.             if (bigType1.equals(CardBigType.HEI_TAO)) {
  26.                 result = 1;
  27.             } else if (bigType1.equals(CardBigType.HONG_TAO)) {
  28.                 if (bigType2.equals(CardBigType.MEI_HUA)
  29.                         || bigType2.equals(CardBigType.FANG_KUAI)) {
  30.                     result = 1;
  31.                 }
  32.             } else if (bigType1.equals(CardBigType.MEI_HUA)) {
  33.                 if (bigType2.equals(CardBigType.FANG_KUAI)) {
  34.                     result = 1;
  35.                 }
  36.             }
  37.             // 2张牌的等级不可能完全相同,程序内部采用这种设计
  38.             else {
  39.                 result = -1;
  40.             }
  41.         }
  42.         return result;
  43.     }
  44. }

标签