火车车厢重排——队列实现

其实队列和栈挺像的，所以也就没有单独写一个实现队列的笔记，可以参考一下栈的实现：https://www.cnblogs.com/2015-16/p/12957964.html    （同时这一篇也包含了队列的一些基本使用）

队列，简称队，也是一种操作受限的线性表。把进行插入的一端称做队尾（rear），进行删除的一端称做队头（front）；（先进先出表）

环形队列：简而言之，在顺序队列中，我们删除元素，并没有真正删除，只是把front指针前进，那么两个指针都往前，后面自然会空出许多单元，这样就浪费了，我们采用环形队列，在逻辑上把一个数组掰弯，形成一个圆，让rear指到数组顶点之后可以回过头来，再次指向最开始的单元，这样就可以利用那些空间；

环形队列通常约定进队时少用一个数据元素空间，队满条件：（q->rear+1）% MaxSize == q->front  ；队空条件：q->rear == q->front  ；

队中元素个数：（rear-front+MaxSize）% MaxSize   ；

**********************************************************************

题目来了：火车轨道重排 

问题分析：分析题目意思我们可以大致得到，我们需要利用缓冲轨导，实现对车厢的排序。车厢排序有这样的特点，首先是，车厢数从1-n,是连续的数字，其次我们需要按照从小到大的顺序，一个一个的输出，可供我们选择缓冲轨道，但是，假设如果我现在车厢数目改变，或者说车厢数字顺序改变，那我们相应的，所需要的轨道数数目也可能改变。我设计了一个动态的轨道数目来解决这个问题。首先需要按照合适的格式，把我们需要重排的车厢数序列放入队列中，之后逐步的输出车厢数。即先考虑主轨，如果主轨不能（主轨目前可以输出的数字不是我想要的），那便考虑缓冲轨道，如果缓冲轨道也不能，那就是说明，我们需要的车厢，还在主轨的后边，我们便需要把主轨的前面的车厢分散进入缓冲轨道，以此实现输出。

void Rearrangment_Queue(Queue *& Q, int G_number) {
    int nowOut = 1, i, temp, Sign;            // 缓冲轨导数标记 G_number 
    Queue ** kq = new Queue *[G_number];    // 数组指针 
    for (i = 0; i < G_number; i++)
        Initialize_Queue(kq[i], Q->number);    // 缓冲轨导初始化 
    while (nowOut <= Q->number) {        // 入轨判断 
        Sign = 0;                            // 标记符Sign
        if (Empty_Queue(Q) && Q->data[Q->front + 1] == nowOut) {
            cout << nowOut << " ";
            nowOut++;
            Q->front++;
            Sign++;                            // 标记符Sign
        }
        for (i = 0; i < G_number; i++)    // 缓冲轨判断 
            if (Empty_Queue(kq[i]) && kq[i]->data[kq[i]->front + 1] == nowOut) {
                cout << nowOut << " ";        // 缓冲轨非空(1)情况下进行匹配 
                nowOut++;
                kq[i]->front++;
                Sign++;                        // 标记符Sign
            }
        if (!Sign) {                    // 缓冲轨生成    
            int j = 0;
            while (Q->data[Q->front + 1] != nowOut) {
                Out_Queue(Q, temp);
                if (kq[j]->data[kq[j]->rear] < temp)
                    Enter_Queue(kq[j], temp);
                else                        // 同G_number
                    Enter_Queue(kq[++j], temp);
            }
        }
    }
    cout << endl;
    for (i = 0; i < G_number; i++)            // 缓冲轨删除
        Destroy_Queue(kq[i]);
    delete [] kq;
}

kq用来存放若干个缓冲轨，nowOut是目前需要输出的数字；

先处理主轨，再处理缓冲轨，最后，若均没有对应数字，则需要完成主轨和缓冲轨数字的变换；

当然还需要很多其余队列相关函数：初始化、销毁、进队、出队、判空以及创建队列和G_number求解；

#include<iostream>
#include<cstdlib>

using namespace std;

struct Queue {
    int * data;
    int number;            // 车箱数 
    int front, rear;
};
                        // 初始化
void Initialize_Queue(Queue *& Q, int number) {    
    Q = (Queue *)malloc(sizeof(Queue));
    Q->number = number;            // 车厢数固定
    Q->data = new int[Q->number];
    Q->data[0] = 0;                // 确保后序判断需要
    Q->front = Q->rear = -1;
}
                        // 销毁
void Destroy_Queue(Queue *& Q) {
    delete[] Q->data;
    free(Q);
}
                        // 进队
void Enter_Queue(Queue *& Q, int e) {
    Q->rear++;
    Q->data[Q->rear] = e;
}
                        // 出队
void Out_Queue(Queue *& Q, int & e) {
    Q->front++;
    e = Q->data[Q->front];
}
                        // 判空
bool Empty_Queue(Queue * Q) {        // 空 = 0 ，非空 = 1
    return (!(Q->front == Q->rear));     
}
                        // 创建以及G_number
int Create_Queue(Queue *& Q) {
    int i, e, G_number = 0;        // 缓冲轨导数
    cout << "请输入待重排的车厢序列 ：";
    Q->rear = Q->number - 1;
    for (i = Q->number; i > 0; i--) {
        cin >> e;
        Q->data[i - 1] = e;
        if (i < Q->number && Q->data[i - 1] > Q->data[i])
            G_number++;            // 按最大所需轨道数计算
    }                            // 可能实际所需轨道数少于此数
    return G_number;            // 但是方便
}

void Rearrangment_Queue(Queue *& Q, int G_number) {
    int nowOut = 1, i, temp, Sign;            // 缓冲轨导数标记 G_number 
    Queue ** kq = new Queue *[G_number];    // 数组指针 
    for (i = 0; i < G_number; i++)
        Initialize_Queue(kq[i], Q->number);    // 缓冲轨导初始化 
    while (nowOut <= Q->number) {        // 入轨判断 
        Sign = 0;                            // 标记符Sign
        if (Empty_Queue(Q) && Q->data[Q->front + 1] == nowOut) {
            cout << nowOut << " ";
            nowOut++;
            Q->front++;
            Sign++;                            // 标记符Sign
        }
        for (i = 0; i < G_number; i++)    // 缓冲轨判断 
            if (Empty_Queue(kq[i]) && kq[i]->data[kq[i]->front + 1] == nowOut) {
                cout << nowOut << " ";        // 缓冲轨非空(1)情况下进行匹配 
                nowOut++;
                kq[i]->front++;
                Sign++;                        // 标记符Sign
            }
        if (!Sign) {                    // 缓冲轨生成    
            int j = 0;
            while (Q->data[Q->front + 1] != nowOut) {
                Out_Queue(Q, temp);
                if (kq[j]->data[kq[j]->rear] < temp)
                    Enter_Queue(kq[j], temp);
                else                        // 同G_number
                    Enter_Queue(kq[++j], temp);
            }
        }
    }
    cout << endl;
    for (i = 0; i < G_number; i++)            // 缓冲轨删除
        Destroy_Queue(kq[i]);
    delete [] kq;
}

int main()
{
    Queue * Q;
    int G_number, number;
    cout << "请输入最大车厢数 number ：";
    cin >> number;
    Initialize_Queue(Q, number);
    G_number = Create_Queue(Q);
    cout << "火车车厢重排后 ：";
    Rearrangment_Queue(Q, G_number);
    Destroy_Queue(Q);
    return 0;
}

对于这样一个问题似乎也可以修改为一个利用队列进行排序的算法，但是对于空间方面的要求着实过大，理论上感觉还是可以的；

2020-05-25