Quelqu'un se sentirait chaud pour m'aider ?

J'vous donne plus d'infos en mp

Un projet dont je ne sais absoluement rien et qui probablement est un projet de cours (parceque bon, on est en decembre). Ca a l'air super excitant!

Si tu a une ou des question(s) pose ici, un forum c'est fait pour ça.

def heapsort( aList ):
# convert aList to heap
length = len( aList ) - 1
leastParent = length / 2
for i in range ( leastParent, -1, -1 ):
moveDown( aList, i, length )

# flatten heap into sorted array
for i in range ( length, 0, -1 ):
if aList[0] > aList[i]:
swap( aList, 0, i )
moveDown( aList, 0, i - 1 )

def moveDown( aList, first, last ):
largest = 2 * first + 1
while largest <= last:
# right child exists and is larger than left child
if ( largest < last ) and ( aList[largest] < aList[largest + 1] ):
largest += 1

# right child is larger than parent
if aList[largest] > aList[first]:
swap( aList, largest, first )
# move down to largest child
first = largest;
largest = 2 * first + 1
else:
return # force exit

def swap( A, x, y ):
tmp = A[x]
A[x] = A[y]
A[y] = tmp

On me demande d'évaluer la complexité de ce code

bah c'est toujours pareil ces trucs la. tu pars du bas du call tree. tu ecris la complexite a chaque niveau en fonction de la complexite de ce qu'il y a en dessous.
tu ecrit l'expression comme ca et tu la simplifie avec les outils standard d'algebre et de suite/serie.

occasionellement tu pars d'un guess et tu prouve par induction en partant de la definition de O()