排序算法总结（python实现）

排序算法总结（python实现）

总结排序算法。

分别是冒泡排序，选择排序，插入排序，希尔排序，归并排序和快速排序。

冒泡排序：

比较相邻的两个元素，如果次序不对，就交换位置。每次遍历都把经历的最大的元素放到合适的位置上。就象气泡上浮到合适的位置。



图中为列表的第一次遍历，第一次遍历可将列表中最大的元素推到列表末尾。

重复n-1次，完成整个列表的排序。时间复杂度为O(n^2)

一种改进方法为短冒泡排序，即增加一个标志位。

短冒泡程序代码如下:

#短冒泡程序 添加了一个标志位，代表这次遍历是否有数据交替
#如果没有，则认为排序已经完成。
def small_bubbleSort(alist):
exchange=True
passnum=len(alist)-1
while exchange and passnum>0:
exchange=False
for i in range(passnum):
if alist[i]>alist[i+1]:
exchange=True
temp = alist[i]
alist[i] = alist[i+1]
alist[i+1] = temp
passnum-=1

alist = [54,26,93,17,77,31,44,55,20]
small_bubbleSort(alist)
print(alist)

选择排序：

第一次遍历列表，得到列表list[:]中的最大值，将其与列表list[-1]交换。

第二次遍历列表，得到列表list[:-1]中的最大值，将其与列表list[-2]交换。

重复n-1次(n为列表长度)，排序完成。



代码如下：

def xuanze(items):
for passnum in range(len(items)-1,0,-1):
pos_max=0
for i in range(1,passnum+1):
if items[i]>items[pos_max]:
pos_max=i
temp = items[passnum]
items[passnum]=items[pos_max]
items[pos_max]=temp

alist2 = [54,26,93,17,77,31,44,55,20]
xuanze(alist2)
print(alist2)

选择排序的时间复杂度为：O(n^2)

插入排序：

第一步指定列表当中的第一个元素是有序的(因为只有一个。)

第二步，将第二个元素与第一个元素进行比较，根据大小情况进行位置交换，实现长度为二的有列表表。

第三部，将第三个元素与有列表表中的第二个元素比较，如果大于第二个元素(则同样大于第一个元素)，位置不变。如果小于第二个元素，继续与第一个元素进行比较，按照大小情况进行位置交换，实现长度为三的有列表表。

最终实现整个列表的排序。



插入排序最大需要前n-1个整数和次比对。所以复杂度为O(n^2) .

代码如下：

def charu(items):
for item in range(1,len(items)):
pos=item
current=items[pos]
while pos>0 and items[pos-1]>current:#从后往前进行比较。
items[pos]=items[pos-1]
pos-=1
items[pos]=current
alist3 = [54,26,93,17,77,31,44,55,20]
charu(alist3)
print(alist3)

希尔排序：

以插入排序为基础，将原来的列表分为以gap为间隔的子列表，对每一个列表进行插入排序。

进行递归gap=gap//2，直到gap==1。

对于 9 1 2 5 7 4 8 6 3 5 这10个数。初始gap为(10//2)

第一步进行gap为5为间隔取数，可以得到五组(9,4) (1,8) (2,6) (5,3) (7,5),对每组进行插入排序。

整个列表为 4 1 2 3 5 9 8 6 5 7.

第二步进行gap为5//2为间隔取数，可以得到(4,2,5,8,5) 和(1,3,9,6,7)两组。对每组进行插入排序。

整个列表为2 1 4 3 5 6 5 7 8 9.

第三步进行gap为2//2为间隔取数，可以得到(2,1,4,3,5,6,5,7,8,9)一组，对该组进行插入排序。

整个列表为 1 2 3 4 5 5 6 7 8 9. 排序完成。

代码如下：

def shellSort(alist):
sublistcount = len(alist)//2
while sublistcount > 0:
for startposition in range(sublistcount):
gapInsertionSort(alist,startposition,sublistcount)
print("After increments of size",sublistcount,
"The list is",alist)

sublistcount = sublistcount // 2

def gapInsertionSort(alist,start,gap):
for i in range(start+gap,len(alist),gap):
currentvalue = alist[i]
position = i
while position>=gap and alist[position-gap]>currentvalue:
alist[position]=alist[position-gap]
position = position-gap

alist[position]=currentvalue

alist = [9,1,2,5,7,4,8,6,3,5]
shellSort(alist)
print(alist)

希尔排序的一个特点，一个列表以5为间隔有序，那么他一定是部分有序的，在以3为间隔进行排序。排序后的结果既以间隔3有序，也必定以间隔5有序。

一个部分有序的列表进行插入排序所需的时间，一定小于无序的列表直接进行插入排序。

希尔排序的时间复杂度为O(n)~O(n^2)之间 。

希尔排序的初始gap一般为 列表的长度//2。

归并排序：

归并排序分为两个部分。

首先，对整个列表进行对半切分，如子列表长度等于1，则将其视为有序，不在做处理，否则，对其继续进行对半切分，直到长度等于1。(显而易见这是个递归操作)

注意，需要额外的空间存放对半切分后的子列表。



然后对每个列表进行合并，



第一步：申请空间，使其大小为两个已经排列表表之和，该空间用来存放合并后的列表

第二步：设定两个指针，最初位置分别为两个已经排列表表的起始位置

第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置

重复步骤3直到某一指针超出列表尾

将另一列表剩下的所有元素直接复制到合并列表尾

代码如下：

def mergeSort(alist):
print("Splitting ",alist)
if len(alist)>1:
mid = len(alist)//2
#利用
lefthalf = alist[:mid]
righthalf = alist[mid:]
mergeSort(lefthalf)
mergeSort(righthalf)
i=0#左边列表的索引
j=0#右边列表的索引
k=0#总和列表的索引
print '-----'
while i<len(lefthalf) and j<len(righthalf):
if lefthalf[i]<righthalf[j]:  # 比对left和right位置的值，从0开始
alist[k]=lefthalf[i]    #将两边i,j对应值较小的一项填入alist
i=i+1       #填入后k+1,i+1或者j+1
else:
alist[k]=righthalf[j]
j=j+1
k=k+1
while i<len(lefthalf): #如果出现左右两边长度不相等的情况，那么总会有
alist[k]=lefthalf[i]#一边的i或j小于其长度，这一边会是较长的一边
i=i+1
k=k+1
while j<len(righthalf):
alist[k]=righthalf[j]
j=j+1
k=k+1
print("Merging ",alist)

alist = [54,26,93,17,77,31,44,55,20]
mergeSort(alist)
print(alist)

归并排序要把列表一分为二，对于长度为n的列表，其复杂度与二分查找相同，为O(logn)，且每一步操作还包括n步合并，所以其最终时间复杂度为O(nlogn)。

快速排序：

这一节图片来自于[]http://developer.51cto.com/art/201403/430986.htm]

设实例列表为6 1 2 7 9 3 4 5 10 8。

以第一个元素6为轴点，将其设为左端点 i,以最后一个元素为右端点，将其设为j。



右端点开始向左移动，在遇到第一个大于轴点数的时候停下来，左端点开始向右移动，在遇到第一个小于轴点数的时候停下来。如下图：



左端点i停在了7上，右端点j停在了5上，将左右端点的值进行交换。是的左端点对应的值小于轴点，同时右端点的值大于轴点。



然后右端点先从7开始向左出发，预计将会在4的地方停下来，然后左端点i继续从5出发，预计将会在9的地方停下来。如下图：



再次将左右端点的值进行交换



然后右端点继续出发，在3的地方停下来，然后左端点出发，将会在3的地方遭遇右端点。当两个端点遭遇时，两者停止移动。



然后将轴点与遭遇点进行交换。





到此第一轮真正结束。此时以基准数6为分界点，6左边的数都小于等于6，6右边的数都大于等于6。回顾一下刚才的过程，其实哨兵j的使命就是要找小于基准数的数，而哨兵i的使命就是要找大于基准数的数，直到i和j碰头为止。

将原来的列表，以6为分界点拆分成了两个列表，左边的列表是“3 1 2 5 4”，右边的列表是“9 7 10 8”。接下来还需要分别处理这两个列表。因为6左边和右边的列表目前都还是很混乱的。

对于左右列表采用同样的处理方式。（同样是一个递归过程，递归终止条件是左右切分后列表的长度为1）。

代码如下：

def sort(items):
sort_help(items,0,len(items)-1)

def sort_help(items,first,last):
if first>=last:
return
tmp=items[first]
left=first#以first为起点
right=last
while left!=right:
while items[right]>=tmp and left<right:#必须先移动右端点。
right-=1
while items[left]<=tmp and left<right:
left+=1
if left<right:
items[left],items[right]=items[right],items[left]
#因为此时left==right,所以将first和left位置上的值进行交换
items[first],items[left]=items[left],items[first]

sort_help(items,first,right-1)#进行递归  right==left
sort_help(items,right+1,last)

alist=[54,26,93,17,77,31,44,55,20]
sort(alist)
print(alist)

总结：

冒泡、选择、插入排序的时间复杂度都为O(n^2)。

希尔排序是插入排序的改进，在O(n)与O(n^2)之间。

归并排序的时间复杂度为O(nlogn)，但合并过程需要额外存储空间。

快速排序的时间复杂度一般为O(nlogn)，最坏情况为O(n^2)，但不需要额外存储空间。