扑克牌排序算法
扑克牌排序是一个经典的排序问题，有多种高效的解决方案。我将介绍几种适用于扑克牌排序的算法及其实现。
基础信息
一副标准扑克牌有52张牌(不含大小王)，可以分为4种花色(♠♥♦♣)和13种点数(A,2-10,J,Q,K)。
常用排序算法
1. 计数排序 (Counting Sort)
计数排序特别适合扑克牌排序，因为扑克牌的值域有限且已知。
python
def poker_counting_sort(cards):
使用计数排序对扑克牌排序
排序规则：先按花色(♠
# 创建花色和点数的映射
suit_order = {'♠': 0, '♥': 1, '♦': 2, '♣': 3}
aapoker官方下载中心rank_order = {'A': 0, '2': 1, '3': 2, '4': 3, '5': 4,
'6': 5, '7': 6, '8': 7, '9': 8,
'10': 9, 'J': 10, 'Q': 11, 'K': 12}
# 创建计数数组 (4花色 × 13点数)
count = [[[] for _ in range(13)] for _ in range(4)]
# 计数阶段
for card in cards:
suit = card['suit']
rank = card['rank']
suit_idx = suit_order[suit]
rank_idx = rank_order[rank]
count[suit_idx][rank_idx].append(card)
# 收集结果
result = []
for i in range(4):
for j in range(13):
result.extend(count[i][j])
return result
2. 基数排序 (Radix Sort)
基数排序也很适合扑克牌，可以按花色和点数分别作为两个"位"进行排序。
python
def poker_radix_sort(cards):
使用基数排序对扑克牌排序
先按点数排序，再按花色排序(稳定排序保持点数顺序)
if not cards:
return []
# 先按点数排序
rank_order = {'A': 0, '2': 1, '3': 2, '4': 3, '5': 4,
'6': 5, '7': 6, '8': 7, '9': 8,
'10': 9, 'J': 10, 'Q': 11, 'K': 12}
# 使用稳定的排序算法先按点数排序
cards_sorted_by_rank = sorted = sorted(cards, key=lambda x: rank_order[x['rank']])
# 再按花色排序(稳定排序)
suit_order = {'♠': 0, '♥': 1, '♦': 2, '♣': 3}
result = sorted(cards_sorted_by_rank, key=lambda x: suit_order[x['suit']])
return result
3. 桶排序 (Bucket Sort)
利用扑克牌有限的值域特点，可以使用桶排序。
python
def poker_bucket_sort(cards):
使用桶排序对扑克牌排序
suit_order = {'♠': 0, '♥': 1, '♦': 2, '♣': 3}
rank_order = {'A': 0, '2': 1, '3': 2, '4': 3, '5': 4,
'6': 5, '7': 6, '8': 7, '9': 8,
'10': 9, 'J': 10, 'Q': 11, 'K': 12}
# 创建桶 (总共52个位置)
buckets = [[] for _ in range(52)]
# 分配到桶中
for card in cards:
suit_idx = suit_order[card['suit']]
rank_idx = rank_order[card['rank']]
bucket_idx = suit_idx * 13 + rank_idx
buckets[bucket_idx].append(card)
# 收集结果
result = []
for bucket in buckets:
result.extend(bucket)
return result
4. 自定义比较函数的快速排序
python
def poker_quick_sort(cards):
使用自定义比较函数的快速排序
suit_order = {'♠': 0, '♥': 1, '♦': 2, '♣': 3}
rank_order = {'A': 0, '2': 1, '3': 2, '4': 3, '5': 4,
'6': 5, '7': 6, '8': 7, '9': 8,
'10': 9, 'J': 10, 'Q': 11, 'K': 12}
def compare(card1, card2):
# 先比较花色
suit1_val = suit_order[card1['suit']]
suit2_val = suit_order[card2['suit']]
if suit1_val != suit2_val:
return suit1_val
# 花色相同则比较点数
rank1_val = rank_order[card1['rank']]
rank2_val = rank_order[card2['rank']]
return rank1_val
def quick_sort_helper(arr):
if len(arr)
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if compare(x, pivot)
middle = [x for x in arr if compare(x, pivot) == 0]
right = [x for x in arr if compare(x, pivot) > 0]
return quick_sort_helper(left) + middle + quick_sort_helper(right)
return quick_sort_helper(cards)
测试示例
python
# 测试数据
test_cards = [
{'suit': '♥', 'rank': '5'},
{'suit': '♠', 'rank': 'A'},
{'suit': '♦', 'rank': '10'},
{'suit': '♣', 'rank': 'K'},
{'suit': '♠', 'rank': '2'},
{'suit': '♥', 'rank': 'J'}
# 测试各种排序算法
print("原始牌:", test_cards)
print("计数排序:", poker_counting_sort(test_cards))
print("基数排序:", poker_radix_sort(test_cards))
print("桶排序:", poker_bucket_sort(test_cards))
print("快速排序:", poker_quick_sort(test_cards))
性能分析
| 算法 | 时间复杂度 | 空间复杂度 | 稳定性 | 适用场景 |
||||--|-|
| 计数排序 | O(n+k) | O(k) | 稳定 | 值域有限的场景 |
| 基数排序 | O(d×(n+k)) | O(n+k) | 稳定 | 多关键字排序 |
| 桶排序 | O(n+k) | O(n+k) | 稳定 | 均匀分布的数据 |
| 快速排序 | O(n log n) | O(log n) | 不稳定 | 通用场景 |
对于扑克牌排序，计数排序通常是最高效的选择，因为：
1. 值域完全域完全已知且有限
2. 时间复杂度为线性 O(n)
3. 空间开销固定且可控
这些算法都可以根据具体游戏规则(如某些游戏中A最大)轻松调整排序顺序。
