In this blog post, we'll take a question-driven approach to understand the fundamentals of the insertion sort algorithm. I came up with this approach when I was trying to find a better way to understand the insertion algorithm and others that I will soon be learning about. I wanted to build a strategy that I could apply to most, if not all, of the algorithms I will be learning. While I was thinking about this, I was sure that I might have to use first principles thinking
Inspired by first principles thinking, this approach involves first trying to grasp the algorithm, whether our initial understanding is vague or clear. We then identify the tiny concepts or mechanics involved that make up the algorithm. By forming questions around these mechanics or tiny concepts. We are essentially trying to understand the working of the algorithm from small different perspectives with a focus on trying to solve the questions that we formed on our own.
The answer you form may or may not initially resemble the syntax used in the actual algorithm. The goal should be to answer the question on your own, regardless of whether the syntax is close or not. Once you have a clear understanding, you can then convert, merge your answer(s) to use syntax, similar to the actual implementation of the algorithm. I believe this process allows you to explore alternative forms of code , grasp why a specific syntax is being used, deal with edge cases in a better way on your own.
I believe this method ensures that we understand the theory and the reasoning behind each line of code, making the implementation process more intuitive and meaningful. The following questions and the thought process which i went through helped me understand Insertion Sort better and enabled me to code it effectively.
For you, the questions might be different; they could be more, fewer, or entirely different. Some might say this is akin to reverse engineering, whatever you call it, this method enabled me get a thorough understanding of the Insertion Sort algorithm. I hope it does the same for you for any other other algorithm. Soo, let’s dive in!
Insertion Sort Implementation
This is the form of code we will eventually implement for Insertion Sort.
def insertion_sort(values):
for new_value_index in range(1,len(values)):
new_value = values[new_value_index]
index = new_value_index-1
while index>=0:
if values[index]<new_value:break
values[index+1] = values[index]
index-=1
values[index+1] = new_value
登入後複製
Questions
Given a sorted list, using while loop, print values from right to left.
values = [4,8,12,16,20,24,30]
# given a sorted list, using while loop, print values from right to left.
index = len(values)-1
while index>=0:
print(values[index],end = " ")
index-=1
登入後複製
Given a sorted list and a new value, find the index at which the new value is to be inserted to keep the list sorted.
values = [4, 8, 12, 16, 20, 24]
new_value = 14
# using while loop, if traversing from right to left
index = len(values)-1
while index>=0:
if values[index]<new_value: break
index-=1
print(values,new_value,index)
登入後複製
Given a sorted list and a new value, insert the new value to the list so it remains sorted.
values = [4, 8, 12, 16, 20, 24]
new_value = 14
# if traversal from right to left
index = len(values)-1
while index>=0:
if values[index]<new_value:break
index-=1
values = values[:index+1] + [new_value] + values[index+1:]
print(values)
登入後複製
Given a sorted list, then appended with a new value, move the new value to the given index position.
values = [4, 8, 12, 16, 20, 24, 30]
new_value = 14
values.append(new_value)
given_index = 3
# above given
n = len(values)-1
index = n-1
while index>given_index:
values[index+1] = values[index]
index-=1
print(values)
values[given_index+1] = new_value
print(values)
登入後複製
Given a sorted list, then appended with a new value, sort the list.
values = [4, 8, 12, 16, 20, 24, 30]
new_value = 14
values.append(new_value)
print(values)
### given a sorted list, then appended with new value, sort the list
####
n = len(values)-1
new_value = values[-1]
# find the index at which the value is to be inserted
# right to left
index = n-1
while index>=0:
if values[index]<new_value:break
index-=1
given_index = index
print("given_index : " , given_index)
# move the values forward by one step until we reach the given index
index = n-1
while index>given_index:
values[index+1] = values[index]
index-=1
values[index+1] = new_value
print(values)
登入後複製
Given a sorted list, then appended with a new value(s), sort the list.
values = [4, 8, 12, 16, 20, 24, 30]
new_values = [14,32]
values += new_values
print(values)
# given a sorted list, then appended with two new value(s), sort the list
n = len(values)-1
new_value_start_index = n - 1
print(new_value_start_index, values[new_value_start_index])
for new_value_index in range(new_value_start_index,len(values)):
new_value = values[new_value_index]
index = new_value_index-1
while index>=0:
if values[index]<new_value: break
values[index+1] = values[index]
index-=1
values[index+1] = new_value
print(values)
登入後複製
Given a list, sort it.
import random
values = random.sample(range(10,90), k = 10)
values
登入後複製
print(values)
for new_value_index in range(1,len(values)):
new_value = values[new_value_index]
index = new_value_index-1
while index>=0:
if values[index]<new_value:break
values[index+1] = values[index]
index-=1
values[index+1] = new_value
print(values)
登入後複製
Insertion Sort Implementation
def insertion_sort(values):
for new_value_index in range(1,len(values)):
new_value = values[new_value_index]
index = new_value_index-1
while index>=0:
if values[index]<new_value:break
values[index+1] = values[index]
index-=1
values[index+1] = new_value
登入後複製
Additional Resources
While I initially worked through a comprehensive set of questions to understand the algorithm better, the above are a set of questions that I think are important to understand Insertion Sort in a better way. Including all of the questions that I worked on would make the post quite lengthy.
For those interested in seeing all of the questions, I have created a Jupyter Notebook containing the full set of questions with my own answers, which enabled me to understand the implementation of Insertion Sort completely.
I encourage you to check out the notebook if you want to delve further.
Corrections and suggestions are welcome.
以上是理解插入排序：問題驅動的方法的詳細內容。更多資訊請關注PHP中文網其他相關文章！
