merge sort
Merge sort is a very typical application of divide and conquer method. The idea of merge sort is to recursively decompose the array first, and then merge the array.
After decomposing the array to the smallest, and then merging the two ordered arrays, the basic idea is to compare the first number of the two arrays, whichever is smaller, and the corresponding pointer is moved one bit backward. Then compare until one array is empty, and finally copy the rest of the other array.
Merge Sort Analysis
def merge_sort(alist):
'''Merge sort'''
n = len (alist)
if n<=1:
return alist
mid=n//2
#left After decomposition, the left is an ordered new list formed by merge sort
left_list=merge_sort(alist[:mid])
# After the left is decomposed, the right is an ordered new list formed by merge sort
right_list=merge_sort(alist[mid:])
# Merge two ordered subsequences into a new whole
# merge(left,right)
# Left and right sequence cursors
left_pointer,right_pointer=0,0
#Create a list to store the result value after the judgment
result=[]
while (left_pointer<len(left_list)) and (right_pointer<len(right_list)):
if left_list[left_pointer]<=right_list[right_pointer]:
result.append(left_list[left_pointer])
left_pointer+=1
else:
result.append(right_list[right_pointer])
right_pointer+=1
result+=left_list[left_pointer:]
result+=right_list[right_pointer:]
return result
alist=[54,226,93,17,77,31,44,55,20]
ml=merge_sort(alist)
print(alist)
print(ml)
#merge_sort recursive analysis alist=[54,226,93,17,77,31,44,55,20]
'''
1. Enter recursive left
mid=4-->merge_sort(alist[:4])-->a_list=[54,226,93,17]
2. Enter recursive left
-->mid=2-->merge_sort(alist[:2])-->a_list=[54,226]
3. Enter recursive left
-->mid=1-->merge_sort(alist[:1])-->n=1-->return left_list=[54]
3. Enter recursion right
-->mid=1-->merge_sort(alist[1:])-->n=1-->return right_list=[226]
return sorted list
result=[]-->:return left_list=[54,226]
2. Enter recursion right
-->mid=2-->merge_sort(alist[2:])-->a_list=[93,17]
3. Enter recursive left
-->mid=1-->merge_sort(alist[:1])-->n=1-->return left_list=[93]
3. Enter recursion right
-->mid=1-->merge_sort(alist[1:])-->n=1-->return right_list=[17]
result=[]-->:return right_list=[17,93]
result=[]-->:return left_list=[17,54,93,226]
1. Enter recursion right
mid=4-->merge_sort(alist[4:])-->a_list=[77,31,44,55,20]
2. Enter recursive left
-->mid=2-->merge_sort(alist[:2])-->a_list=[77,31]
3. Enter recursive left
-->mid=1-->merge_sort(alist[:1])-->n=1-->return left_list=[31]
3. Enter recursion right
-->mid=1-->merge_sort(alist[1:])-->n=1-->return right_list=[77]
return sorted list
result=[]-->:return left_list=[31,77]
2. Enter recursion right
-->mid=2-->merge_sort(alist[2:])-->a_list=[44,55,20]
3. Enter recursive left
-->mid=1-->merge_sort(alist[:1])-->n=1-->return left_list=[44]
3. Enter recursion right
-->mid=1-->merge_sort(alist[1:])-->n=2
3. Enter recursive left
-->mid=1-->merge_sort(alist[:1])-->n=1-->return left_list=[55]
3. Enter recursion right
-->mid=1-->merge_sort(alist[1:])-->n=1-->return right_list=[20]
result=[]-->:return right_left=[20,55]
result=[]-->:return right_list[20,44,55]
result=[]-->:return right_left=[20,31,44,55,77]
Merge sort result=[17, 20, 31, 44, 54, 55, 77, 93, 226]
'''
time complexity
- Optimal time complexity: O(nlogn)
- Worst time complexity: O(nlogn)
- Stability: stable
Efficiency comparison of common sorting algorithms
In general interviews, you need to master several sorting algorithms, and quick sorting must be mastered as much as possible.