# Maximum heap build insert delete

Posted by vexx on Tue, 04 Feb 2020 09:33:28 +0100

priority queue
For a special queue, the order of getting out elements is based on the priority (key) of the elements, and the order of getting out elements into the queue
Action: find max (min), delete (max)

Array:
Ordered array:
Ordered list:

Use binary search tree? NO

Use complete binary tree YES
Heap concatenation properties
Structure: a complete binary tree represented by an array:
Ordering: the key of any node is the maximum (or minimum) value of all nodes in its word tree
MaxHeap, also known as large top heap: maximum
MinHeap, also known as "small top heap": minimum
The order of node sequence on the path from root node to any node
Action: insert any element, delete the maximum element
Deletion of the maximum heap: take out the root node (maximum) element and delete one node of the heap at the same time

Creation of the maximum heap: store the existing N elements in an array according to the requirements of the maximum heap

```#include <stdio.h>
#include <stdlib.h>
//Maximum heap

#define MaxData 1000        //Sentinel, this value should be defined as greater than the value of all possible elements in the heap

typedef int ElementType;

typedef struct HeapNode * MaxHeap;
struct HeapNode {
int Capacity;            //Maximum heap capacity
int Size;                //Number of current elements in the heap
ElementType *Data;    //Array used to store elements
};
```

Build an empty maximum heap:

```//Build an empty maximum heap
MaxHeap InitHeap(int maxsize)
{
MaxHeap H = (MaxHeap)malloc(sizeof(struct HeapNode));
H->Data = (ElementType*)malloc(sizeof(struct HeapNode) * (maxsize + 1));        //The elements in the heap are stored from the subscript 1, but in order to ensure that the heap can store maxsize elements, it is necessary to allocate maxsize + 1 memory unit
H->Capacity = maxsize;
H->Size = 0;
H->Data = MaxData;            //Store 0 subscript units as sentinels
for (int i = 1; i < maxsize + 1; i++)
H->Data[i] = 0;
return H;
}
```

Determine whether the heap is full or empty:

```int IsEmpty(MaxHeap H)
{
return H->Size == 0;
}

//Determine if the heap is full
int IsFull(MaxHeap H)
{
return H->Size == H->Capacity;
}
```

Insert an element:

```//Insert an element in the maximum heap
void Insert(MaxHeap H, ElementType item)
{
int i;
if (IsFull(H))
{
printf("The heap is full\n");
return;
}
i = ++H->Size;        //i is the position of the last element in the heap after insertion
for (; H->Data[i / 2] < item; i /= 2)
H->Data[i] = H->Data[i / 2];        //When the loop exits, the data of the parent node is larger than the item, and the item has found the correct location
H->Data[i] = item;    //Assign item to correct subscript cell
}
```

Delete an element:

```ElementType Delete(MaxHeap H)
{
ElementType temp, Max;
int parent = 1, child;
if (IsEmpty(H))
{
printf("The heap is empty!\n");
return 0;
}
Max = H->Data;            //Now record the maximum value, that is, the value of the root node
temp = H->Data[H->Size--];        //Replace the data of the root node with the last node element, and then reduce the heap data size by 1

//If 2 * parent > 0, then the parent is already the root node
for (; 2 * parent <= H->Size; parent = child)
{
child = 2 * parent;

//If child! = H - > size indicates that child is not the last node, the parent node has a right node,
//And if the value of the right node is greater than that of the left node, then child + +;
if (child != H->Size && (H->Data[child + 1] < H->Data[child]))
child++;        //Child points to the larger of the left and right child nodes
if (temp > H->Data[child]) break;            //If the child node is already less than temp, it indicates that the appropriate location has been found
else
H->Data[parent] = H->Data[child];
}
H->Data[parent] = temp;
return Max;
}
```

Maximum heap creation:

1. In the first step, N elements are stored in the binary tree according to the input order. This step needs to satisfy the structural characteristics of the complete binary tree, regardless of its order

2. Start from the node of the last right child, and do the filtering operation similar to the element deletion. Adjust one by one until the root node

```//Create a maximum heap
MaxHeap CreateMaxHeap()
{
int dt, i = 0, j;
int parent, child;
ElementType X;
MaxHeap H = InitHeap(20);        //Create an empty maximum heap and fill it with elements
while (scanf_s("%d", &dt) != EOF)
{
H->Data[i + 1] = dt;
i++;
H->Size++;
}
for (j = i / 2; j >= 1; j--)        //Start with i / 2 and filter down one by one
{
//The following operations are exactly the same as deleting elements, but do not need to reduce the number of elements.
X = H->Data[j];
for (parent = j; 2 * parent <= H->Size; parent = child)
{
child = 2 * parent;
if (child != H->Size && H->Data[child] < H->Data[child + 1])
child++;
if (H->Data[child] < X)
break;
else
H->Data[parent] = H->Data[child];
}
H->Data[parent] = X;
}
return H;
}
```

Print elements in the heap:

```//Print elements in heap
void printHeap(MaxHeap H)
{
for (int i = 1; i <= H->Size; i++)
printf("%d ", H->Data[i]);
printf("\n");
}
```

To create a tree first:

```void PreOrderCreateHeap(MaxHeap H, int index)
{
int dt;
scanf_s("%d", &dt);
if (dt == 0)
{
return;
}
H->Size++;
H->Data[index] = dt;
printf("please enter the left child of %d :", dt);
PreOrderCreateHeap(H, 2 * index);
printf("please enter the right child of %d: ", dt);
PreOrderCreateHeap(H, 2 * index + 1);
}
```

Main function:

```int main()
{
MaxHeap H = CreateMaxHeap();
PreOrderCreateHeap(H, 1);
printHeap(H);

return 0;
}
```  76 original articles published, 86 praised, 9566 visited

Topics: less