优先级队列实现为单链接无法更新插入时的指针引用

Question

Question Edited: How can I insert into my linked list while keeping pointer references as arguments? My updated code is as follows:

Note: I have a copy of the queue which was used in inserting a given node into the correct spot however I'm not seeing anyway to update the original queue as there no way to link the previous nodes.

Resolved: Working priority queue (FIFO) - Needs cleaning

#define QUEUE_HEAD_INDICATOR 0.0

namespace
{
    pq* create_node(float priority = 0, const string & text = "")
    {
        pq* q = new pq;
        q->priority = priority;
        q->text = text;
        q->next = nullptr;
        return q;
    }
}

pq* init_priority_queue() {
    return create_node(QUEUE_HEAD_INDICATOR);
}


void insert(pq* &queue, string text, float priority) {
    if (!queue) return;

    pq* prev = queue;
    pq* cursor = queue->next;
    int offset = 0;

    if(prev->priority == 0.0 && prev->text == "") {
        prev->priority = priority;
        prev->text = text;
        return;
    }
    if(!cursor) {
        if(prev->priority > priority) {
            pq* node = create_node(priority, text);
            node->next = prev;
            prev = node;
        } else {
            pq* node = create_node(priority, text);
            prev->next = node;
        }
    } else {
        while(cursor && cursor->priority < priority) {
            prev = cursor;
            cursor = cursor->next;
            offset++;
        }
        pq* node = create_node(priority, text);
        if(offset == 0) {
            if(cursor->priority == (int)node->priority) {
                node->next = prev->next;
                prev->next = node;
                queue = prev;
            } else {
                node->next = prev;
                prev = node;
                queue = prev;
            }
        } else if(!cursor) {
            prev->next = node;
        } else {
            node->next = prev->next;
            prev->next = node;
        }
        return;
    }
}


string remove(pq* &queue) {
    pq* prev = queue;
    pq* cursor = queue->next;

    if(!queue->next) {
        string text = queue->text;
        prev = NULL;
        return text;
    }

    while(cursor->next) {
        prev = cursor;
        cursor = cursor->next;
    }

    prev->next = NULL;
    string text = cursor->text;
    return text;
}

Here is what the struct looks like

struct pq {
    float priority;
    string text;
    pq* next;
};

Answer 1

The assignment queue = new_node assigns the argument of the insert function, but not the pointer in the middle of the linked list (which is the next member variable of the previous element).

    pq* qp = new pq;
    insert(qp, "0.1", 0.1f);
    // qp -> 0.1
    insert(qp, "0.3", 0.3f);
    // qp -> 0.1 -> 0.3
    insert(qp, "0.2", 0.2f);
    // qp -> 0.2 -> 0.3
    // qp now points to the 0.2 element, leaving the 0.1 element inaccessible

Also your function never compares the priority of the first element with the priority of the element to be inserted for queues with a length > 1. Your while loop only compares the priority of the element to be inserted to the priorities of the elements beyond the first element.

Answer 2

I need to make an assumption here: queue is a reference to a pointer to the head node of a linked list. This seems a reasonable assumption because of the way it is used in the if(queue->next == NULL) case.

The following code will overwrite the pointer to the head node, and subsequently every other node, leaking it.

while(queue->next && queue->next->key < priority) {
    queue = queue->next; // bam! previous node leaked back at the caller
}

You could use a copy of the head node, but... There are much better ways to handle this.

My recommendation is to not pass pointer to a root node. Pass a pointer to the pointer to it. This handles the head case by making the head look exactly like every other node and eliminates most of the code. Since we're always keeping a pointer to the previous node's next we have easy access to the insertion point for a new node and the next node.

You cannot do this trick with a reference because a reference cannot be reassigned.

Example:

#include <string>
#include <iostream>

// my best guess at what pq looks like
struct pq
{
    pq* next;
    std::string text;
    float key;
};

void insert(pq ** queue, // cannot reseat ref, so pointer required
            const std::string &text, // ref eliminates copy.
                                     // const because we don't want to change
            float priority) {
    while((*queue) && // search while more queues
            (*queue)->key < priority) // and priority is low
    {
        queue = &(*queue)->next;
    }
    *queue = new pq{*queue, // if queue is null, end of list, if not inserted in middle
                    text, 
                    priority}; 
}

// Demo
int main()
{
    pq * queue = NULL;

    insert(&queue, "c", 5);
    insert(&queue, "a", 1);
    insert(&queue, "b", 2.5);
    insert(&queue, "e", 10);
    insert(&queue, "d", 7.5);

    // print and clean-up.
    while (queue)
    {
        std::cout << queue->text << std::endl;
        pq * temp = queue; // temp so we don't lose queue
        queue = queue->next;
        delete temp; // release node
    }
}