#!/usr/bin env python

# 数组编号从 0开始
def left(i):
? ? return 2*i +1
def right(i):
? ? return 2*i+2

#保持最大堆性质 使以i为根的子树成为最大堆
def max_heapify(A, i, heap_size):
? ? if heap_size <= 0:
? ? ? ? return
? ? l = left(i)
? ? r = right(i)
? ? largest = i # 选出子节点中较大的节点
? ? if l < heap_size and A[l] > A[largest]:
? ? ? ? largest = l
? ? if r < heap_size and A[r] > A[largest]:
? ? ? ? largest = r
? ? if i != largest :#说明当前节点不是最大的，下移
? ? ? ? A[i], A[largest] = A[largest], A[i] #交换
? ? ? ? max_heapify(A, largest, heap_size)#继续追踪下移的点
? ? #print A
# 建堆?
def bulid_max_heap(A):
? ? heap_size = len(A)
? ? if heap_size >1:
? ? ? ? node = heap_size/2 -1
? ? ? ? while node >= 0:
? ? ? ? ? max_heapify(A, node, heap_size)
? ? ? ? ? node -=1

# 堆排序 下标从0开始
def heap_sort(A):
? ? bulid_max_heap(A)
? ? heap_size = len(A)
? ? i = heap_size - 1
? ? while i > 0 :
? ? ? ? A[0],A[i] = A[i], A[0] # 堆中的最大值存入数组适当的位置，并且进行交换
? ? ? ? heap_size -=1 # heap 大小 递减 1
? ? ? ? i -= 1 # 存放堆中最大值的下标递减 1
? ? ? ? max_heapify(A, 0, heap_size)

if __name__ == '__main__' :

? ? A = [10, -3, 5, 7, 1, 3, 7]
? ? print 'Before sort:',A
? ? heap_sort(A)
? ? print 'After sort:',A

不稳定，时间复杂度 O(nlog n)

快速排序
快速排序算法和合并排序算法一样，也是基于分治模式。对子数组A[p...r]快速排序的分治过程的三个步骤为：

分解：把数组A[p...r]分为A[p...q-1]与A[q+1...r]两部分，其中A[p...q-1]中的每个元素都小于等于A[q]而A[q+1...r]中的每个元素都大于等于A[q]；
解决：通过递归调用快速排序，对子数组A[p...q-1]和A[q+1...r]进行排序；
合并：因为两个子数组是就地排序的，所以不需要额外的操作。

对于???分partition 每一轮迭代的开始，x=A[r], 对于任何数组下标k，有：

1) 如果p≤k≤i，则A[k]≤x。
2) 如果i+1≤k≤j-1，则A[k]>x。
3) 如果k=r，则A[k]=x。

代码如下：

#!/usr/bin/env python
# 快速排序
'''
划分 使满足 以A[r]为基准对数组进行一个划分，比A[r]小的放在左边，
? 比A[r]大的放在右边
快速排序的分治partition过程有两种方法，
一种是上面所述的两个指针索引一前一后逐步向后扫描的方法,
另一种方法是两个指针从首位向中间扫描的方法。
'''
#p,r 是数组A的下标
def partition1(A, p ,r):
? ? '''
? ? ? 方法一，两个指针索引一前一后逐步向后扫描的方法
? ? '''
? ? x = A[r]
? ? i = p-1
? ? j = p
? ? while j < r:
? ? ? ? if A[j] < x:
? ? ? ? ? ? i +=1
? ? ? ? ? ? A[i], A[j] = A[j], A[i]
? ? ? ? j += 1
? ? A[i+1], A[r] = A[r], A[i+1]
? ? return i+1

def partition2(A, p, r):
? ? '''
? ? 两个指针从首尾向中间扫描的方法
? ? '''
? ? i = p
? ? j = r
? ? x = A[p]
? ? while i < j :
? ? ? ? while A[j] >= x and i < j:
? ? ? ? ? ? j -=1
? ? ? ? A[i] = A[j]
? ? ? ? while A[i]<=x and i < j:
? ? ? ? ? ? i +=1
? ? ? ? A[j] = A[i]
? ? A[i] = x
? ? return i

# quick sort
def quick_sort(A, p, r):
? ? '''
? ? ? ? 快速排序的最差时间复杂度为O(n2)，平时时间复杂度为O(nlgn)
? ? '''
? ? if p < r:
? ? ? ? q = partition2(A, p, r)
? ? ? ? quick_sort(A, p, q-1)
? ? ? ? quick_sort(A, q+1, r)

if __name__ == '__main__':

? ? A = [5,-4,6,3,7,11,1,2]
? ? print 'Before sort:',A
? ? quick_sort(A, 0, 7)
? ? print 'After sort:',A

不稳定，时间复杂度 最理想 O(nlogn)最差时间O(n^2)

说下python中的序列：
列表、元组和字符串都是序列，但是序列是什么，它们为什么如此特别呢？序列的两个主要特点是索引操作符和切片操作符。索引操作符让我们可以从序列中抓取一个特定项目。切片操作符让我们能够获取序列的一个切片，即一部分序列,如：a = ['aa','bb','cc'], print a[0] 为索引操作，print a[0:2]为切片操作。

总结如下：