Реализация Python Max Heap | Python Max Heap

Структуры данных-это способы организации или эффективного хранения различных типов данных. Они являются неотъемлемой частью многих различных алгоритмов и позволяют нам, программистам, эффективно поддерживать данные. Мы ищем способ хранения наших данных таким образом, чтобы он требовал минимального потребления памяти, .And время, затраченное на извлечение данных из него, должно быть минимальным. Одной из таких важных структур данных является python max heap.

Максимальная куча-это особый вид дерева (должно быть полное двоичное дерево), где мы храним данные таким образом, что каждый родительский узел больше или равен каждому из его дочерних узлов. Это означает, что родитель каждого полного дерева должен быть наибольшим числом в этом дереве. В этой статье мы постараемся охватить все, что касается max heap, с самых основ.

Что такое Max Heap в Python и почему он используется?

Теперь мы знаем, что в максимальной куче все элементы упорядочены таким образом, что дочерние узлы имеют меньшее значение, чем их родительский узел. Он может быть представлен (или упорядочен) в виде массива, где первый элемент является самым большим. И если все элементы расположены таким образом, что ребенок меньше или равен своему родителю, то этот тип расположения известен как min-heap.

Важность Python Min Heap

В интервью по разработке программного обеспечения много вопросов задается по этим кучам. Причина этого заключается в том, что кучи очень полезны при реализации очередей приоритетов. И приоритетные очереди важны в Операционных системах для приоритизации задач.Расстановка приоритетов задач означает, на каких задачах операционная система должна сосредоточиться в первую очередь, а на каких-нет. Это происходит из-за ограничения доступности ресурсов в многозадачной системе. Для операционной системы важно решить, как распределить ресурсы для всех задач таким образом, чтобы каждое задание было выполнено в порядке важности.Короче говоря, приоритетная очередь полезна для балансировки нагрузки.

Представление кучи Python Max

Максимальная куча обычно представляется с помощью массива (или списка python), где первый элемент является самым большим в этом массиве.

Предположим, что у нас есть максимальная куча-

Он может быть представлен в массиве как-[10 ,9 ,7 ,5 ,6 ,2 ]

Мы видим, что элементы расположены таким образом, что каждый ребенок имеет меньшую ценность, чем его родитель.

Еще одна важная вещь, которую мы должны знать, это то, что родитель ребенка находится в индексе-

Arr[(i-1)/2]

Где Arr – массив- [10, 9, 7 ,5 ,6, 2]

“я” – это индекс ребенка.

Так, например, родительским узлом для) является-

Арр[(3-1)/2][2/2)][1]

Примечание – Здесь индекс начинается с “0”.

Аналогично, если мы хотим найти дочерние элементы определенного родительского узла, формула выглядит следующим образом::

Слева[2*i+ 1]

Где родительского узла.

Предположим, мы хотим найти левого ребенка 10 лет)

Арр[2*0+1][1]

Правый ребенок = Arr[2*i+2]

Предположим, мы хотим найти правильный дочерний элемент элемента ‘9’)

Арр[(2*1)+1][2+1][3]

Мы рассмотрели почти все важное в теоретической части о максимальной куче, и пришло время перейти непосредственно к части реализации.

Реализация Max Heap в Python

Операции:

push() – Мы можем вставить каждый элемент в кучу. Мы всегда добавляем элемент в конце дерева. Временная сложность операции равна O(log(n)). Каждый раз, когда мы делаем вставку, мы должны убедиться, что куча все еще находится в правильном порядке, проверяя значение нового элемента с родительским.
Pop ()– Мы можем удалить корень кучи. Мы должны поменять корень с последним элементом и снова проверить, все ли в порядке с кучей. А если нет, то мы должны сделать его кучей. Временная сложность этой операции также равна O(log(n)).
Peek () – Используя peek, мы можем посмотреть на первое значение кучи (самое большое значение). Время href=”https://en.wikipedia.org/wiki/Complexity”>сложность операции peek равна O(1). href=”https://en.wikipedia.org/wiki/Complexity”>сложность операции peek равна O(1).

Программа Max Heap на Python

class Max_Heap:
    # initializing the constructor with arr (array that we have to convert into heap). The default value is None([])
    def __init__(self, arr=[]):
        # Initializing the heap with no elements in it
        self._heap = []
        
        # If the array by the user is not empty, push all the elements
        if arr is not None:
            for root in arr:
                self.push(root)

# push is used to insert new value to the heap
    def push(self, value):
        # Appending the value given by user at the last
        self._heap.append(value)
        # Calling the bottom_up() to ensure heap is in order.
        # here we are passing our heap 
        _bottom_up(self._heap, len(self) - 1)

# push is used to insert new value to the heap
    def pop(self):
        if:
        # swapping the root value with the last value.

            _swap(self._heap, len(self) - 1, 0)
        # storing the popped value in the root variable

           ._heap.pop()

        #Calling the top_down function to ensure that the heap is still in order 
            _top_down(self._heap, 0)
            
        else:
           
        return root

# It tells the length of the heap
    def __len__(self):
        return len(self._heap)
# print the first element (The root)
    def peek(self):
        if:
            return(self._heap[0])
        else:
            return("heap is empty")


# Swaps value in heap between i and j index
def _swap(L, i, j):
    L[i],[j], L[i]

# This is a private function used for traversing up the tree and ensuring that heap is in order
def _bottom_up(heap, index):
    # Finding the root of the element
    root_index = (index - 1) // 2
    
    # If we are already at the root node return nothing
    if root_index < 0:
        return

    # If the current node is greater than the root node, swap them
    if heap[index] > heap[root_index]:
        _swap(heap, index,root_index)
    # Again call bottom_up to ensure the heap is in order
        _bottom_up(heap, root_index)

# This is a private function which ensures heap is in order after root is popped
def _top_down(heap, index):
    * index + 1
    # If we are at the end of the heap, return nothing
    if child_index(heap):
        return

    # For two children swap with the larger one
    if child_index + 1 < len(heap) and heap[child_index] < heap[child_index + 1]:
        child_index

    # If the child node is smaller than the current node, swap them
    if heap[child_index] > heap[index]:
        _swap(heap, child_index, index)
        _top_down(heap, child_index)

# Making the object of the Heap class and passing the array to convert into heap([1,2,3,4,5,6])
# Checking the value at top
print("Value at top:",m.peek())
# pushing elements into heap
m.push(1)
m.push(11)
print("Value at top:",m.peek())
# Deleting the root node
print("Root popped:",m.pop())
m.push(7)
m.push(9)
m.push(15)
print("Value at top:",m.peek())
print("Root popped:",m.pop())

Выход-

Value at top: 6
Value at top: 11
Root popped: 11
Value at top: 15
Root popped: 15

Результирующая куча-

Должен Читать

Как преобразовать строку в нижний регистр в
Как вычислить Квадратный корень
Пользовательский ввод | Функция ввода () | Ввод с клавиатуры
Лучшая книга для изучения Python

Вывод

Мы изучили реализацию max heap в python с нуля, потому что для понимания работы за любой структурой данных мы должны знать работу за ней. В операционных системах использование сортировки кучи с использованием кучи для распределения ресурсов на задачи с более высоким весом имеет больший приоритет при обработке.

Попробуйте запустить программы на вашей стороне и дайте нам знать, если у вас есть какие-либо вопросы.

Счастливого кодирования!