Share priority queue c++,

[hoaliendustin]

#hàng đợi, #C ++, #data Cấu trúc, #Queue, #Heap ## Hàng đợi ưu tiên trong C ++

Hàng đợi ưu tiên là một cấu trúc dữ liệu duy trì một tập hợp các phần tử theo thứ tự được sắp xếp, trong đó các yếu tố có mức độ ưu tiên cao nhất là ở phía trước của hàng đợi.Ưu tiên của một phần tử được xác định bởi một hàm so sánh, được truyền cho hàm tạo hàng đợi ưu tiên.

Các hàng đợi ưu tiên thường được sử dụng để thực hiện các thuật toán như thuật toán đường dẫn ngắn nhất của Dijkstra và thuật toán cây bao trùm tối thiểu của Prim.Chúng cũng có thể được sử dụng để thực hiện các thuật toán lập lịch dựa trên ưu tiên, chẳng hạn như trình lập lịch vòng tròn và trình lập lịch công việc ngắn nhất đầu tiên.

### Thực hiện hàng đợi ưu tiên trong C ++

Mã sau đây thực hiện hàng đợi ưu tiên trong C ++ bằng cách sử dụng một đống nhị phân.Một đống nhị phân là một cây nhị phân hoàn chỉnh trong đó các yếu tố được đặt hàng theo mức độ ưu tiên của chúng.Rễ của đống là yếu tố ưu tiên cao nhất và trẻ em của một nút được đặt hàng theo thứ tự ưu tiên giảm.

`` `C ++
#include <Istream>
#include <Vector>

sử dụng không gian tên STD;

// một lớp hàng đợi ưu tiên sử dụng một đống nhị phân
lớp ưu tiên {
công cộng:
// Người xây dựng
Hàng đợi ưu tiên() {}

// Chèn một phần tử vào hàng đợi ưu tiên
void chèn (phần tử int) {
// Thêm phần tử vào cuối vectơ
data.push_back (phần tử);

// bong bóng lên phần tử cho đến khi nó ở đúng vị trí
int index = data.size () - 1;
while (index> 0 && data [cha mẹ (index)] <data [index]) {
hoán đổi (dữ liệu [chỉ mục], dữ liệu [cha mẹ (chỉ mục)]);
chỉ mục = cha mẹ (chỉ mục);
}
}

// loại bỏ phần tử với mức độ ưu tiên cao nhất khỏi hàng đợi ưu tiên
int remove () {
// Nhận phần tử ở phía trước hàng đợi
phần tử int = data [0];

// Di chuyển phần tử cuối cùng đến phía trước hàng đợi
dữ liệu [0] = data [data.size () - 1];

// Hàng đợi hàng đợi
int index = 0;
while (index <data.size () - 1) {
int left = LeftChild (index);
int right = rightChild (index);

// Tìm phần lớn nhất trong ba yếu tố
int lớn nhất = chỉ mục;
if (trái <data.size () && data [trái]> data [lớn nhất]) {
lớn nhất = trái;
}
if (phải <data.size () && data

> data [lớn nhất]) {
lớn nhất = đúng;
}

// Nếu phần tử lớn nhất không ở phía trước hàng đợi, hãy trao đổi nó
if (lớn nhất! = index) {
hoán đổi (dữ liệu [chỉ mục], dữ liệu [lớn nhất]);
chỉ mục = lớn nhất;
} khác {
phá vỡ;
}
}

// Xóa phần tử cuối cùng khỏi vectơ
data.pop_back ();

trở lại phần tử;
}

// Trả về phần tử với mức ưu tiên cao nhất trong hàng đợi ưu tiên
int top () {
trả về dữ liệu [0];
}

// Trả về kích thước của hàng đợi ưu tiên
int size () {
trả về dữ liệu.size ();
}

riêng tư:
// Trả về cha mẹ của một nút trong đống nhị phân
int Parent (int index) {
Trả về (INDEX - 1) / 2;
}

// Trả về đứa con trái của một nút trong đống nhị phân
int LeftChild (int index) {
trả về 2 * index + 1;
}

// Trả về đứa con phải của một nút trong đống nhị phân
int rightchild (int index) {
trả về 2 * index + 2;
}

// dữ liệu trong hàng đợi ưu tiên
Dữ liệu vector <Int>;
};

int main () {
// Tạo hàng đợi ưu tiên
Hàng đợi ưu tiên;
=======================================
#Priority queue, #C++, #data structure, #Queue, #Heap ## Priority Queue in C++

A priority queue is a data structure that maintains a set of elements in sorted order, where the elements with the highest priority are at the front of the queue. The priority of an element is determined by a comparison function, which is passed to the priority queue constructor.

Priority queues are often used to implement algorithms such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm. They can also be used to implement priority-based scheduling algorithms, such as the round-robin scheduler and the shortest job first scheduler.

### Implementing a Priority Queue in C++

The following code implements a priority queue in C++ using a binary heap. A binary heap is a complete binary tree in which the elements are ordered according to their priority. The root of the heap is the element with the highest priority, and the children of a node are ordered in decreasing order of priority.

```c++
#include <iostream>
#include <vector>

using namespace std;

// A priority queue class that uses a binary heap
class PriorityQueue {
public:
// Constructor
PriorityQueue() {}

// Inserts an element into the priority queue
void insert(int element) {
// Add the element to the end of the vector
data.push_back(element);

// Bubble up the element until it is in the correct position
int index = data.size() - 1;
while (index > 0 && data[parent(index)] < data[index]) {
swap(data[index], data[parent(index)]);
index = parent(index);
}
}

// Removes the element with the highest priority from the priority queue
int remove() {
// Get the element at the front of the queue
int element = data[0];

// Move the last element to the front of the queue
data[0] = data[data.size() - 1];

// Heapify the queue
int index = 0;
while (index < data.size() - 1) {
int left = leftChild(index);
int right = rightChild(index);

// Find the largest of the three elements
int largest = index;
if (left < data.size() && data

> data[largest]) {
largest = left;
}
if (right < data.size() && data

> data[largest]) {
largest = right;
}

// If the largest element is not at the front of the queue, swap it
if (largest != index) {
swap(data[index], data[largest]);
index = largest;
} else {
break;
}
}

// Remove the last element from the vector
data.pop_back();

return element;
}

// Returns the element with the highest priority in the priority queue
int top() {
return data[0];
}

// Returns the size of the priority queue
int size() {
return data.size();
}

private:
// Returns the parent of a node in the binary heap
int parent(int index) {
return (index - 1) / 2;
}

// Returns the left child of a node in the binary heap
int leftChild(int index) {
return 2 * index + 1;
}

// Returns the right child of a node in the binary heap
int rightChild(int index) {
return 2 * index + 2;
}

// The data in the priority queue
vector<int> data;
};

int main() {
// Create a priority queue
PriorityQueue queue;​