使用双向链表的优先队列

给定具有优先级的节点，使用双向链表实现优先级队列。

先决条件：优先队列

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。

• push()：该函数用于向队列中插入新数据。
• pop()：该函数从队列中移除具有最低优先级值的元素。
• peek() / top()：该函数用于获取队列中优先级最低的元素，而不将其从队列中移除。

方法 ：

1. 创建一个双向链表，包含字段 info（保存节点的信息）、priority（保存节点的优先级）、prev（指向上一个节点）、next（指向下一个节点）。
2. 在节点中插入元素和优先级。
3. 按优先级递增的顺序排列节点。

下面是上述步骤的实现：

C++

// C++ code to implement priority
// queue using doubly linked list
#include 
using namespace std;
 
// Linked List Node
struct Node {
    int info;
    int priority;
    struct Node *prev, *next;
};
 
// Function to insert a new Node
void push(Node** fr, Node** rr, int n, int p)
{
    Node* news = (Node*)malloc(sizeof(Node));
    news->info = n;
    news->priority = p;
 
    // If linked list is empty
    if (*fr == NULL) {
        *fr = news;
        *rr = news;
        news->next = NULL;
    }
    else {
        // If p is less than or equal front
        // node's priority, then insert at
        // the front.
        if (p <= (*fr)->priority) {
            news->next = *fr;
            (*fr)->prev = news->next;
            *fr = news;
        }
 
        // If p is more rear node's priority,
        // then insert after the rear.
        else if (p > (*rr)->priority) {
            news->next = NULL;
            (*rr)->next = news;
            news->prev = (*rr)->next;
            *rr = news;
        }
 
        // Handle other cases
        else {
 
            // Find position where we need to
            // insert.
            Node* start = (*fr)->next;
            while (start->priority > p)
                start = start->next;
            (start->prev)->next = news;
            news->next = start->prev;
            news->prev = (start->prev)->next;
            start->prev = news->next;
        }
    }
}
 
// Return the value at rear
int peek(Node* fr) { return fr->info; }
 
bool isEmpty(Node* fr) { return (fr == NULL); }
 
// Removes the element with the
// least priority value form the list
int pop(Node** fr, Node** rr)
{
    Node* temp = *fr;
    int res = temp->info;
    (*fr) = (*fr)->next;
    free(temp);
    if (*fr == NULL)
        *rr = NULL;
    return res;
}
 
// Driver code
int main()
{
    Node *front = NULL, *rear = NULL;
    push(&front, &rear, 2, 3);
    push(&front, &rear, 3, 4);
    push(&front, &rear, 4, 5);
    push(&front, &rear, 5, 6);
    push(&front, &rear, 6, 7);
    push(&front, &rear, 1, 2);
 
    cout << pop(&front, &rear) << endl;
    cout << peek(front);
 
    return 0;
}

C

// C code to implement priority
// queue using doubly linked list
#include 
#include 
 
// Linked List Node
struct Node {
    int info;
    int priority;
    struct Node *prev, *next;
};
 
// Function to insert a new Node
void push(struct Node** fr, struct Node** rr, int n, int p)
{
    struct Node* news
        = (struct Node*)malloc(sizeof(struct Node*));
    news->info = n;
    news->priority = p;
 
    // If linked list is empty
    if (*fr == NULL) {
        *fr = news;
        *rr = news;
        news->next = NULL;
    }
    else {
        // If p is less than or equal front
        // node's priority, then insert at
        // the front.
        if (p <= (*fr)->priority) {
            news->next = *fr;
            (*fr)->prev = news->next;
            *fr = news;
        }
 
        // If p is more rear node's priority,
        // then insert after the rear.
        else if (p > (*rr)->priority) {
            news->next = NULL;
            (*rr)->next = news;
            news->prev = (*rr)->next;
            *rr = news;
        }
 
        // Handle other cases
        else {
 
            // Find position where we need to
            // insert.
            struct Node* start = (*fr)->next;
            while (start->priority > p)
                start = start->next;
            (start->prev)->next = news;
            news->next = start->prev;
            news->prev = (start->prev)->next;
            start->prev = news->next;
        }
    }
}
 
// Return the value at rear
int peek(struct Node* fr) { return fr->info; }
 
int isEmpty(struct Node* fr) { return (fr == NULL); }
 
// Removes the element with the
// least priority value form the list
int pop(struct Node** fr, struct Node** rr)
{
    struct Node* temp = *fr;
    int res = temp->info;
    (*fr) = (*fr)->next;
    free(temp);
    if (*fr == NULL)
        *rr = NULL;
    return res;
}
 
// Driver code
int main()
{
    struct Node *front = NULL, *rear = NULL;
    push(&front, &rear, 2, 3);
    push(&front, &rear, 3, 4);
    push(&front, &rear, 4, 5);
    push(&front, &rear, 5, 6);
    push(&front, &rear, 6, 7);
    push(&front, &rear, 1, 2);
 
    printf("%d\n", pop(&front, &rear));
    printf("%d\n", peek(front));
    return 0;
}

Java

// Java code to implement priority
// queue using doubly linked list
 
import java.util.*;
 
class Solution {
 
    static Node front, rear;
 
    // Linked List Node
    static class Node {
        int info;
        int priority;
        Node prev, next;
    }
 
    // Function to insert a new Node
    static void push(Node fr, Node rr, int n, int p)
    {
        Node news = new Node();
        news.info = n;
        news.priority = p;
 
        // If linked list is empty
        if (fr == null) {
            fr = news;
            rr = news;
            news.next = null;
        }
        else {
            // If p is less than or equal front
            // node's priority, then insert at
            // the front.
            if (p <= (fr).priority) {
                news.next = fr;
                (fr).prev = news.next;
                fr = news;
            }
 
            // If p is more rear node's priority,
            // then insert after the rear.
            else if (p > (rr).priority) {
                news.next = null;
                (rr).next = news;
                news.prev = (rr).next;
                rr = news;
            }
 
            // Handle other cases
            else {
 
                // Find position where we need to
                // insert.
                Node start = (fr).next;
                while (start.priority > p)
                    start = start.next;
                (start.prev).next = news;
                news.next = start.prev;
                news.prev = (start.prev).next;
                start.prev = news.next;
            }
        }
        front = fr;
        rear = rr;
    }
 
    // Return the value at rear
    static int peek(Node fr) { return fr.info; }
 
    static boolean isEmpty(Node fr) { return (fr == null); }
 
    // Removes the element with the
    // least priority value form the list
    static int pop(Node fr, Node rr)
    {
        Node temp = fr;
        int res = temp.info;
        (fr) = (fr).next;
        if (fr == null)
            rr = null;
 
        front = fr;
        rear = rr;
        return res;
    }
 
    // Driver code
    public static void main(String args[])
    {
 
        push(front, rear, 2, 3);
        push(front, rear, 3, 4);
        push(front, rear, 4, 5);
        push(front, rear, 5, 6);
        push(front, rear, 6, 7);
        push(front, rear, 1, 2);
 
        System.out.println(pop(front, rear));
        System.out.println(peek(front));
    }
}
 
// This code is contributed
// by Arnab Kundu

Python3

# Python3 code to implement priority
# queue using doubly linked list
 
# Linked List Node
class Node:
     
    def __init__(self):
         
        self.info = 0
        self.priority = 0
        self.next = None
        self.prev = None
 
front = None
rear = None
 
# Function to insert a new Node
def push(fr, rr, n, p):
     
    global front, rear
     
    news = Node()
    news.info = n
    news.priority = p
     
    # If linked list is empty
    if (fr == None):
        fr = news
        rr = news
        news.next = None
     
    else:
         
        # If p is less than or equal fr
        # node's priority, then insert at
        # the fr.
        if (p <= (fr).priority):
            news.next = fr
            (fr).prev = news.next
            fr = news
 
        # If p is more rr node's priority,
        # then insert after the rr.
        elif (p > (rr).priority):
            news.next = None
            (rr).next = news
            news.prev = (rr).next
            rr = news
         
        # Handle other cases
        else:
 
            # Find position where we need to
            # insert.
            start = (fr).next
             
            while (start.priority > p):
                start = start.next
                 
            (start.prev).next = news
            news.next = start.prev
            news.prev = (start.prev).next
            start.prev = news.next
             
    front = fr
    rear = rr
     
# Return the value at rr
def peek(fr):
     
    return fr.info
             
def isEmpty(fr):
     
    return fr == None
 
# Removes the element with the
# least priority value form the list
def pop(fr, rr):
     
    global front , rear
    temp = fr
    res = temp.info
    (fr) = (fr).next
     
    if (fr == None):
        rr = None
         
    front = fr
    rear = rr
    return res
 
# Driver code
if __name__=='__main__':
     
    push( front, rear, 2, 3)
    push( front, rear, 3, 4)
    push( front, rear, 4, 5)
    push( front, rear, 5, 6)
    push( front, rear, 6, 7)
    push( front, rear, 1, 2)
     
    print(pop(front, rear))
    print(peek(front))
 
# This code is contributed by rutvik_56

C#

// C# code to implement priority
// queue using doubly linked list
using System;
 
class GFG {
    public static Node front, rear;
 
    // Linked List Node
    public class Node {
        public int info;
        public int priority;
        public Node prev, next;
    }
 
    // Function to insert a new Node
    public static void push(Node fr, Node rr, int n, int p)
    {
        Node news = new Node();
        news.info = n;
        news.priority = p;
 
        // If linked list is empty
        if (fr == null) {
            fr = news;
            rr = news;
            news.next = null;
        }
        else {
            // If p is less than or equal front
            // node's priority, then insert at
            // the front.
            if (p <= (fr).priority) {
                news.next = fr;
                (fr).prev = news.next;
                fr = news;
            }
 
            // If p is more rear node's priority,
            // then insert after the rear.
            else if (p > (rr).priority) {
                news.next = null;
                (rr).next = news;
                news.prev = (rr).next;
                rr = news;
            }
 
            // Handle other cases
            else {
 
                // Find position where we
                // need to insert.
                Node start = (fr).next;
                while (start.priority > p) {
                    start = start.next;
                }
                (start.prev).next = news;
                news.next = start.prev;
                news.prev = (start.prev).next;
                start.prev = news.next;
            }
        }
        front = fr;
        rear = rr;
    }
 
    // Return the value at rear
    public static int peek(Node fr) { return fr.info; }
 
    public static bool isEmpty(Node fr)
    {
        return (fr == null);
    }
 
    // Removes the element with the
    // least priority value form the list
    public static int pop(Node fr, Node rr)
    {
        Node temp = fr;
        int res = temp.info;
        (fr) = (fr).next;
        if (fr == null) {
            rr = null;
        }
 
        front = fr;
        rear = rr;
        return res;
    }
 
    // Driver code
    public static void Main(string[] args)
    {
        push(front, rear, 2, 3);
        push(front, rear, 3, 4);
        push(front, rear, 4, 5);
        push(front, rear, 5, 6);
        push(front, rear, 6, 7);
        push(front, rear, 1, 2);
 
        Console.WriteLine(pop(front, rear));
        Console.WriteLine(peek(front));
    }
}
 
// This code is contributed by Shrikant13

Javascript

// javascript code to implement priority
// queue using doubly linked list
var front, rear;
 
    // Linked List Node
     class Node {
         constructor(){
        this.info = 0;
        this.priority = 0;
this.prev = null;
this.next = null;
}
    }
 
    // Function to insert a new Node
    function push(fr,  rr , n , p) {
var news = new Node();
        news.info = n;
        news.priority = p;
 
        // If linked list is empty
        if (fr == null) {
            fr = news;
            rr = news;
            news.next = null;
        } else {
            // If p is less than or equal front
            // node's priority, then insert at
            // the front.
            if (p <= (fr).priority) {
                news.next = fr;
                (fr).prev = news.next;
                fr = news;
            }
 
            // If p is more rear node's priority,
            // then insert after the rear.
            else if (p > (rr).priority) {
                news.next = null;
                (rr).next = news;
                news.prev = (rr).next;
                rr = news;
            }
 
            // Handle other cases
            else {
 
                // Find position where we need to
                // insert.
        var start = (fr).next;
                while (start.priority > p)
                    start = start.next;
                (start.prev).next = news;
                news.next = start.prev;
                news.prev = (start.prev).next;
                start.prev = news.next;
            }
        }
        front = fr;
        rear = rr;
    }
 
    // Return the value at rear
    function peek(fr) {
        return fr.info;
    }
 
    function isEmpty(fr) {
        return (fr == null);
    }
 
    // Removes the element with the
    // least priority value form the list
    function pop(fr,  rr) {
var temp = fr;
        var res = temp.info;
        (fr) = (fr).next;
        if (fr == null)
            rr = null;
 
        front = fr;
        rear = rr;
        return res;
    }
 
    // Driver code
     
 
        push(front, rear, 2, 3);
        push(front, rear, 3, 4);
        push(front, rear, 4, 5);
        push(front, rear, 5, 6);
        push(front, rear, 6, 7);
        push(front, rear, 1, 2);
 
        document.write(pop(front, rear)+"<br/>");
        document.write(peek(front));
 
// This code contributed by aashish1995

输出：

1
2

相关文章：
使用单链表的优先队列

时间复杂度和与二叉堆的比较：

peek()    push()    pop()
-----------------------------------------
Linked List |   O(1)      O(n)      O(1)
            |
Binary Heap |   O(1)    O(Log n)   O(Log n)