三种排序算法的python实现+装饰器统计每种算法耗时

第一部分，先讨论三种排序算法(以从小到大为例)的python实现：

1.普通的方法：
思路比较简单：通过循环遍历列表，每次取出一个最小值，放到一个新的列表中，并且删除原列表中那个遍历出的最小值。最后返回新的列表即是按照从小到大排序好了的。这种排序方法需要额外分配一块空间用来盛放新的列表，因此，空间复杂度会比较高(关于时空复杂度的问题，还没搞清楚，欢迎大牛赐教~)

def common_sort(array):
    res_array = []
    while True:
        if len(array) > 0:
            temp = array[0]
            for item in array:
                if item < temp:
                    temp = item
            res_array.append(temp)
            array.remove(temp)
        else:
            break
    return res_array

第二种：quick sort
思路：从列表中取出第一个元素作为基准数，将比该基准数小的都放在它左边，比基准数大的都放在右边，这样以该基准数作为分隔，就把原列表分隔成两部分，再对每部分执行上一步的分隔操作，直到各个区间只有一个元素为止。快爬采用这种递归算法，每次切割列表，如果对大数据集进行排序，效果应该比较好，快排是冒泡排序的改进版。

def sub_sort(array,low,high):#low 和 high 为游标
    key = array[low]
    while low < high:
        while low < high and array[high] >= key:
            high -= 1
        while low < high and array[high] < key:
            array[low] = array[high]
            low += 1
            array[high] = array[low]

        array[low] = key
    return low

def quick_sort(array,low,high): #实现递归的函数
    if low < high:
        key_index = sub_sort(array,low,high)
        quick_sort(array,low,key_index)
        quick_sort(array,key_index + 1,high)
    return array

第三种：冒泡排序
思路：比较相邻的两个元素，把较小的向左移动，两层的循环操作之后，就把所有元素按照从小到大排好序了。

def bubble_sort(array):
    for i in range(len(array) - 1):
        for j in range(i+1,len(array)):
            if array[i] > array[j]:
                temp = array[j]
                array[j] = array[i]
                array[i] = temp
    return array

第二部分：装饰器的实现

为了记录每种算法进行排序的耗时，因此写一个装饰器函数是最好的实现方法，对原函数进行包装，增加计算耗时的代码段。装饰器函数如下：

#装饰器函数一定要放在被装饰函数的之前，否则会出现nameError
def tsfunc(func):
    def wrappedFunc(*args,**kargs):
        start = time.clock()
        action = func(*args,**kargs)
        time_delta = time.clock() - start
        print '[%s] %s() called,time delta : %s' %(ctime(),func.__name__,time_delta)
        return action
    return wrappedFunc

需要对原函数挂上该装饰器函数，如下形式：

@tsfunc
def quick_sort(array,low,high):
    <function body>
@tsfunc
def common_sort(array):
    <function body>
@tsfunc
def bubble_sort(array):
    <function body>

运行一下代码：

if __name__ == '__main__':
    array = [4,5,2,4,6,9,0,18,2,3,5]
    print array
    common_sort(array)
    array = [4,5,2,4,6,9,0,18,2,3,5]
    quick_sort(array,0,len(array) - 1)
    array = [4,5,2,4,6,9,0,18,2,3,5]
    bubble_sort(array)

输出结果：
[4, 5, 2, 4, 6, 9, 0, 18, 2, 3, 5]

[Sun Jul 03 20:52:39 2016] common_sort() called,time delta : 2.92512113273e-05
[Sun Jul 03 20:52:39 2016] quick_sort() called,time delta : 1.53953743828e-06
[Sun Jul 03 20:52:39 2016] quick_sort() called,time delta : 1.53953743828e-06
[Sun Jul 03 20:52:39 2016] quick_sort() called,time delta : 0.000220923622393
[Sun Jul 03 20:52:39 2016] quick_sort() called,time delta : 3.46395923613e-06
[Sun Jul 03 20:52:39 2016] quick_sort() called,time delta : 0.00830811378567
[Sun Jul 03 20:52:39 2016] quick_sort() called,time delta : 0.016537711162
[Sun Jul 03 20:52:39 2016] quick_sort() called,time delta : 0.0244655592004
[Sun Jul 03 20:52:39 2016] quick_sort() called,time delta : 1.92442179785e-06
[Sun Jul 03 20:52:39 2016] quick_sort() called,time delta : 0.0311787122
[Sun Jul 03 20:52:39 2016] quick_sort() called,time delta : 7.69768719142e-07
[Sun Jul 03 20:52:39 2016] quick_sort() called,time delta : 1.53953743828e-06
[Sun Jul 03 20:52:39 2016] quick_sort() called,time delta : 0.00640640016504
[Sun Jul 03 20:52:39 2016] quick_sort() called,time delta : 1.15465307871e-06
[Sun Jul 03 20:52:39 2016] quick_sort() called,time delta : 1.92442179785e-06
[Sun Jul 03 20:52:39 2016] quick_sort() called,time delta : 1.92442179785e-06
[Sun Jul 03 20:52:39 2016] quick_sort() called,time delta : 0.00519786327599
[Sun Jul 03 20:52:39 2016] quick_sort() called,time delta : 0.0108987704099
[Sun Jul 03 20:52:39 2016] quick_sort() called,time delta : 0.0224025790331
[Sun Jul 03 20:52:39 2016] quick_sort() called,time delta : 3.46395923613e-06
[Sun Jul 03 20:52:39 2016] quick_sort() called,time delta : 0.0277670972368
[Sun Jul 03 20:52:39 2016] quick_sort() called,time delta : 0.0640505306978
[Sun Jul 03 20:52:39 2016] bubble_sort() called,time delta : 3.00209800464e-05
可见快排采用递归的算法，每次执行quick_sort()函数，都会调用装饰器函数，所以造成quick_sort被执行的次数较多，换言之，排序结果也体现出了递归过程

通过统计耗时：
排序方法： quick_sort commnon_sort bubble_sort
耗时(s): 0.2174535050 0.0000292512 0.0000300210

可见小样本的时候快排是多么不占优势，其余二者耗时相近，但是在不考虑空间限制 和 小样本 条件下 最通用的commmon_sort 确实耗时最短的，大样本下未验证，如说法有误，烦请更正（对复杂度真心不熟。。。）