maxListe(F[1..n]): R[max,liste] {On retourne le maximum et une liste de candidats}
Si taille(F) = 1
max F[1]
liste {}
Retourner {max,liste}
Si taille(F) = 2
Si F[1] > F[2]
max F[1]
liste F[2]
Sinon
max F[2]
liste F[1]
Retourner {max,liste}
Sinon
G maxListe(1..n/2) {On regarde dans la moitié gauche(division entière)}
maxg G[1]
listeg G[2]
D maxListe(n/2+1..n) {Moitié droite}
maxd D[1]
listed D[2]
Si maxg > maxd
liste pileg + maxd
Retourner {maxg, liste}
Sinon
liste piled + maxd
Retourner {maxd, liste}
L'algorithme fonctionne à la base simplement en divisant la liste dont il faut extraire le maximum en deux et en s'appelant
récursivement jusqu'à obtenir une liste de taille 1 ou 2. De laquelle on peut déterminer le maximum au moyen d'une simple
comparaison (ou aucune s'il n'y a qu'un élément). Les retour d'appel seront traités par paire en comparant les deux maximum et en
ne conservant que le plus grand.
Comme il y a n éléments, au plus bas niveau de la pyramide, on comparera, dans le pire des cas, les n éléments deux par
deux, ce qui nous donne n/2 comparaisons. Au retour d'appel, on aura un comparaison à faire par paire de maximum reçu, soit n/4
comparaisons dans le pire des cas. Et ainsi de suite on retrouvera finalement la série n/2 + n/4 + n/8 ... qui tend vers n. On
trouvera donc le maximum en n comparaisons.
Pour déterminer le second plus grand élément, on utilisera la structure existante déjà établie pour trouver le maximum pour
récolter la liste de tous les éléments correspondant à des candidats valables à ce titre. Par la suite, on effectuera une recherche
séquentielle simple parmi la liste des candidats recueillis pour déterminer le maximum. On aura ainsi notre second.
Pour déterminer les candidats à conserver pour la liste, il faut observer que dans l'arbre binaire formé par notre structure
récursive d'appels pour trouver le maximum, le second plus grand élément de notre liste ne peut être qu'un des éléments «battu»
sur son trajet par le maximum. Un des sous maximum éliminé par le vrai maximum donc. Ça se prouve facilement en gardant à
l'esprit que le second plus grand élément aurait été celui qui aurait été trouvé si notre vrai maximum n'avait pas été présent. Il a
donc obligatoirement été bloqué dans sa progression par notre vrai maximum.
Donc on accumule à chaque comparaison (à chaque étage de la pyramide que l'on remonte) la liste des éléments ayant été
exclus par notre maximum actuel et seulement ceux-là. Comme dans l'arbre binaire formé la hauteur est bornée par lgn, il ne peut
y avoir qu'au maximum lgn candidats dans la liste finale. La recherche séquentielle devra donc faire lgn -1comparaisons.
On a donc une recherche du maximum en n comparaisons dans le pire des cas et une recherche de second en lgn-1
comparaisons dans le pire des cas, d'où moins de n + lgn comparaisons au total.
Note: Il y a d'autres comparaison dans la structure de l'algorithme (test de longueur de la liste), pour la clarté de lecture je les ai ignorées, mais pour respecter
à la lettre les instructions, on pourrait les remplacer par un test d'existence sur l'élément 3 ou 2...