My code keeps failing, error messages:

Description : This is the same test as in the PDF Examples Input : DYN$\_$ARR Size$/$Cap: $7/8[100,20,6,200,90,150,300]$ Expected : DYN$\_$ARR Size$/$Cap: $7/8[300,200,150,100,90,20,6]$ : Return: None Student : DYN$\_$ARR Size$/$Cap: $7/8[6,20,90,100,150,200,300]$ : Return: None DynamicArray has different contents Test Failed: False is not true

Description : This is a test with random values Input : DYN$\_$ARR Size$/$Cap: $6/8[84848,90990,44,48273,69294,39081]$ Expected : DYN$\_$ARR Size$/$Cap: $6/8[90990,84848,69294,48273,39081,44]$ : Return: None Student : DYN$\_$ARR Size$/$Cap: $6/8[44,39081,48273,69294,84848,90990]$ : Return: None DynamicArray has different contents Test Failed: False is not true

This is the problem:

heapsort$($da: DynamicArray$)->$ None:

Write a function that receives a DynamicArray and sorts its content in non$-$ascending order,

using the Heapsort algorithm. You must sort the array in place, without creating any data

structures. This function does not return anything.

You may assume that the input array will contain one or more homogeneous elements

$($either all numbers, or strings, or custom objects, but never a mix of these$).$ You do not

need to write checks for these conditions.

The runtime complexity of this implementation must be O$($N log N$).$ If the sort uses an

algorithm other than Heapsort, you will not receive any points for this portion of the

assignment, even if your function passes Gradescope.

My code:

def heapsort$($da: DynamicArray$)->$ None:

$"""$

Sorts the elements in the DynamicArray in non$-$ascending order using the Heapsort.

The sorting happens in place without creating new data structures.

$"""$

def $\_$percolate$\_$down$\_$sort$($da: DynamicArray, parent: int, heap$\_$size: int$)->$ None:

$"""$

Percolates the element at the given index down to restore the heap property.

$"""$

left$\_$child $=2*$ parent $+1$

right$\_$child $=2*$ parent $+2$

largest $=$ parent

# Check if left child exists and is larger than the current node

if left$\_$child $<$ heap$\_$size and da$.$get$\_$at$\_$index$($left$\_$child$)>$ da$.$get$\_$at$\_$index$($largest$)$:

largest $=$ left$\_$child

# Check if the right child exists and is larger than the current node

if right$\_$child $<$ heap$\_$size and da$.$get$\_$at$\_$index$($right$\_$child$)>$ da$.$get$\_$at$\_$index$($largest$)$:

largest $=$ right$\_$child

# If the smallest is not the current node, swap with the largest child and percolate down

if largest $!=$ parent:

da$.\_$swap$($parent$,$ largest$)$

$\_$percolate$\_$down$\_$sort$($da$,$ largest, heap$\_$size$)$

n $=$ da$.$length$()$

for i in range$(($n $//2)-1,-1,-1)$:

$\_$percolate$\_$down$\_$sort$($da$,$ i$,$ n$)$

# Perform heapsort

for end in range$($n $-1,0,-1)$:

da$.\_$swap$(0,$ end$)$ # Move the root $($max element$)$ to the end

$\_$percolate$\_$down$\_$sort$($da$,0,$ end$)$