排序算法总结（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)，但不需要额外存储空间。