在C问题中将相同优先级的项目添加到优先级队列中

Question

我用 C 语言编写了一个优先级队列，它通过使用优先级来接受航班的乘客信息。有三个主要的机票舱位（商务舱、经济舱、标准舱），商务舱有一个特殊舱位，即“外交官”，经济舱也有“老兵”舱位。以下是输入信息列表，括号中是相应的优先级：

输入： bus_1(1)、eco_1(3)、bus_2(1)、eco_2(3)、std_1(4)、eco_3(3)、eco_4(3)、bus_3(0 )、bus_4(1)、eco_6(2)、eco_7(2)

输出： bus_3、bus_1、bus_4、bus_2、eco_7、eco_6、eco_4、eco_3、eco_2、eco_1、std_1

应该是什么： bus_3、bus_1、bus_2、bus_4、eco_6、eco_7、eco_1、eco_2、eco_3、eco_4、std_1

0 是最高优先级，4 是最低优先级。我知道我的代码不正确，但我无法找出正确的方法来编写算法以将相同的优先级项目推送到已经在队列中的项目之后。这是我的功能：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

enum classes
{
    business,
    economy,
    standard
};

struct flight
{
    char flightName[8];

    //for priority queue
    struct queueNode *rootNode;
    int hasRoot;
    int businessQueueCount, economyQueueCount, standardQueueCount;
    int totalPassengerCount;

};

struct passenger
{
    char passengerName[15];
    char flightName[8];
};

struct queueNode
{
    struct passenger passenger;
    int priority;
    struct queueNode *next;
};

struct queueNode *newQueueNode(char flightName[8], char passengerName[15], int priority)
{
    struct queueNode *temp = malloc(sizeof(struct queueNode));
    temp->priority = priority;
    temp->next = NULL;
    strcpy(temp->passenger.flightName, flightName);
    strcpy(temp->passenger.passengerName, passengerName);

    return temp;
}


void pushQueue(struct queueNode **head, char *flightName, char *passengerName, int priority)
{
    struct queueNode *start = (*head);

    struct queueNode *temp = newQueueNode(flightName, passengerName, priority);

    if ((*head)->priority > priority)
    {
        temp->next = *head;
        (*head) = temp;
    }
    else
    {
        if (start->next != NULL && start->next->priority == priority)
        {
            temp->next = start->next->next;
            start->next->next = temp;
        }
        else
        {
            while (start->next != NULL && start->next->priority < priority)
            {
                start = start->next;
            }

            temp->next = start->next;
            start->next = temp;
        }
    }
}

struct passenger peekQueue(struct queueNode **head)
{
    return (*head)->passenger;
}

void popQueue(struct queueNode **head)
{
    struct queueNode *temp = *head;
    (*head) = (*head)->next;
    free(temp);
}

int main(){

    struct flight flight_temp;
    strcpy(flight_temp.flightName, "flight1");

    flight_temp.rootNode = newQueueNode(flight_temp.flightName, "bus_1", 1);
    pushQueue(&(flight_temp.rootNode), flight_temp.flightName, "eco_1", 3);
    pushQueue(&(flight_temp.rootNode), flight_temp.flightName, "bus_2", 1);
    pushQueue(&(flight_temp.rootNode), flight_temp.flightName, "std_1", 4);
    pushQueue(&(flight_temp.rootNode), flight_temp.flightName, "eco_3", 3);
    pushQueue(&(flight_temp.rootNode), flight_temp.flightName, "bus_3", 0);
    pushQueue(&(flight_temp.rootNode), flight_temp.flightName, "bus_4", 1);
    pushQueue(&(flight_temp.rootNode), flight_temp.flightName, "eco_4", 3);

    for (size_t i = 0; i < 6; i++)
    {
        printf("%s\n", peekQueue(&(flight_temp.rootNode)).passengerName);
        popQueue(&(flight_temp.rootNode));
    }






}

提前感谢您的帮助。

Answer 1

本质上，您的pushQueue 函数正在尝试插入一个排序列表，确保如果一个相等的项目已经存在，那么新的项目会在它之后。但是你的代码中有几个问题会导致它失败。我在您的代码中添加了一些 cmets，以向您显示错误所在。

void pushQueue(struct queueNode **head, char *flightName, char *passengerName, int priority)
{
    struct queueNode *start = (*head);

    struct queueNode *temp = newQueueNode(flightName, passengerName, priority);

    if ((*head)->priority > priority)
    {
        temp->next = *head;
        (*head) = temp;
        // if you put a return statement here, then you can get rid of
        // the else. It reduces nesting and makes your code cleaner.
    }
    else
    {
        // If the new item has the same priority as what's already in the list,
        // then you insert the new item right after it. What if there were two
        // or more items with the same priority? The new one wouldn't go
        // to the end of the list.
        // This code really is just a broken special case for the else below.
        if (start->next != NULL && start->next->priority == priority)
        {
            temp->next = start->next->next;
            start->next->next = temp;
        }
        else
        {
            // You want to insert the new item after any existing items that
            // have the same priority. But your logic will stop when it finds
            // the first node that has the same priority. So the new item
            // gets inserted at the front. You need to change '<' to '<='
            while (start->next != NULL && start->next->priority < priority)
            {
                start = start->next;
            }

            temp->next = start->next;
            start->next = temp;
        }
    }
}

您可以通过组合案例来大大简化您的代码。并且还要避免像start->next->next 这样难以推理且容易出错的令人费解的表达式，从而导致尝试取消引用 NULL 指针。

void pushQueue(struct queueNode **head, char *flightName, char *passengerName, int priority)
{
    struct queueNode *currentNode = (*head);
    struct queueNode *nextNode;

    struct queueNode *newNode = newQueueNode(flightName, passengerName, priority);

    // if the new node's priority is less than the head node's priority,
    // then the new node becomes the head.    
    if ((*head)->priority > priority)
    {
        newNode->next = *head;
        (*head) = newNode;
        return;
    }

    // Traverse the list looking for the first node whose priority
    // is greater than the new node's priority.
    nextNode = currentNode->next;
    while (nextNode != NULL && nextNode->priority <= priority)
    {
        currentNode = nextNode;
        nextNode = currentNode->next;
    }
    // at this point, you want to insert your new node between
    // currentNode and nextNode
    currentNode->next = newNode;
    newNode->next = nextNode;
}

当然，你会想要测试它。我并没有真正改变你的算法：只是将你的两种特殊情况合二为一。