Pourquoi préférer start + (end - start) / 2 over (start + end) / 2 lors du calcul du milieu d'un tableau?

J'ai vu des programmeurs utiliser la formule

mid = start + (end - start) / 2

au lieu d'utiliser la formule plus simple

mid = (start + end) / 2

pour trouver l'élément du milieu dans le tableau ou la liste.

Pourquoi utilisent-ils l'ancien?

Il y a trois raisons.

Tout d'abord, start + (end - start) / 2fonctionne même si vous utilisez des pointeurs, à condition qu'il end - startne déborde pas de ¹ .

int *start = ..., *end = ...;
int *mid = start + (end - start) / 2; // works as expected
int *mid = (start + end) / 2;         // type error, won't compile

Deuxièmement, start + (end - start) / 2ne débordera pas si startet endsont de grands nombres positifs. Avec les opérandes signés, le débordement n'est pas défini:

int start = 0x7ffffffe, end = 0x7fffffff;
int mid = start + (end - start) / 2; // works as expected
int mid = (start + end) / 2;         // overflow... undefined

(Notez que cela end - startpeut déborder, mais seulement si start < 0ou end < 0.)

Ou avec l'arithmétique non signée, le débordement est défini mais vous donne la mauvaise réponse. Cependant, pour les opérandes non signés, start + (end - start) / 2ne débordera jamais tant que end >= start.

unsigned start = 0xfffffffeu, end = 0xffffffffu;
unsigned mid = start + (end - start) / 2; // works as expected
unsigned mid = (start + end) / 2;         // mid = 0x7ffffffe

Enfin, vous souhaitez souvent arrondir vers l' startélément.

int start = -3, end = 0;
int mid = start + (end - start) / 2; // -2, closer to start
int mid = (start + end) / 2;         // -1, surprise!

Notes de bas de page

¹ Selon la norme C, si le résultat de la soustraction du pointeur n'est pas représentable comme a ptrdiff_t, alors le comportement est indéfini. Cependant, en pratique, cela nécessite d'allouer un chartableau utilisant au moins la moitié de l'espace d'adressage entier.

Nous pouvons prendre un exemple simple pour démontrer ce fait. Supposons que dans un certain grand tableau, nous essayons de trouver le milieu de la plage [1000, INT_MAX]. Maintenant, INT_MAXest la plus grande valeur que le inttype de données peut stocker. Même si1 on ajoute à cela, la valeur finale deviendra négative.

Aussi, start = 1000et end = INT_MAX.

En utilisant la formule: (start + end)/2,

le point médian sera

(1000 + INT_MAX)/2= -(INT_MAX+999)/2, qui est négatif et peut donner une erreur de segmentation si nous essayons d'indexer en utilisant cette valeur.

Mais, en utilisant la formule (start + (end-start)/2), nous obtenons:

(1000 + (INT_MAX-1000)/2)= (1000 + INT_MAX/2 - 500)= (INT_MAX/2 + 500) qui ne débordera pas .

Pour ajouter à ce que d'autres ont déjà dit, le premier explique sa signification plus clairement à ceux qui sont moins mathématiciens:

mid = start + (end - start) / 2

se lit comme suit:

mi est égal au début plus la moitié de la longueur.

tandis que:

mid = (start + end) / 2

se lit comme suit:

milieu est égal à la moitié du début et de la fin

Ce qui ne semble pas aussi clair que le premier, du moins exprimé ainsi.

comme Kos l'a souligné, il peut également lire:

mid est égal à la moyenne du début et de la fin

Ce qui est plus clair mais toujours pas, du moins à mon avis, aussi clair que le premier.

start + (end-start) / 2 peut éviter un éventuel dépassement, par exemple start = 2 ^ 20 et end = 2 ^ 30