【程序员笔试面试必会——排序①】Python实现 冒泡排序、选择排序、插入排序、归并排序、快速排序、堆排序、希尔排序

最近在准备笔试题和面试题，把学到的东西整理出来，一来是给自己留个笔记，二来是帮助大家学习。

题目：

给定一个int数组A及数组的大小n，请返回排序后的数组。

测试样例：

输入：[1,2,3,5,2,3],6

返回：[1,2,2,3,3,5]

代码示例：

冒泡排序：O(n^2)

　　最基本的排序，不多解释。

class BubbleSort:
def bubbleSort(self, A, n):
for x in xrange(n):
for y in xrange(n-x-1):
if A[y] > A[y+1]:
A[y], A[y+1] = A[y+1], A[y]
return A

选择排序：O(n^2)

　　想象成每次从一大堆数里面选出最小的数放在左边，重复直到这一大对数都被选完。

class SelectionSort:
def selectionSort(self, A, n):
for i in xrange(n-1):
min_index = i
for j in xrange(i+1, n):
if A[min_index] > A[j]:
min_index = j
if min_index != i:
A[i], A[min_index] = A[min_index], A[i]
return A

插入排序：O(n^2)

　　想象成打麻将时，摸到一个排插入到已有的麻将里边。选择排序从左边第二个牌开始，与左边的牌比较，如果比左边的小就与其交换位置，依次重复此步骤，直到排序完所有的牌。

class InsertionSort:
def insertionSort(self, A, n):
for i in xrange(1, n):
tmp = A[i]
j = i - 1
while tmp < A[j] and j >= 0:
A[j+1] =  A[j]
j -= 1
A[j+1] = tmp
return A

归并排序：O(n*log n)

　　分治法思想。把所有的数看成长度为1的有序区间：[1],[2],[3],[5],[2],[3]，再将相邻的区间合并成为最大长度为2的有序区间：[1,2],[3,5],[2,3]，再合并成为最大长度为4的有序区间：[1,2,3,5],[2,3]，再合并：[1,2,2,3,3,5]。

class MergeSort:
def mergeSort(self, A, n):
if n <= 1:
return A
half = n / 2
left = self.mergeSort(A[:half], half)
right = self.mergeSort(A[half:], n-half)

result = []
i = j = 0
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

快速排序：O(n*log n)

　　从这些数中随意选一个数，小于这个数的放在它左边，大于它的放右边；再在这左右两边的一堆数重复使用这个方法，直到排序结束。

class QuickSort:
def quickSort(self, A, n=None):
if not A:
return []
else:
key = A[0]  # 固定每次选择最左边的数
left = self.quickSort([n for n in A[1:] if n <= key])
right = self.quickSort([n for n in A[1:] if n > key])
return left + [key] + right

堆排序：

　　在这里我们借用wiki的定义来说明： 通常堆是通过一维数组来实现的，在阵列起始位置为0的情况中

　　　　(1)父节点i的左子节点在位置(2*i+1);
　　　　(2)父节点i的右子节点在位置(2*i+2);
　　　　(3)子节点i的父节点在位置floor((i-1)/2);

# -*- coding:utf-8 -*-

class HeapSort:
def heapSort(self, A, n):
# 创建大根堆
for i in xrange(n/2 + 1, -1, -1):
self.max_heap_fix(A, i, n)
# 堆排序
for i in xrange(n-1, -1, -1):
A[0], A[i] = A[i], A[0]
self.max_heap_fix(A, 0, i)
return A

def max_heap_fix(self, A, i, n):
"""
:param A: 大根堆、一维数组
:param i: 预修复的子树根节点
:param n: 大根堆总的元素数量
"""
j = i * 2 + 1  # i的左子节点下标
# 当i的左子节点存在时
while j < n:
# 当i的右子节点存在，且大于i的左子节点
if j + 1 < n and A[j] < A[j+1]:
j += 1
# 当i的左右子节点都小于i时，修复大根堆结束
if A[j] < A[i]:
break
# 当i的子节点大于i时，交换节点
A[i], A[j] = A[j], A[i]
i = j  # 将i移向于i交换的节点
j = i * 2 + 1  # i的左子节点下标

希尔排序：

　　插入排序是希尔排序的一种特殊情况，当希尔排序的初始步长为1时，即为插入排序。

class ShellSort:
def shellSort(self, A, n):
step = n / 2
while step > 0:
for i in xrange(step, n):
tmp = A[i]
while i >= step and tmp < A[i-step]:
A[i] = A[i-step]
i -= step
A[i] = tmp
step = step / 2
return A