zoukankan      html  css  js  c++  java

  • 【转载】斗地主算法的设计与实现–对牌进行排序

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

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

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

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

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

      

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

        if (id < 1 || id > 54) {
            throw new RuntimeException("牌的数字不合法");
        } 

        int grade = 0; 

        // 2个王必须放在前边判断
        if (id == 53) {
            grade = 16;
        } else if (id == 54) {
            grade = 17;
        } 

        else {
            int modResult = id % 13; 

            if (modResult == 1) {
                grade = 14;
            } else if (modResult == 2) {
                grade = 15;
            } else if (modResult == 3) {
                grade = 3;
            } else if (modResult == 4) {
                grade = 4;
            } else if (modResult == 5) {
                grade = 5;
            } else if (modResult == 6) {
                grade = 6;
            } else if (modResult == 7) {
                grade = 7;
            } else if (modResult == 8) {
                grade = 8;
            } else if (modResult == 9) {
                grade = 9;
            } else if (modResult == 10) {
                grade = 10;
            } else if (modResult == 11) {
                grade = 11;
            } else if (modResult == 12) {
                grade = 12;
            } else if (modResult == 0) {
                grade = 13;
            } 

        } 

        return grade;
    }

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

      

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

        int size = cards.size();
        // 冒泡排序,从左到右，从小到大
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size – i – 1; j++) {
                int gradeOne = cards.get(j).grade;
                int gradeTwo = cards.get(j + 1).grade; 

                boolean isExchange = false;
                if (gradeOne > gradeTwo) {
                    isExchange = true;
                } else if (gradeOne == gradeTwo) {
                    // 2张牌的grade相同
                    CardBigType type1 = cards.get(j).bigType;
                    CardBigType type2 = cards.get(j + 1).bigType; 

                    // 从做到右，方块、梅花、红桃、黑桃
                    if (type1.equals(CardBigType.HEI_TAO)) {
                        isExchange = true;
                    } else if (type1.equals(CardBigType.HONG_TAO)) {
                        if (type2.equals(CardBigType.MEI_HUA)
                                || type2.equals(CardBigType.FANG_KUAI)) {
                            isExchange = true;
                        }
                    } else if (type1.equals(CardBigType.MEI_HUA)) {
                        if (type2.equals(CardBigType.FANG_KUAI)) {
                            isExchange = true;
                        }
                    }
                } 

                if (isExchange) {
                    Card cardOne = cards.get(j);
                    Card cardTwo = cards.get(j + 1);
                    // 交换
                    cards.set(j + 1, cardOne);
                    cards.set(j, cardTwo);
                }
            }
        }
        return true;
    }

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

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

public class CardComparator implements Comparator<Card> { 

    public int compare(Card card1, Card card2) {
        int result = -1; 

        int grade1 = card1.grade;
        int grade2 = card2.grade; 

        if (grade1 > grade2) {
            result = 1;
        } else if (grade1 < grade2) {
            result = -1;
        } else {
            // 等级相同的情况，比如都是9
            CardBigType bigType1 = card1.bigType;
            CardBigType bigType2 = card2.bigType;
            // 从左到右，方块、梅花、红桃、黑桃
            if (bigType1.equals(CardBigType.HEI_TAO)) {
                result = 1;
            } else if (bigType1.equals(CardBigType.HONG_TAO)) {
                if (bigType2.equals(CardBigType.MEI_HUA)
                        || bigType2.equals(CardBigType.FANG_KUAI)) {
                    result = 1;
                }
            } else if (bigType1.equals(CardBigType.MEI_HUA)) {
                if (bigType2.equals(CardBigType.FANG_KUAI)) {
                    result = 1;
                }
            }
            // 2张牌的等级不可能完全相同,程序内部采用这种设计
            else {
                result = -1;
            }
        } 

        return result;
    } 

}

    相关阅读：

    斗地主算法的设计与实现–项目介绍&如何定义和构造一张牌

    斗地主算法的设计与实现–如何判断一手牌的类型(单,对子,三不带,三带一,四代二等)

    斗地主算法的设计与实现–如何比较两手牌的大小

  • 相关阅读:
    数据结构学习8——二叉树的销毁
    单链表的反向
    LNK4098: 默认库“MSVCRT”与其他库的使用冲突
    动态链接库(VC_Win32)
    注册表操作(VC_Win32)
    消息钩子与定时器(VC_Win32)
    套接字编程(VC_Win32)
    线程概述,优先级,睡眠,创建及终止(VC_Win32)
    进程通信(VC_Win32)
    进程概述及创建,终止(VC_Win32)
  • 原文地址：https://www.cnblogs.com/net2012/p/3364947.html
Copyright © 2011-2022 走看看