priority_queue < int, vector , більше > minH;>

PriorityQueue minHeap = новий PriorityQueue ();>

heap = [] heapify(heap)>

var minHeap = new PriorityQueue ();>

const minHeap = new MinHeap();>

#include  #include  using namespace std; // Function to insert a new element into the min-heap void insert_min_heap(vector & heap, int value) { // Додати новий елемент у кінець купи heap.push_back(value);  // Отримання індексу останнього елемента int index = heap.size() - 1;  // Порівняйте новий елемент із його батьківським // місцем, якщо необхідно, while (index> 0 && heap[(index - 1) / 2]> heap[index]) { swap(heap[index], heap[(index - 1) / 2]);  // Перейти вгору по дереву до батьківського // елемента index = (index - 1) / 2;  } } // Головна функція для перевірки функції insert_min_heap int main() { вектор купа;  int values[] = { 10, 7, 11, 5, 4, 13 };  int n = sizeof(значення) / sizeof(значення[0]);  для (int i = 0; i< n; i++) {  insert_min_heap(heap, values[i]);  cout << 'Inserted ' << values[i]  << ' into the min-heap: ';  for (int j = 0; j < heap.size(); j++) {  cout << heap[j] << ' ';  }  cout << endl;  }  return 0; }>

import java.util.*; public class GFG {  // Function to insert a new element into the min-heap  public static void insertMinHeap(int[] heap, int size,  int value)  {  // Add the new element to the end of the heap  heap[size] = value;  // Get the index of the last element  int index = size;  // Compare the new element with its parent and swap  // if necessary  while (index>0 && heap[(index - 1) / 2]> heap[index]) { swap(heap, index, (index - 1) / 2);  // Перейти вгору по дереву до батьківського // елемента index = (index - 1) / 2;  } } // Функція для обміну місцями двох елементів у масиві public static void swap(int[] arr, int i, int j) { int temp = arr[i];  arr[i] = arr[j];  arr[j] = темп;  } // Основна функція для перевірки функції insertMinHeap public static void main(String[] args) { int[] heap = new int[6];  int[] значення = { 10, 7, 11, 5, 4, 13 };  int size = 0;  для (int i = 0; i< values.length; i++) {  insertMinHeap(heap, size, values[i]);  size++;  System.out.print('Inserted ' + values[i]  + ' into the min-heap: ');  for (int j = 0; j < size; j++) {  System.out.print(heap[j] + ' ');  }  System.out.println();  }  } }>

def insert_min_heap(heap, value): # Add the new element to the end of the heap heap.append(value) # Get the index of the last element index = len(heap) - 1 # Compare the new element with its parent and swap if necessary while index>0 і купа[(індекс - 1) // 2]> купа[індекс]: купа[індекс], купа[(індекс - 1) // 2] = купа[(індекс - 1) // 2], купа[ index] # Переміщення вверх по дереву до батьківського елемента поточного елемента index = (index - 1) // 2 купа = [] values ​​= [10, 7, 11, 5, 4, 13] для значення у values: insert_min_heap( купа, значення) print(f'Вставлено {value} у min-heap: {heap}')>

using System; using System.Collections.Generic; public class Program {  // Function to insert a new element into the min-heap  static void InsertMinHeap(List heap, int value) { // Додати новий елемент у кінець купи heap.Add(value);  // Отримання індексу останнього елемента int index = heap.Count - 1;  // Порівняйте новий елемент із його батьківським і // за необхідності поміняйте місцями while (index> 0 && heap[(index - 1) / 2]> heap[index]) { int temp = heap[index];  купа[індекс] = купа[(індекс - 1) / 2];  купа[(індекс - 1) / 2] = temp;  // Перейти вгору по дереву до батьківського // елемента index = (index - 1) / 2;  } } // Основна функція для перевірки функції InsertMinHeap public static void Main() { List купа = новий список ();  int[] значення = { 10, 7, 11, 5, 4, 13 };  foreach(int value in values) { InsertMinHeap(heap, value);  Console.Write('Inserted ' + value + ' into the min-heap: ');  foreach(int елемент у купі) { Console.Write(element + ' ');  } Console.WriteLine();  } } }>

function insertMinHeap(heap, value) {  heap.push(value);  let index = heap.length - 1;  let parentIndex = Math.floor((index - 1) / 2);  while (index>0 && heap[parentIndex]> heap[index]) { [heap[index], heap[parentIndex]] = [heap[parentIndex], heap[index]];  індекс = parentIndex;  parentIndex = Math.floor((індекс - 1) / 2);  } } // Приклад використання const heap = []; значення const = [10, 7, 11, 5, 4, 13]; for (const значення значень) { insertMinHeap(heap, value);  console.log(`Вставлено ${value} у міні-кучу: ${heap}`); }>

#include  #include  using namespace std; // Function to insert a new element into the min-heap void insert_min_heap(vector & heap, int value) { // Додати новий елемент у кінець купи heap.push_back(value);  // Отримання індексу останнього елемента int index = heap.size() - 1;  // Порівняйте новий елемент із його батьківським // місцем, якщо необхідно, while (index> 0 && heap[(index - 1) / 2]> heap[index]) { swap(heap[index], heap[(index - 1) / 2]);  // Перейти вгору по дереву до батьківського // елемента index = (index - 1) / 2;  } } // Функція видалення вузла з мінімальної купи void delete_min_heap(вектор & heap, int value) { // Знайти індекс елемента, який потрібно видалити int index = -1;  для (int i = 0; i< heap.size(); i++) {  if (heap[i] == value) {  index = i;  break;  }  }  // If the element is not found, return  if (index == -1) {  return;  }  // Replace the element to be deleted with the last  // element  heap[index] = heap[heap.size() - 1];  // Remove the last element  heap.pop_back();  // Heapify the tree starting from the element at the  // deleted index  while (true) {  int left_child = 2 * index + 1;  int right_child = 2 * index + 2;  int smallest = index;  if (left_child < heap.size()  && heap[left_child] < heap[smallest]) {  smallest = left_child;  }  if (right_child < heap.size()  && heap[right_child] < heap[smallest]) {  smallest = right_child;  }  if (smallest != index) {  swap(heap[index], heap[smallest]);  index = smallest;  }  else {  break;  }  } } // Main function to test the insert_min_heap and // delete_min_heap functions int main() {  vector купа;  int values[] = { 13, 16, 31, 41, 51, 100 };  int n = sizeof(значення) / sizeof(значення[0]);  для (int i = 0; i< n; i++) {  insert_min_heap(heap, values[i]);  }  cout << 'Initial heap: ';  for (int j = 0; j < heap.size(); j++) {  cout << heap[j] << ' ';  }  cout << endl;  delete_min_heap(heap, 13);  cout << 'Heap after deleting 13: ';  for (int j = 0; j < heap.size(); j++) {  cout << heap[j] << ' ';  }  cout << endl;  return 0; }>

import java.util.*; public class GFG {  // Function to insert a new element into the min-heap  public static void insertMinHeap(List heap, int value) { // Додати новий елемент у кінець купи heap.add(value);  // Отримання індексу останнього елемента int index = heap.size() - 1;  // Порівняйте новий елемент із його батьківським і // за необхідності замініть місцями while (index> 0 && heap.get((index - 1) / 2)> heap.get(index)) { Collections.swap(heap, index, (індекс - 1) / 2);  // Перейти вгору по дереву до батьківського // елемента index = (index - 1) / 2;  } } // Функція для видалення вузла з мінімальної купи public static void deleteMinHeap(List heap, int value) { // Знайти індекс елемента, який потрібно видалити int index = -1;  для (int i = 0; i< heap.size(); i++) {  if (heap.get(i) == value) {  index = i;  break;  }  }  // If the element is not found, return  if (index == -1) {  return;  }  // Replace the element to be deleted with the last  // element  heap.set(index, heap.get(heap.size() - 1));  // Remove the last element  heap.remove(heap.size() - 1);  // Heapify the tree starting from the element at the  // deleted index  while (true) {  int leftChild = 2 * index + 1;  int rightChild = 2 * index + 2;  int smallest = index;  if (leftChild < heap.size()  && heap.get(leftChild)  < heap.get(smallest)) {  smallest = leftChild;  }  if (rightChild < heap.size()  && heap.get(rightChild)  < heap.get(smallest)) {  smallest = rightChild;  }  if (smallest != index) {  Collections.swap(heap, index, smallest);  index = smallest;  }  else {  break;  }  }  }  // Main function to test the insertMinHeap and  // deleteMinHeap functions  public static void main(String[] args)  {  List heap = новий ArrayList ();  int[] значення = { 13, 16, 31, 41, 51, 100 };  int n = values.length;  для (int i = 0; i< n; i++) {  insertMinHeap(heap, values[i]);  }  System.out.print('Initial heap: ');  for (int j = 0; j < heap.size(); j++) {  System.out.print(heap.get(j) + ' ');  }  System.out.println();  deleteMinHeap(heap, 13);  System.out.print('Heap after deleting 13: ');  for (int j = 0; j < heap.size(); j++) {  System.out.print(heap.get(j) + ' ');  }  System.out.println();  } }>

def insert_min_heap(heap, value): heap.append(value) index = len(heap) - 1 while index>0 і купа[(індекс - 1) // 2]> купа[індекс]: купа[індекс], купа[(індекс - 1) // 2] = купа[(індекс - 1) // 2], купа[ index] index = (index - 1) // 2 def delete_min_heap(heap, value): index = -1 for i in range(len(heap)): if heap[i] == value: index = i break if index == -1: повернути heap[index] = heap[-1] heap.pop() while True: left_child = 2 * index + 1 right_child = 2 * index + 2 smallest = index if left_child< len(heap) and heap[left_child] < heap[smallest]: smallest = left_child if right_child < len(heap) and heap[right_child] < heap[smallest]: smallest = right_child if smallest != index: heap[index], heap[smallest] = heap[smallest], heap[index] index = smallest else: break heap = [] values = [13, 16, 31, 41, 51, 100] for value in values: insert_min_heap(heap, value) print('Initial heap:', heap) delete_min_heap(heap, 13) print('Heap after deleting 13:', heap)>

using System; using System.Collections.Generic; class MinHeap {  private List купа = новий список ();  public void Insert(int value) { heap.Add(value);  int index = heap.Count - 1;  while (index> 0 && heap[(index - 1) / 2]> heap[index]) { Swap(index, (index - 1) / 2);  індекс = (індекс - 1) / 2;  } } public void Delete(int value) { int index = heap.IndexOf(value);  if (index == -1) { return;  } heap[index] = heap[heap.Count - 1];  heap.RemoveAt(heap.Count - 1);  while (true) { int leftChild = 2 * index + 1;  int rightChild = 2 * індекс + 2;  int найменший = індекс;  якщо (ліворучДитина< heap.Count  && heap[leftChild] < heap[smallest]) {  smallest = leftChild;  }  if (rightChild < heap.Count  && heap[rightChild] < heap[smallest]) {  smallest = rightChild;  }  if (smallest != index) {  Swap(index, smallest);  index = smallest;  }  else {  break;  }  }  }  private void Swap(int i, int j)  {  int temp = heap[i];  heap[i] = heap[j];  heap[j] = temp;  }  public void Print()  {  for (int i = 0; i < heap.Count; i++) {  Console.Write(heap[i] + ' ');  }  Console.WriteLine();  } } class Program {  static void Main(string[] args)  {  MinHeap heap = new MinHeap();  int[] values = { 13, 16, 31, 41, 51, 100 };  for (int i = 0; i < values.Length; i++) {  heap.Insert(values[i]);  }  Console.Write('Initial heap: ');  heap.Print();  heap.Delete(13);  Console.Write('Heap after deleting 13: ');  heap.Print();  } }>

function insertMinHeap(heap, value) {  // Add the new element to the end of the heap  heap.push(value);  // Get the index of the last element  let index = heap.length - 1;  // Compare the new element with its parent and swap if necessary  for (let flr = Math.floor((index - 1) / 2); index>0 && купа[flr]> купа[індекс]; flr = Math.floor((index - 1) / 2)) { [heap[index], heap[flr]] = [ heap[flr], heap[index], ];  // Переміщення вверх по дереву до батьківського елемента поточного елемента index = Math.floor((index - 1) / 2);  } } function deleteMinHeap(heap, value) { // Знайдіть індекс елемента, який потрібно видалити let index = -1;  для (нехай i = 0; i< heap.length; i++) {  if (heap[i] == value) {  index = i;  break;  }  }  // If the element is not found, return  if (index == -1) {  return;  }  // Replace the element to be deleted with the last element  heap[index] = heap[heap.length - 1];  // Remove the last element  heap.pop();  // Heapify the tree starting from the element at the deleted index  while (true) {  let left_child = 2 * index + 1;  let right_child = 2 * index + 2;  let smallest = index;  if (left_child < heap.length && heap[left_child] < heap[smallest]) {  smallest = left_child;  }  if (right_child < heap.length && heap[right_child] < heap[smallest]) {  smallest = right_child;  }  if (smallest != index) {  [heap[index], heap[smallest]] = [heap[smallest], heap[index]];  index = smallest;  } else {  break;  }  } } // Main function to test the insertMinHeap and deleteMinHeap functions let heap = []; let values = [13, 16, 31, 41, 51, 100]; for (let i = 0; i < values.length; i++) {  insertMinHeap(heap, values[i]); } console.log('Initial heap: ' + heap.join(' ')); deleteMinHeap(heap, 13); console.log('Heap after deleting 13: ' + heap.join(' '));>

#include  #include  #include  using namespace std; int main() {  // Create a max heap with some elements using a  // priority_queue  priority_queue , більше > minHeap;  minHeap.push(9);  minHeap.push(8);  minHeap.push(7);  minHeap.push(6);  minHeap.push(5);  minHeap.push(4);  minHeap.push(3);  minHeap.push(2);  minHeap.push(1);  // Отримання пікового елемента (тобто найбільшого елемента) int peakElement = minHeap.top();  // Надрукувати піковий елемент cout<< 'Peak element: ' << peakElement << std::endl;  return 0; }>

import java.util.PriorityQueue; public class GFG {  public static void main(String[] args)  {  // Create a max heap with some elements using a  // PriorityQueue  PriorityQueue minHeap = новий PriorityQueue();  minHeap.add(9);  minHeap.add(8);  minHeap.add(7);  minHeap.add(6);  minHeap.add(5);  minHeap.add(4);  minHeap.add(3);  minHeap.add(2);  minHeap.add(1);  // Отримання пікового елемента (тобто найбільшого елемента) int peakElement = minHeap.peek();  // Надрукувати піковий елемент System.out.println('Піковий елемент: ' + peakElement);  } }>

import heapq # Create a min heap with some elements using a list min_heap = [9, 8, 7, 6, 5, 4, 3, 2, 1] heapq.heapify(min_heap) # Get the peak element (i.e., the smallest element) peak_element = heapq.nsmallest(1, min_heap)[0] # Print the peak element print('Peak element:', peak_element)>

using System; using System.Collections.Generic; public class GFG {  public static void Main()  {  // Create a min heap with some elements using a  // PriorityQueue  var minHeap = new PriorityQueue ();  minHeap.Enqueue(9);  minHeap.Enqueue(8);  minHeap.Enqueue(7);  minHeap.Enqueue(6);  minHeap.Enqueue(5);  minHeap.Enqueue(4);  minHeap.Enqueue(3);  minHeap.Enqueue(2);  minHeap.Enqueue(1);  // Отримання пікового елемента (тобто найменшого елемента) int peakElement = minHeap.Peek();  // Надрукувати піковий елемент Console.WriteLine('Піковий елемент: ' + peakElement);  } }>

const PriorityQueue = require('fast-priority-queue'); // Create a min heap with some elements using a PriorityQueue const minHeap = new PriorityQueue((a, b) =>а - б); minHeap.add(9); minHeap.add(8); minHeap.add(7); minHeap.add(6); minHeap.add(5); minHeap.add(4); minHeap.add(3); minHeap.add(2); minHeap.add(1); // Отримання пікового елемента (тобто найменшого елемента) const peakElement = minHeap.peek(); // Надрукувати піковий елемент console.log(`Піковий елемент: ${peakElement}`);>

#include  #include  using namespace std; void minHeapify(vector &arr, int i, int n) { int найменший = i;  int l = 2*i + 1;  int r = 2*i + 2;  якщо (л< n && arr[l] < arr[smallest])  smallest = l;  if (r < n && arr[r] < arr[smallest])  smallest = r;  if (smallest != i) {  swap(arr[i], arr[smallest]);  minHeapify(arr, smallest, n);  } } int main() {  vector arr = {10, 5, 15, 2, 20, 30};  cout<< 'Original array: ';  for (int i = 0; i < arr.size(); i++)  cout << arr[i] << ' ';  // Perform heapify operation on min-heap  for (int i = arr.size()/2 - 1; i>= 0; i--) minHeapify(arr, i, arr.size());  cout<< '
Min-Heap after heapify operation: ';  for (int i = 0; i < arr.size(); i++)  cout << arr[i] << ' ';  return 0; }>

// Java code of Heapify operation in Min-Heap import java.util.Arrays; import java.util.List; public class Main {  // Function to maintain the min-heap property of the heap rooted at index 'i'  public static void minHeapify(List arr, int i, int n) { // Припустимо, що корінь є найменшим елементом спочатку int smallest = i;  // Обчислення індексів лівого та правого дочірніх елементів поточного вузла int l = 2 * i + 1;  int r = 2 * i + 2;  // Порівнюємо ліву дочірню частину з поточною найменшою if (l< n && arr.get(l) < arr.get(smallest))  smallest = l;  // Compare the right child with the current smallest  if (r < n && arr.get(r) < arr.get(smallest))  smallest = r;  // If the current node is not the smallest, swap it with the smallest child  if (smallest != i) {  int temp = arr.get(i);  arr.set(i, arr.get(smallest));  arr.set(smallest, temp);  // Recursively heapify the subtree rooted at the smallest child  minHeapify(arr, smallest, n);  }  }  public static void main(String[] args) {  // Create a list representing the array  List arr = Arrays.asList(10, 5, 15, 2, 20, 30);  System.out.print('Оригінальний масив: ');  // Вивести вихідний масив для (int i = 0; i< arr.size(); i++)  System.out.print(arr.get(i) + ' ');  // Perform heapify operation on the min-heap  // Start from the last non-leaf node and go up to the root of the tree  for (int i = arr.size() / 2 - 1; i>= 0; i--) minHeapify(arr, i, arr.size());  System.out.print('
Мінальна купа після операції heapify: ');  // Надрукувати мінімальну купу після операції heapify для (int i = 0; i< arr.size(); i++)  System.out.print(arr.get(i) + ' ');  } }>

def minHeapify(arr, i, n): smallest = i left = 2 * i + 1 right = 2 * i + 2 if left < n and arr[left] < arr[smallest]: smallest = left if right < n and arr[right] < arr[smallest]: smallest = right if smallest != i: arr[i], arr[smallest] = arr[smallest], arr[i] minHeapify(arr, smallest, n) if __name__ == '__main__': arr = [10, 5, 15, 2, 20, 30] print('Original array:', arr) # Perform heapify operation on a min-heap for i in range(len(arr) // 2 - 1, -1, -1): minHeapify(arr, i, len(arr)) print('Min-Heap after heapify operation:', arr)>

using System; using System.Collections.Generic; class GFG {  // Function to perform the minHeapify operation on a min-heap.  static void MinHeapify(List arr, int i, int n) { int smallest = i;  int left = 2 * i + 1;  int right = 2 * i + 2;  // Порівнюємо лівий дочірній елемент із поточним найменшим вузлом.  якщо (ліворуч< n && arr[left] < arr[smallest])  smallest = left;  // Compare the right child with the current smallest node.  if (right < n && arr[right] < arr[smallest])  smallest = right;  // If the current node is not the smallest  // swap it with the smallest child.  if (smallest != i)  {  int temp = arr[i];  arr[i] = arr[smallest];  arr[smallest] = temp;  // Recursively call minHeapify on the affected subtree.  MinHeapify(arr, smallest, n);  }  }  static void Main(string[] args)  {  List arr = новий список { 10, 5, 15, 2, 20, 30 };  Console.Write('Оригінальний масив: ');  foreach (int num in arr) Console.Write(num + ' ');  // Виконати операцію heapify на міні-купі.  for (int i = arr.Count / 2 - 1; i>= 0; i--) MinHeapify(arr, i, arr.Count);  Console.Write('
Min-Heap після операції heapify: ');  foreach (int num in arr) Console.Write(num + ' ');  } }>

// Define a function to perform min-heapify operation on an array function minHeapify(arr, i, n) {  let smallest = i;  let l = 2 * i + 1;  let r = 2 * i + 2;  // Check if left child is smaller than the current smallest element  if (l < n && arr[l] < arr[smallest])  smallest = l;  // Check if right child is smaller than the current smallest element  if (r < n && arr[r] < arr[smallest])  smallest = r;  // If the smallest element is not the current element, swap them  if (smallest !== i) {  [arr[i], arr[smallest]] = [arr[smallest], arr[i]];  minHeapify(arr, smallest, n);  } } // Main function function main() {  const arr = [10, 5, 15, 2, 20, 30];  // Print the original array  console.log('Original array: ' + arr.join(' '));  // Perform heapify operation on the min-heap  for (let i = Math.floor(arr.length / 2) - 1; i>= 0; i--) minHeapify(arr, i, arr.length);  // Надрукувати мінімальну купу після операції heapify console.log('Min-Heap після операції heapify: ' + arr.join(' ')); } // Виклик функції main для запуску процесу main();>

#include  using namespace std; int main() {  priority_queue , більше > min_heap;  // приклад максимальної купи min_heap.push(10);  min_heap.push(9);  min_heap.push(8);  min_heap.push(6);  min_heap.push(4);  int element = 6; // елемент для пошуку bool found = false;  // Скопіюйте мінімальну купу до тимчасової черги та знайдіть // елемент std::priority_queue , більше > temp = min_heap;  while (!temp.empty()) { if (temp.top() == element) { found = true;  перерва;  } temp.pop();  } якщо (знайдено) { std::cout<< 'Element found in the min heap.'  << std::endl;  }  else {  std::cout << 'Element not found in the min heap.'  << std::endl;  }  return 0; }>

import java.util.PriorityQueue; public class GFG {  public static void main(String[] args)  {  PriorityQueue min_heap = новий PriorityQueue();  min_heap.add( 3); // вставити елементи в пріоритетну чергу min_heap.offer(1);  min_heap.offer(4);  min_heap.offer(1);  min_heap.offer(6);  int element = 6; // елемент для пошуку boolean found = false;  // Скопіюйте мініатюрну купу до тимчасової черги та знайдіть // елемент PriorityQueue temp = new PriorityQueue(min_heap);  while (!temp.isEmpty()) { if (temp.poll() == element) { found = true;  перерва;  } } if (знайдено) { System.out.println( 'Елемент знайдено в мінімальній купі.');  } else { System.out.println( 'Елемент не знайдено в мінімальній купі.');  } } }>

import heapq min_heap = [1, 2, 3, 5, 6, 7, 8, 10] # example min heap heapq.heapify(min_heap) element = 6 # element to search for found = False # Copy the min heap to a temporary list and search for the element temp = list(min_heap) while temp: if heapq.heappop(temp) == element: found = True break if found: print('Element found in the min heap.') else: print('Element not found in the min heap.')>

using System; using System.Collections.Generic; public class GFG {  public static void Main()  {  var minHeap = new PriorityQueue ();  // приклад min heap minHeap.Enqueue(4);  minHeap.Enqueue(6);  minHeap.Enqueue(8);  minHeap.Enqueue(9);  minHeap.Enqueue(10);  int element = 6; // елемент для пошуку bool found = false;  // Скопіюйте мініатюрну купу до тимчасової черги та знайдіть // елемент var temp = new PriorityQueue (minHeap);  while (temp.Count> 0) { if (temp.Peek() == element) { found = true;  перерва;  } temp.Dequeue();  } if (знайдено) { Console.WriteLine( 'Елемент знайдено в мінімальній купі.');  } else { Console.WriteLine( 'Елемент не знайдено в мінімальній купі.');  } } }>

// Example min heap let minHeap = new PriorityQueue(); minHeap.enqueue(4); minHeap.enqueue(6); minHeap.enqueue(8); minHeap.enqueue(9); minHeap.enqueue(10); let element = 6; // Element to search for let found = false; // Copy the min heap to a temporary queue and search for the element let temp = new PriorityQueue(minHeap); while (temp.size()>0) { якщо (temp.peek() == елемент) { знайдено = істина;  перерва;  } temp.dequeue(); } if (знайдено) { console.log('Елемент знайдено в мінімальній купі.'); } else { console.log('Елемент не знайдено в мінімальній купі.'); }>