In most sorting algorithms that use the divide and conquer approach, you'd need to find the middle index between two indices. If l is the left index and r is the right index, then our most obvious approach towards finding the half or middle of the two is <code>m = (l+r)/2</code>. But, this can create an integer overflow when both l &amp; r are large. Here's why, you must use: <code>m = l + (r-l)/2</code>:
Suppose you have l &amp; r as:
<pre><code class="lang-cpp">int l = INT_MAX;
int r = INT_MAX;
</code></pre>
Using <code>int m = (l+r)/2</code> we would get:
<code>m = (INT_MAX + INT_MAX) / 2</code> in which <code>(INT_MAX + INT_MAX)</code> creates an integer overflow.
Now, if we use <code>int m = l + (r-l)/2</code>:
<code>m = INT_MAX + (INT_MAX - INT_MAX)/2</code> and, here we do not have an integer overflow.
But, this process will not prevent integer overflow in cases when l &amp; r are large numbers of opposite signs, eg:
<pre><code class="lang-cpp">int l = INT_MAX;
int r = INT_MIN;
</code></pre>
In fact, it will create an integer overflow in this case whereas <code>(l+r)/2</code> will not.
But, as long as we're talking about sorting algorithms, l &amp; r are indices (0&lt;=l&lt;r), therefore they will both be positive. Thus, using <code>l+(r-l)/2</code> over <code>(l+r)/2</code> helps prevent integer overflow in sorting algorithms.
<hr />
Photo by <a target="_blank" href="https://unsplash.com/@scienceinhd?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Science in HD</a> on <a target="_blank" href="https://unsplash.com/s/photos/maths?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a>
<hr />
I hope you never forget this 😁️. Follow me on [Twitter](<a href="https://twitter.com/satyamsundaram3" class="autolinkedURL autolinkedURL-url" target="_blank">twitter.com/satyamsundaram3</a>) for more such insights on tech &amp; startups.

In most sorting algorithms that use the divide and conquer approach, you'd need to find the middle index between two indices. If l is the left index and r is the right index, then our most obvious approach towards finding the half or middle of the two is `m = (l+r)/2`. But, this can create an integer overflow when both l & r are large. Here's why, you must use: `m = l + (r-l)/2`:

Suppose you have l & r as:

```cpp
int l = INT_MAX;
int r = INT_MAX;
```

Using `int m = (l+r)/2` we would get:

`m = (INT_MAX + INT_MAX) / 2` in which `(INT_MAX + INT_MAX)` creates an integer overflow.

Now, if we use `int m = l + (r-l)/2`:

`m = INT_MAX + (INT_MAX - INT_MAX)/2` and, here we do not have an integer overflow.

But, this process will not prevent integer overflow in cases when l & r are large numbers of opposite signs, eg:

```cpp
int l = INT_MAX;
int r = INT_MIN;
```

In fact, it will create an integer overflow in this case whereas `(l+r)/2` will not.

But, as long as we're talking about sorting algorithms, l & r are indices (0&lt;=l&lt;r), therefore they will both be positive. Thus, using `l+(r-l)/2` over `(l+r)/2` helps prevent integer overflow in sorting algorithms.

---

Photo by [Science in HD](https://unsplash.com/@scienceinhd?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) on [Unsplash](https://unsplash.com/s/photos/maths?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText)

---

I hope you never forget this 😁️. Follow me on \[Twitter\](https://twitter.com/satyamsundaram3) for more such insights on tech & startups.

In most sorting algorithms that use the divide and conquer approach, you'd need to find the middle index between two indices. If l is the left index and...

Why use left+(right-left)/2 instead of (left+right)/2 in sorting algorithms?