apriori算法c++实现_经典数据结构与算法（三）：Python/C/C ++实现队列类型优先级队列...-CSDN博客

前期文章点击这里：

经典数据结构与算法(一)：Python/C/C ++实现堆栈和队列

优先级队列是一种特殊的队列，其中每个元素都与一个优先级相关联，并根据其优先级进行服务。如果出现具有相同优先级的元素，则会根据其在队列中的顺序为其提供服务。

通常，元素本身的值被认为用于分配优先级。

例如，具有最高值的元素被视为最高优先级元素。但是，在其他情况下，我们可以将具有最低值的元素视为最高优先级元素。并且，我们可以根据需要的要求设置优先级。

优先队列和普通队列之间的区别：

在队列中，采用先进先出规则，而在优先级队列中，则根据priority删除值。优先级最高的元素将首先被删除。

优先队列的实现：

可以使用数组，链表，堆数据结构或二进制搜索树来实现优先级队列。在这些数据结构中，堆数据结构提供了优先级队列的有效实现。

因此，我们将使用堆数据结构来实现优先级队列。

下面给出优先级队列的不同实现的比较分析。

运作方式	窥视	插	删除
链表	`O(1)`	`O(n)`	`O(1)`
二进制堆	`O(1)`	`O(log n)`	`O(log n)`
二进制搜索树	`O(1)`	`O(log n)`	`O(log n)`

优先队列操作：优先级队列的基本操作是插入，删除和查看元素。

在研究优先级队列之前，请参考堆数据结构以更好地理解二进制堆，因为本文将其用于实现优先级队列。

1.将元素插入优先级队列

通过以下步骤将元素插入优先级队列(最大堆)。

插入后：

将元素插入优先级队列的算法(最大堆)

伪代码：

If there is no node,   create a newNode.else (a node is already present)  insert the newNode at the end (last node from left to right.)  heapify the array

对于Min Heap，对上述算法进行了修改，使其parentNode始终小于newNode。

2.从优先级队列中删除元素

从优先级队列(最大堆)中删除元素的操作如下：

将其与最后一个元素交换

于是删除最后一个元素

再次整理：

删除优先级队列中元素的算法(最大堆)

伪代码：

If nodeToBeDeleted is the leafNode  remove the nodeElse swap nodeToBeDeleted with the lastLeafNode  remove noteToBeDeleted   heapify the array

对于Min Heap，修改了上述算法，使两者均childNodes小于currentNode。

3.从优先级队列中窥视(查找最大值/最小值)

窥视操作从最大堆中返回最大元素，或者从最小堆中返回最小元素，而不删除节点。对于最大堆和最小堆

return rootNode

4.从优先级队列中提取最大/最小

从最大堆中删除节点后，Extract-Max返回具有最大值的节点，而从最小堆中删除节点后，Extract-Min返回具有最小值的节点。

Python，C和C ++中的优先级队列实现

def heapify(arr, n, i):        largest = i    l = 2 * i + 1    r = 2 * i + 2    if l < n and arr[i] < arr[l]:        largest = l    if r < n and arr[largest] < arr[r]:        largest = r        if largest != i:        arr[i], arr[largest] = arr[largest], arr[i]        heapify(arr, n, largest)def insert(array, newNum):    size = len(array)    if size == 0:        array.append(newNum)    else:        array.append(newNum)        for i in range((size // 2) - 1, -1, -1):            heapify(array, size, i)def deleteNode(array, num):    size = len(array)    i = 0    for i in range(0, size):        if num == array[i]:            break    array[i], array[size - 1] = array[size - 1], array[i]    array.remove(size - 1)    for i in range((len(array) // 2) - 1, -1, -1):        heapify(array, len(array), i)arr = []insert(arr, 3)insert(arr, 4)insert(arr, 9)insert(arr, 5)insert(arr, 2)print ("Max-Heap array: " + str(arr))deleteNode(arr, 4)print("After deleting an element: " + str(arr))

#include int size = 0;void swap(int *a, int *b) {  int temp = *b;  *b = *a;  *a = temp;}void heapify(int array[], int size, int i) {  if (size == 1) {    printf("Single element in the heap");  } else {        int largest = i;    int l = 2 * i + 1;    int r = 2 * i + 2;    if (l < size && array[l] > array[largest])      largest = l;    if (r < size && array[r] > array[largest])      largest = r;        if (largest != i) {      swap(&array[i], &array[largest]);      heapify(array, size, largest);    }  }}void insert(int array[], int newNum) {  if (size == 0) {    array[0] = newNum;    size += 1;  } else {    array[size] = newNum;    size += 1;    for (int i = size / 2 - 1; i >= 0; i--) {      heapify(array, size, i);    }  }}void deleteRoot(int array[], int num) {  int i;  for (i = 0; i < size; i++) {    if (num == array[i])      break;  }  swap(&array[i], &array[size - 1]);  size -= 1;  for (int i = size / 2 - 1; i >= 0; i--) {    heapify(array, size, i);  }}void printArray(int array[], int size) {  for (int i = 0; i < size; ++i)    printf("%d ", array[i]);  printf("\n");}int main() {  int array[10];  insert(array, 3);  insert(array, 4);  insert(array, 9);  insert(array, 5);  insert(array, 2);  printf("Max-Heap array: ");  printArray(array, size);  deleteRoot(array, 4);  printf("After deleting an element: ");  printArray(array, size);}

#include #include using namespace std;void swap(int *a, int *b) {  int temp = *b;  *b = *a;  *a = temp;}void heapify(vector<int> &hT, int i) {  int size = hT.size();      int largest = i;  int l = 2 * i + 1;  int r = 2 * i + 2;  if (l < size && hT[l] > hT[largest])    largest = l;  if (r < size && hT[r] > hT[largest])    largest = r;    if (largest != i) {    swap(&hT[i], &hT[largest]);    heapify(hT, largest);  }}void insert(vector<int> &hT, int newNum) {  int size = hT.size();  if (size == 0) {    hT.push_back(newNum);  } else {    hT.push_back(newNum);    for (int i = size / 2 - 1; i >= 0; i--) {      heapify(hT, i);    }  }}void deleteNode(vector<int> &hT, int num) {  int size = hT.size();  int i;  for (i = 0; i < size; i++) {    if (num == hT[i])      break;  }  swap(&hT[i], &hT[size - 1]);  hT.pop_back();  for (int i = size / 2 - 1; i >= 0; i--) {    heapify(hT, i);  }}void printArray(vector<int> &hT) {  for (int i = 0; i < hT.size(); ++i)    cout << hT[i] << " ";  cout << "\n";}int main() {  vector<int> heapTree;  insert(heapTree, 3);  insert(heapTree, 4);  insert(heapTree, 9);  insert(heapTree, 5);  insert(heapTree, 2);  cout << "Max-Heap array: ";  printArray(heapTree);  deleteNode(heapTree, 4);  cout << "After deleting an element: ";  printArray(heapTree);}

优先级队列的一些应用程序是：

Dijkstra的算法
用于实现堆栈
用于操作系统中的负载平衡和中断处理
用于霍夫曼代码中的数据压缩