扑克牌排序

一、扑克牌排序

1、poke结构体

typedef struct {
    char a;
    int b;
}poke;

其中a存储卡牌花色A、B、C、D；b存储卡牌数字1~9。

2、数组型队列

queue<poke> color[5];
queue<poke> number[10];
queue<poke> sorted;

使用#include<queue>建立poke类型的数组型队列，每一组中都是一个队列。

其中number以数字为顺序存储卡牌，color以花色为顺序存储卡牌，number和color队列数组为0时均不用(用或不用都行)。sorted为最后排序完整理的队列(非数组型)。

二、算法思想

先建立9个队列，用于存放点数的大小，将卡牌依点数存放入各自的队列之中，然后再按队列1到队列9依次出队。
例如，对于上面的结果，依次进队后，结果如下：
队列1：C1；队列3：D3，队列4：C4，A4
将其依次出队后，结果为C1，D3，C4，A4
然后，再建立4个队列，用于存放花色。将卡牌依花色A～D存放入队列1～4中，然后再按队列1到队列4依次出队。
例如，对于上面刚刚出队的序列C1，D3，C4，A4，将其依次进队，结果如下：
队列1：A4；队列3：C1，C4；队列4：D3
将其依次出队后，结果为A4，C1，C4，D3，排序结束。

伪代码

1. 输入n；
2. 循环n次；
    2.1 输入p.a，输入p.b；
    2.2 将p放入第p.b个数字队
3. i从1循环到9
    3.1 循环到数字i队为空
        3.1.1 p = number[i].front();
        3.1.2 color[p.a - 'A' + 1].push(p);
        3.1.3 number[i].pop();
4.i从1循环到4
    4.1 循环到花色i队为空
        4.1.1 p = color[i].front();
        4.1.2 sorted.push(p);
        4.1.3 color[i].pop();
5.输出sorted

三、时间复杂度&空间复杂度

1、时间复杂度

如果给出的排序已排序好了，那么要经过n次的输入数据，9n次将数据归入数字队，4n次将数据归入花色队，再输出sorted，所以时间复杂度为O(n)。

如果给出的排序为乱序，其过程与正序相同，时间复杂度仍是O(n)。

2、空间复杂度

空间复杂度为O(1)。

3、相比冒泡排序

(1)时间复杂度：冒泡排序的最好时间复杂度为O(n)，最坏时间复杂度为O(n^2)，而该算法的时间复杂度为O(n)。

(2)空间复杂度：都是O(1)。

四、代码展示

#include<iostream>
#include<queue>

using namespace std;

typedef struct {
    char a;
    int b;
}poke;

int main()
{
    queue<poke> color[5];
    queue<poke> number[10];
    poke p;
    int n;
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> p.a >> p.b;
        number[p.b].push(p);
    }
    for (int i = 1; i <= 9; i++) {
        cout << "Queue" << i << ":";
        while (!number[i].empty()) {
            p = number[i].front();
            cout << p.a << p.b << " ";
            color[p.a - 'A' + 1].push(p);
            number[i].pop();
        }
        cout << "\n";
    }
    queue<poke> sorted;
    for (int i = 1; i <= 4; i++) {
        cout << "Queue" << char('A' + i - 1) << ":";
        while (!color[i].empty()) {
            p = color[i].front();
            cout << p.a << p.b << " ";
            sorted.push(p);
            color[i].pop();
        }
        cout << "\n";
    }
    while (!sorted.empty()) {
        p = sorted.front();
        cout << p.a << p.b << " ";
        sorted.pop();
    }
    return 0;
}

输入案例如题，输出如图：

五、总结

数组型队列的使用大大降低该题的复杂程度，虽然可以复用number数组来存储花色但是容易混淆，使用数组型队伍的难点是数组的每一个都是一个队，且队的元素都是结构体poke，初始理解时没有那么清楚。

猜你喜欢