__Copy Code__The code is as follows:

#-*-Coding:utf-8-*-

Class Heap (object):

@classmethod

def parent (CLS, i):

"" "Parent Node Subscript" ""

return int ((i-1) >> 1);

@classmethod

Def left (CLS, i):

"" "Left son subscript" ""

Return (I << 1) + 1;

@classmethod

def right (CLS, i):

"" "Right son subscript" ""

Return (I << 1) + 2;

Class Minpriorityqueue (list, Heap):

@classmethod

Def min_heapify (CLS, A, I, heap_size):

"" "Minimum heap a[i] is the subtree of the root" "

L, R = Cls.left (i), cls.right (i)

If L < heap_size and a[l] < A[i]:

least = L

Else

least = I

If r < Heap_size and A[r] < A[least]:

least = R

If least! = I:

A[i], a[least] = A[least], a[i]

Cls.min_heapify (A, least, Heap_size)

def minimum (self):

"" Returns the minimum element with the pseudo code as follows:

Heap-minimum (A)

1 return a[1]

T (n) = O (1)

"""

return self[0]

def extract_min (self):

"" To remove and return the minimum element, the pseudo code is as follows:

Heap-extract-min (A)

1 if heap-size[a] < 1

2 then Error "Heap Underflow"

3 Min←a[1]

4 A[1]←a[heap-size[a]]//tail element put to first position

5 Heap-size[a]←heap-size[a]-1//decrease Heap-size[a]

6 Min-heapify (A, 1)//Keep minimum heap properties

7 return min

T (n) =θ (LGN)

"""

Heap_size = Len (self)

Assert heap_size > 0, "Heap underflow"

val = self[0]

Tail = heap_size-1

Self[0] = Self[tail]

Self.min_heapify (self, 0, tail)

Self.pop (tail)

Return Val

def decrease_key (self, I, key):

"" To reduce the value of I to key, the pseudo code is as follows:

Heap-decrease-key (A, I, KEY)

1 if key > A[i]

2 then error "new key was larger than current key"

3 A[i]←key

4 while I > 1 and a[parent (i)] > A[i]//is not a root node and the parent node is larger.

5 Do Exchange a[i]↔a[parent (i)]//Swap two elements

6 i←parent (i)//point to parent node location

T (n) =θ (LGN)

"""

val = self[i]

Assert key <= Val, "New key is larger than current key"

Self[i] = key

Parent = Self.parent

While I > 0 and Self[parent (i)] > Self[i]:

Self[i], self[parent (i)] = Self[parent (i)], Self[i]

i = parent (i)

def insert (self, key):

"" Insert key into a, pseudo code as follows:

Min-heap-insert (A, key)

1 Heap-size[a]←heap-size[a] + 1//increase in number of elements

2 a[heap-size[a]]←+∞//Initial new added element is +∞

3 Heap-decrease-key (A, Heap-size[a], key)//reduce new elements to KEY

T (n) =θ (LGN)

"""

Self.append (float (' inf '))

Self.decrease_key (Len (self)-1, key)

if __name__ = = ' __main__ ':

Import Random

Keys = Range (10)

Random.shuffle (keys)

Print (keys)

Queue = Minpriorityqueue () # Insert method to build minimum heap

For I in Keys:

Queue.insert (i)

Print (queue)

Print (' * ' * 30)

For I in range (len):

val = i% 3

If val = = 0:

val = queue.extract_min () # removes and returns the smallest element

Elif val = = 1:

val = queue.minimum () # returns the smallest element

Else

val = queue[1]-10

Queue.decrease_key (1, Val) # Queue[1] reduced by 10

Print (queue, Val)

Print ([Queue.extract_min () for I in range (len (queue))])

**