Insertion Sort - troubles reading MIT Intro to Algos - algorithm

Question

The MIT Intro to Algorithms describes insertion sort as:
I wrote this in Python as:
def sort(A):
for j in range(1, len(A)):
key = A[j];
i = j - 1;
# i > 0 should be i >= 0
while i > 0 and A[i] > key:
A[i + 1] = A[i]
i = i - 1;
A[i + 1] = key
return A
However the line while i > 0 introduces a bug - the first two keys are in the wrong positions. Changing this to while i >= 0 fixes this problem.
Why is this not included in the MIT Intro book? Am I reading it wrong?

Answer 1

The algorithm in the book is assuming indexing from 1 to A.length, inclusive, which is why it starts at an index of 2. Python has array indexing from 0 to len(A) - 1. You corrected for that in your range, but you neglected to correct for it in the loop test. Doing so fixes the problem.

Answer 2

#pjs is exactly right. I'll add that a methodical way to convert an algorithm written for 1-based arrays to 0-based with no off-by-1 errors is to use the algorithm as-is except subtract 1 at each array reference and then use algebra to simplify. Here you'd end up with:
def sort(A):
for j in range(2, len(A) + 1): # +1 is because Python ranges exclude high limit
key = A[j - 1]
i = j - 1
while i > 0 and A[i - 1] > key:
A[i + 1 - 1] = A[i - 1]
i = i - 1
A[i + 1 - 1] = key
return A
Of course it's easy to simplify by removing + 1 - 1, since that's adding zero! The result works fine.
If you want to make the code prettier with the outer range starting at 1 rather than 2, make the substitution jj = j - 1, which (adding 1 to both sides) means j = jj + 1:
def sort(A):
for jj in range(1, len(A)):
key = A[jj + 1 - 1]
i = jj + 1 - 1
while i > 0 and A[i - 1] > key:
A[i] = A[i - 1]
i = i - 1
A[i] = key
return A
Again removing + 1 - 1s, we have
def sort(A):
for jj in range(1, len(A)):
key = A[jj]
i = jj
while i > 0 and A[i - 1] > key:
A[i] = A[i - 1]
i = i - 1
A[i] = key
return A
This looks great, and I'd stop here. But yet another variation is possible with the substitution ii = i - 1 or i = ii + 1.
def sort(A):
for jj in range(1, len(A)):
key = A[jj]
ii + 1 = jj
while ii + 1 > 0 and A[ii + 1 - 1] > key:
A[ii + 1] = A[ii + 1 - 1]
ii + 1 = ii + 1 - 1
A[ii + 1] = key
return A
Hmmm... Those assignments to ii look weird. But we can straighten everything out with algebra yet again.
def sort(A):
for jj in range(1, len(A)):
key = A[jj]
ii = jj - 1 # Subtracted 1 from both sides
while ii >= 0 and A[ii] > key: # x + 1 > 0 iff x >= 0
A[ii + 1] = A[ii]
ii = ii - 1 # Subtracted 1 from both sides and simplified
A[ii + 1] = key
return A
Lo and behold, we have the code you proposed. Works every time.