常用排序算法的Python实现

冒泡排序

算法思想：

对于一组需要排序的数据，对于相邻的两个数进行比较，使较大（或者较小）的数一直向后推，经过多层排序之后，使整个序列是有序的。

算法实现：

def bubble_sort(L):
length = len(L)
if length == 0 or length == 1:
return L
for i in range(length):
for j in range(length-i-1):
if L[j] > L[j+1]:
temp = L[j]
L[j] = L[j+1]
L[j+1] = temp
return L

print(bubble_sort(data))

算法的实现使用了两层for循环，其中对于外层for循环来说，第一次for循环，最大的数被推到最后面，第二次for循环，次大的数被推到次后面...依次类推，而内层for循环的作用就是实现将当前层次的最大数找出来，向后沉。

复杂度：

• 时间复杂度
  平均情况O(n^2)， 最好情况O(n)， 最坏情况O(n^2)
• 空间复杂度
  O(1)
• 稳定性
  不稳定

快速排序

算法思想：

任意设置一个基准元素，一般是第一个或者最后一个，将序列以该基准元素为基准，分割成比他小的一部分和比他大的一部分，此时，该基准元素所在的位置就是排序终了之后的准确位置，在对左右两边的序列继续执行同样的操作，直整个个序列有序。

算法实现：

def quick_sort(lists, left, right):
if left >= right:
return lists
key = lists[left]     # 用作基准
low = left
high = right
while left < right:
while left < right and lists[right] >= key:
right -= 1
lists[left] = lists[right]
while left < right and lists[left] <= key:
left += 1
lists[right] = lists[left]

lists[right] = key
quick_sort(lists, low, left - 1)
quick_sort(lists, left + 1, high)
return lists

print(quick_sort(data, 0, len(data)-1))

内层的while循环中，以key为基准，从序列的右边找出比key值小的元素，放在key的左边去，再从key的左边找出比key值大的元素，放在key的右边，此时正好填补了放到左边的的那个空位，多次循环，直到序列有序。

复杂度：

• 时间复杂度
  平均情况O(nlog2n)， 最好情况O(nlog2n)， 最坏情况O(n^2)
• 空间复杂度
  O(nlog2n)
• 稳定性
  不稳定

选择排序

算法思想：

在需要排序的一组数中，选出最小（或者最大）的一个数与第一个位置的数交换，然后在剩下的数中在找到最小（或者最大）的数与第二个位置的数交换，一次类推，直到倒数第二个数与倒数第一个数交换完成为止。

算法实现：

def select_sort(L):
length = len(L)
if length == 0 or length == 1:
return L

def _min(s):
'''
实现从后面的值中找到最小值的索引
'''
min = s
for i in range(s, length):
if L[i] < L[min]:
min = i
return min

for i in range(length):
min = _min(i)
if i != min:
temp = L[min]
L[min] = L[i]
L[i] = temp
return L

print(select_sort(data))

每一次循环，都将该次循环的i作为基准，从i后面的数中通过_min()函数来找到后面数据最小值的索引，在for循环的循环体内交换位置，目的是将小值放到前面去。这样，每一次循环，数中最前面的一部分数据是从小到大排序的，直到最后，所有的数据都是有序的为止。

复杂度：

• 时间复杂度
  平均情况O(n^2)， 最好情况O(n^2)， 最坏情况O(n^2)
• 空间复杂度
  O(1)
• 稳定性
  不稳定

归并排序

算法思想：

主题思想是将两个有序表河滨更成为一个新的有序表，将待排序序列分位若干个子序列，每个子序列是有序的，然后在将其合并为一个整体，使用递归的思想。

算法实现：

def merge(left, right):
i, j = 0, 0
result = []
while i < len(left) and j < len(right):
if left[i] <= right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result += left[i:]
result += right[j:]
return result

def merge_sort(lists):
# 归并排序
if len(lists) <= 1:
return lists
num = int(len(lists) / 2)
left = merge_sort(lists[:num])
right = merge_sort(lists[num:])
return merge(left, right)

print(merge_sort(data))

将一个序列一直对半拆分，分为若干个子序列，直到该子序列只有一个元素为止，然后将其合并。因此主要的问题就变成了如何将两个有序序列合并，这里新建一个空序列，遍历比较两个序列，将较小的元素放在新的序列中，直到某一个序列为空，此时很可能另外的一个序列非空，因此需要将剩余的已经有序的元素一次性添加到新建的序列中。

复杂度：

• 时间复杂度
  平均情况O(nlog2n)， 最好情况O(nlog2n)， 最坏情况O(nlog2n)
• 空间复杂度
  O(n)
• 稳定性
  稳定

插入排序

算法思想：

将序列的第一个元素当做已经排序好的序列，然后从后面的第二个元素开始，逐个元素进行插入，直到整个序列有序为止。

算法实现：

def insert_sort(L):

length = len(L)
if length==0 or length==1:
return L
for i in range(1,length):
value = L[i]
j = i-1
while j>=0 and L[j]>value:
L[j+1] = L[j]
j-=1
L[j+1] = value
return L

print(insert_sort(data))

对于for循环来说，第一次循环结束，整个序列的第一个元素是有序的，第二次循环，前面两个元素是有序的，第三次for循环，前面三个元素是有序的...对于while循环来说，只要索引为i的前面某个元素比我们设置的“哨兵”value的值大，就把它放在后面去，直到前面所有的元素均比value小，这时候本次排序结束，本次排序的结果依然是有序的，因为上一次的结果是有序的，我们本次排序只是将一个新的值加入进去，并没有破坏之前的结构，因此将其称之为“插入排序”。

复杂度：

• 时间复杂度
  平均情况O(n^2)， 最好情况O(n)， 最坏情况O(n^2)
• 空间复杂度
  O(1)
• 稳定性
  稳定

希尔排序

算法思想：

希尔排序是对直接插入排序的改进版本，又称为缩小增量排序，将整个序列分割成若干个子序列，分别进行直接插入排序，待各个子序列基本语序后，在对全体进行直接插入排序。

算法实现：

def shell_sort(lists):
count=len(lists)
step=2
group=int(count/step)
while group>0:
for i in range(group):
j=i+group
while j<count:
key=lists[j]
k=j-group
while k>=0:
if lists[k]>key:
lists[k+group]=lists[k]
lists[k]=key
k=k-group
j=j+group
group=int(group/step)
return lists
print(shell_sort(data))