Python有自己的列表排序方法，就是sorted函数和sort()函数，区别是：sorted函数返回一个有序的序列副本，而sort()函数直接在当前列表进行排序，不创建副本，故sort()函数返回None。一般来说，返回None表示是在 原对象上进行操作，而返回排序的结果则表示创建了一个副本。
代码如下：
unsortedList=[] unsortedList=[55, 91, 63, 71, 72, 7, 74, 16, 4, 31, 100, 51, 94, 35, 49, 46, 43, 59, 18, 17] print sorted(unsortedList) print unsortedList.sort() print unsortedList结果如下：
[4, 7, 16, 17, 18, 31, 35, 43, 46, 49, 51, 55, 59, 63, 71, 72, 74, 91, 94, 100] None [4, 7, 16, 17, 18, 31, 35, 43, 46, 49, 51, 55, 59, 63, 71, 72, 74, 91, 94, 100]
下面我们使用Python来实现常见的几种经典排序算法。
一、冒泡排序
基本思想：从第一个元素开始，每每相邻的两个元素进行比较，若前者比后者大则交换位置。最后两个相邻元素比较完成后，最大的元素形成，然后再次从头开始进行比较，若元素个数为n+1个，则总共需要进行n轮比较就可完成排序（n轮比较后，n个最大的元素已经形成，最后一个元素当然是最小的，就不用再比了）。每轮比较中，每形成一个最大的元素，下一轮比较的时候 就少比较一次，第一轮需要比较n次，第二轮需要比较n-1次，以此类推，第n轮（最后一轮）只需要比较1次就可。这样，列表就排好序了。
按照上面的分析，我们需要两个循环，外循环控制轮数，内循环控制每轮的次数。
实现代码如下：
#冒泡排序
import random
unsortedList=[]
def generateUnsortedList(num):
for i in range(0,num):
unsortedList.append(random.randint(0,100))
print unsortedList
def bubbleSort(unsortedList):
list_length=len(unsortedList)
for i in range(0,list_length-1):
for j in range(0,list_length-i-1):
if unsortedList[j]>unsortedList[j+1]:
unsortedList[j],unsortedList[j+1]=unsortedList[j+1],unsortedList[j]
return unsortedList
generateUnsortedList(20)
print bubbleSort(unsortedList)
二、交换排序
基本思想：从未排序的序列中找到一个最小的元素，放到第一位，再从剩余未排序的序列中找到最小的元素，放到第二位，依此类推，直到所有元素都已排序完毕。假设序列元素总共n+1个，则我们需要找n轮，就可以使该序列排好序。在每轮中，我们可以这样做：用未排序序列的第一个元素和后续的元素依次相比较，如果后续元素小，则后续元素和第一个元素交换位置放到，这样一轮后，排在第一位的一定是最小的。这样进行n轮，就可排序。
实现代码如下：
# 交换排序
def selectionSort(unsortedList):
list_length=len(unsortedList)
for i in range(0,list_length-1):
for j in range(i+1,list_length):
if unsortedList[i]>unsortedList[j]:
unsortedList[i],unsortedList[j]=unsortedList[j],unsortedList[i]
return unsortedList
三、插入排序
基本思想：把序列的第一个元素当成已排序列表中的元素，接着从第二个元素开始，与已排序列表中的元素一一比较，并放到合适的位置。假设有n个元素需要排序，则需要n-1轮插入就可排好序。
实现代码如下：
#插入排序
def insertionSort(unsortedList):
list_length=len(unsortedList)
if list_length<2:
return unsortedList
for i in range(1,list_length):
key=unsortedList[i]
j=i-1
while j>=0 and key<unsortedList[j]:
unsortedList[j+1]=unsortedList[j]
j=j-1
unsortedList[j+1]=key
return unsortedList
四、归并排序
基本思想：归并排序是一种典型的分治思想，把一个无序列表一分为二，对每个子序列再一分为二，继续下去，直到无法再进行划分为止。然后，就开始合并的过程，对每个子序列和另外一个子序列的元素进行比较，依次把小元素放入结果序列中进行合并，最终完成归并排序。
实现代码如下（采用递归方式）：
# 归并排序
def mergeSort(unsortedList):
if len(unsortedList)<2:
return unsortedList
sortedList=[]
left=mergeSort(unsortedList[:len(unsortedList)/2])
right=mergeSort(unsortedList[len(unsortedList)/2:])
while len(left)>0 and len(right)>0:
if left[0]<right[0]:
sortedList.append(left.pop(0))
else:
sortedList.append(right.pop(0))
if len(left)>0:
sortedList.extend(mergeSort(left))
else:
sortedList.extend(mergeSort(right))
return sortedList
五、快速排序
基本思想：快速排序也是一种分治思想，基本思想是先随便在无序列表中找一个元素，以这个元素为基准，其他所有元素都跟该元素比，比该元素小的成为一个子序列，比该元素大的成为另一个子序列，接着重复此过程，最终达到排序效果。我们也用递归的方式来实现。
实现代码如下：
def quickSort(unsortedList):
if len(unsortedList)<2:
return unsortedList
less=[]
greater=[]
middle=unsortedList.pop(0)
for item in unsortedList:
if item<middle:
less.append(item)
else:
greater.append(item)
return quickSort(less)+[middle]+quickSort(greater)
六、堆排序
堆排序使用的是堆这种数据结构，我们这里用列表才存储堆。核心思想：先建立一个最大堆，在建立最大堆的过程中需要不断调整元素的位置。最大堆建立后，顶端元素必定是最大的元素，把该最大元素与最末尾元素位置置换，最大元素就出现在列表末端。重复此过程，直到排序。
实现代码如下：
def maxHeapify(L,heap_size,i):
leftChildIndex=2*i+1
rightChildIndex=2*i+2
# print 'leftChildIndex=',leftChildIndex
# print 'rightChildIndex=',rightChildIndex
largest=i
if leftChildIndex<heap_size and L[leftChildIndex]>L[largest]:
largest=leftChildIndex
if rightChildIndex<heap_size and L[rightChildIndex]>L[largest]:
largest=rightChildIndex
if largest!=i:
L[i],L[largest]=L[largest],L[i]
maxHeapify(L,heap_size,largest)
def buildMaxHeap(L):
heap_size=len(L)
if heap_size>1:
start=heap_size/2-1
# print 'start=',start
while start>=0:
maxHeapify(L,heap_size,start)
start=start-1
def heapSort(L):
heap_size=len(L)
buildMaxHeap(L)
i=heap_size-1
while i>0:
L[0],L[i]=L[i],L[0]
heap_size=heap_size-1
i=i-1
maxHeapify(L,heap_size,0)
return L
写了 这么多排序算法，其实只是为了研究之用，在实际生产过程中，如果需要排序，最好使用Python内置的sort或者sorted，这样运行效率会比较高，因为Python的sort方法会对不同类型的序列采取不同的排序方法，使之效率最大化。
Python有自己的列表排序方法，就是sorted函数和sort()函数，区别是：sorted函数返回一个有序的序列副本，而sort()函数直接在当前列表进行排序，不创建副本，故sort()函数返回None。一般来说，返回None表示是在 原对象上进行操作，而返回排序的结果则表示创建了一个副本。
代码如下：
unsortedList=[] unsortedList=[55, 91, 63, 71, 72, 7, 74, 16, 4, 31, 100, 51, 94, 35, 49, 46, 43, 59, 18, 17] print sorted(unsortedList) print unsortedList.sort() print unsortedList结果如下：
[4, 7, 16, 17, 18, 31, 35, 43, 46, 49, 51, 55, 59, 63, 71, 72, 74, 91, 94, 100] None [4, 7, 16, 17, 18, 31, 35, 43, 46, 49, 51, 55, 59, 63, 71, 72, 74, 91, 94, 100]
下面我们使用Python来实现常见的几种经典排序算法。
一、冒泡排序
基本思想：从第一个元素开始，每每相邻的两个元素进行比较，若前者比后者大则交换位置。最后两个相邻元素比较完成后，最大的元素形成，然后再次从头开始进行比较，若元素个数为n+1个，则总共需要进行n轮比较就可完成排序（n轮比较后，n个最大的元素已经形成，最后一个元素当然是最小的，就不用再比了）。每轮比较中，每形成一个最大的元素，下一轮比较的时候 就少比较一次，第一轮需要比较n次，第二轮需要比较n-1次，以此类推，第n轮（最后一轮）只需要比较1次就可。这样，列表就排好序了。
按照上面的分析，我们需要两个循环，外循环控制轮数，内循环控制每轮的次数。
实现代码如下：
#冒泡排序
import random
unsortedList=[]
def generateUnsortedList(num):
for i in range(0,num):
unsortedList.append(random.randint(0,100))
print unsortedList
def bubbleSort(unsortedList):
list_length=len(unsortedList)
for i in range(0,list_length-1):
for j in range(0,list_length-i-1):
if unsortedList[j]>unsortedList[j+1]:
unsortedList[j],unsortedList[j+1]=unsortedList[j+1],unsortedList[j]
return unsortedList
generateUnsortedList(20)
print bubbleSort(unsortedList)
二、交换排序
基本思想：从未排序的序列中找到一个最小的元素，放到第一位，再从剩余未排序的序列中找到最小的元素，放到第二位，依此类推，直到所有元素都已排序完毕。假设序列元素总共n+1个，则我们需要找n轮，就可以使该序列排好序。在每轮中，我们可以这样做：用未排序序列的第一个元素和后续的元素依次相比较，如果后续元素小，则后续元素和第一个元素交换位置放到，这样一轮后，排在第一位的一定是最小的。这样进行n轮，就可排序。
实现代码如下：
# 交换排序
def selectionSort(unsortedList):
list_length=len(unsortedList)
for i in range(0,list_length-1):
for j in range(i+1,list_length):
if unsortedList[i]>unsortedList[j]:
unsortedList[i],unsortedList[j]=unsortedList[j],unsortedList[i]
return unsortedList
三、插入排序
基本思想：把序列的第一个元素当成已排序列表中的元素，接着从第二个元素开始，与已排序列表中的元素一一比较，并放到合适的位置。假设有n个元素需要排序，则需要n-1轮插入就可排好序。
实现代码如下：
#插入排序
def insertionSort(unsortedList):
list_length=len(unsortedList)
if list_length<2:
return unsortedList
for i in range(1,list_length):
key=unsortedList[i]
j=i-1
while j>=0 and key<unsortedList[j]:
unsortedList[j+1]=unsortedList[j]
j=j-1
unsortedList[j+1]=key
return unsortedList
四、归并排序
基本思想：归并排序是一种典型的分治思想，把一个无序列表一分为二，对每个子序列再一分为二，继续下去，直到无法再进行划分为止。然后，就开始合并的过程，对每个子序列和另外一个子序列的元素进行比较，依次把小元素放入结果序列中进行合并，最终完成归并排序。
实现代码如下（采用递归方式）：
# 归并排序
def mergeSort(unsortedList):
if len(unsortedList)<2:
return unsortedList
sortedList=[]
left=mergeSort(unsortedList[:len(unsortedList)/2])
right=mergeSort(unsortedList[len(unsortedList)/2:])
while len(left)>0 and len(right)>0:
if left[0]<right[0]:
sortedList.append(left.pop(0))
else:
sortedList.append(right.pop(0))
if len(left)>0:
sortedList.extend(mergeSort(left))
else:
sortedList.extend(mergeSort(right))
return sortedList
五、快速排序
基本思想：快速排序也是一种分治思想，基本思想是先随便在无序列表中找一个元素，以这个元素为基准，其他所有元素都跟该元素比，比该元素小的成为一个子序列，比该元素大的成为另一个子序列，接着重复此过程，最终达到排序效果。我们也用递归的方式来实现。
实现代码如下：
def quickSort(unsortedList):
if len(unsortedList)<2:
return unsortedList
less=[]
greater=[]
middle=unsortedList.pop(0)
for item in unsortedList:
if item<middle:
less.append(item)
else:
greater.append(item)
return quickSort(less)+[middle]+quickSort(greater)
六、堆排序
堆排序使用的是堆这种数据结构，我们这里用列表才存储堆。核心思想：先建立一个最大堆，在建立最大堆的过程中需要不断调整元素的位置。最大堆建立后，顶端元素必定是最大的元素，把该最大元素与最末尾元素位置置换，最大元素就出现在列表末端。重复此过程，直到排序。
实现代码如下：
def maxHeapify(L,heap_size,i):
leftChildIndex=2*i+1
rightChildIndex=2*i+2
# print 'leftChildIndex=',leftChildIndex
# print 'rightChildIndex=',rightChildIndex
largest=i
if leftChildIndex<heap_size and L[leftChildIndex]>L[largest]:
largest=leftChildIndex
if rightChildIndex<heap_size and L[rightChildIndex]>L[largest]:
largest=rightChildIndex
if largest!=i:
L[i],L[largest]=L[largest],L[i]
maxHeapify(L,heap_size,largest)
def buildMaxHeap(L):
heap_size=len(L)
if heap_size>1:
start=heap_size/2-1
# print 'start=',start
while start>=0:
maxHeapify(L,heap_size,start)
start=start-1
def heapSort(L):
heap_size=len(L)
buildMaxHeap(L)
i=heap_size-1
while i>0:
L[0],L[i]=L[i],L[0]
heap_size=heap_size-1
i=i-1
maxHeapify(L,heap_size,0)
return L
写了 这么多排序算法，其实只是为了研究之用，在实际生产过程中，如果需要排序，最好使用Python内置的sort或者sorted，这样运行效率会比较高，因为Python的sort方法会对不同类型的序列采取不同的排序方法，使之效率最大化。