今天来谈谈Python中的各种排序总结,含实现代码

下图是各种排序方法的时间复杂度、空间复杂度和稳定性,大牛编程吧教你如何编程提升。

1.直接插入排序。

直接插入的基本思想是每一步将一个数插入到已排序的有序数列中。

python代码实现:

def direct_insert_sort(l):
    for i in range(1,len(l)):
        key = l[i]
        j = i-1
        while j>=0:
            if key<l[j]:
                l[j+1] = l[j]
                l[j] = key
            j -= 1
    return l
a = [2,3,1,5,4,4]

2.Shell排序(希尔排序)。

希尔排序是直接插入排序的改进版本希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止。

python代码实现:

def shell_sort(l):
    c = len(l)
    step = len(l)//2
    while step>0:
        for i in range(step):
            j = i+step
            while j<c:
                key = l[j]
                p = j-step
                while p>=0:
                    if key<l[p]:
                        l[p+step] = l[p]
                        l[p] = key
                    p -= step
                j += step
        step = step//2
    return l
a = [2,3,1,5,4,4]
print(shell_sort(a))  

3.直接选择排序。

直接选择排序是每次找到未排序元素中最小的元素放到最前面具体实现是第一趟将第一个元素与后面所有元素比较,小的放前面,第二趟得到第二个元素,这样直至排序完成。

python代码实现:

def direct_choice_sort(l):
    for i in range(len(l)-1):
        for j in range(i+1,len(l)):
            if l[j]<l[i]:
                l[i],l[j] = l[j],l[i]
    return l
a = [3,1,4,5,2,2]
print(direct_choice_sort(a))  

4.堆排序。

堆排序是一种选择排序,是用堆结构来完成排序的一种算法,升序用大顶堆,降序用小顶堆;构造大顶堆:一个结点i的左右叶子结点为2i+1,2i+2,最后一个非叶子结点为len(l)//2-1,从最后一个非叶子结点起,开始调整,将大的元素放到父结点上。

python代码实现:

def heap_sort(l):
    for j in range(len(l),0,-1):
        #j为堆的长度,c为堆的最大非叶子结点索引
        c = (j//2)-1
        #从最大非叶子结点开始调整堆
        for i in range(c,-1,-1):
            if (2*i+1)<=(j-1) and l[2*i+1]>l[i]:
                l[i],l[2*i+1] = l[2*i+1],l[i]
            if (2*i+2)<=(j-1) and l[2*i+2]>l[i]:
                l[i],l[2*i+2] = l[2*i+2],l[i]
        #交换堆顶与最后一个结点
        l[0],l[j-1] = l[j-1],l[0]
    return l
a = [67,65,77,38,97,3,33,49,33]
#heap(a)
print(heap_sort(a))

5.冒泡排序。

冒泡排序是从后向前每次比较相邻的2个元素大小,大的放后面,这样一次遍历第一个元素就是最小的,第二次遍历第二个元素就是剩下中最小的,这样直到排序完成。

python代码实现:

def Bubble_sort(l):
    c = len(l)
    for i in range(1,c):
        for j in range(c-1,i-1,-1):
            if l[j] < l[j-1]:
                l[j],l[j-1] = l[j-1],l[j]
    return l
a = [3,1,4,5,2,2]
print(Bubble_sort(a))  

6.快速排序。

快速排序的思想是每次任意取一个元素,如第一个,将剩下比它小的元素的放到它的前面,大的放到它的后面,这样这个元素就已经在最终排序完成的位置上了,然后对小的元素和大的元素继续进行快速排序,这样直至排序完成。

python代码实现:

quick_sort = lambda l:l if len(l)<=1 else quick_sort([i for i in l[1:] if i<=l[0]])+[l[0]]+quick_sort([i for i in l[1:] if i>l[0]])
a = [3,1,4,5,2,2]
print(quick_sort(a))

7.归并排序。

归并排序是一个典型的基于分治的递归算法。先将原数组分成n个小数组然后两两归并。

归并过程:先比较l1,l2的第一个元素大小,如果l1大则将l2的第一个元素添加到输出数组o中,然后l2指向第二个元素继续比较,这样直至排序完成。

python代码实现:

def merge(l1,l2):
    o = []
    a1 = 0;a2 = 0
    if l1==[]:
        return l2
    if l2==[]:
        return l1
    for i in range(len(l1)+len(l2)):
        if a1 == len(l1):
            for j in l2[a2:]:
                o.append(j)
        elif a2 == len(l2):
            for j in l1[a1:]:
                o.append(j)
        else:
            if l1[a1]>=l2[a2]:
                o.append(l2[a2])
                a2 += 1
            else:
                o.append(l1[a1])
                a1 += 1
    return o
def sort(l):
    if len(l)<=1:
        return l
    c = len(l)//2
    return merge(sort(l[:c]),sort(l[c:]))
a = [67,65,77,38,97,3,33,33]
print(sort(a))  

基数排序写不出来。。

原文地址:http://blog.51cto.com/13962326/2173186

时间: 2024-11-06 11:44:32

今天来谈谈Python中的各种排序总结,含实现代码的相关文章

谈谈python 中__name__ = &#39;__main__&#39; 的作用

position:static(静态定位) 当position属性定义为static时,可以将元素定义为静态位置,所谓静态位置就是各个元素在HTML文档流中应有的位置 podisition定位问题.所以当没有定义position属性时,并不说明该元素没有自己的位置,它会遵循默认显示为静态位置,在静态定位状态下无法通过坐标值(top,left,right,bottom)来改变它的位置. position:absolute(绝对定位) 当position属性定义为absolute时,元素会脱离文档流

谈谈python中的遍历

谈谈python中的遍历python中也有像java中的for...each....在python中是for...in... 其实感觉差不多,不过python的规则更灵活一点,只要是可以进行迭代的对象都能使用for...in....那么问题来了,什么是可迭代的对象呢?可以使用collections模块的Iterable来判断. from collections import Iterable flag = isinstance('adc',Iterable) print(flag) flag =

python中的各种排序

#encoding=utf-8 import random from copy import copy def directInsertSort(seq): """ 直接插入排序 """ size = len(seq) for i in range(1,size): tmp, j = seq[i], i while j > 0 and tmp < seq[j-1]: seq[j], j = seq[j-1], j-1 seq[j] =

python中各种常用类型的转换的代码

在学习过程中,将写代码过程中常用的内容做个收藏,下面代码是关于python中各种常用类型的转换的代码,应该是对码农们有一些用. int(x [,base ]) 将x转换为一个整数 long(x [,base ]) 将x转换为一个长整数 float(x ) 将x转换到一个浮点数 complex(real [,imag ]) 创建一个复数 str(x ) 将对象 x 转换为字符串 repr(x ) 将对象 x 转换为表达式字符串 eval(str ) 用来计算在字符串中的有效Python表达式,并返

Python中的字典排序

Python中比较常用的排序有两个函数, 一.定义 (1)一个是List数据结构中的sort >>> help(list.sort)Help on method_descriptor: sort(...) L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*; cmp(x, y) -> -1, 0, 1 The sort() method takes optional arguments for co

漫谈python中的搜索/排序

在数据结构那一块,搜索有顺序查找/二分查找/hash查找,而排序有冒泡排序/选择排序/插入排序/归并排序/快速排序.如果遇到数据量和数组排列方式不同,基于时间复杂度的考虑,可能需要用到混合算法.如果用C语言自己写,是一个很头疼且门槛很高的过程,python却用很简单的方式,让这类算法人人可用. 排序的话,python采用了一个sort函数,这个函数用的是一个适应性强的.稳定的.自然的归并算法,名为timsort.而查找,用字典,时间复杂度可以降低到O(1),而字典的实现方式,则是利用了hash函

Python 中的列表排序函数

sorted(iterable, cmp=None, key=None, reverse=False) L.sort(cmp=None, key=None, reverse=False) iterable:是可迭代类型;cmp:用于比较的函数,比较什么由key决定,有默认值,迭代集合中的一项;key:用列表元素的某个属性和函数进行作为关键字,有默认值,迭代集合中的一项;reverse:排序规则. reverse = True 或者 reverse = False,有默认值.返回值:是一个经过排序

Python中关于列表排序并保留id

新手才开始写博客,不周之处请原谅,有错误请指针. >>> a = [1,4,2,5,3]>>> b = sorted(enumerate(a),key = lambda x:x[1])>>> b[(0, 1), (2, 2), (4, 3), (1, 4), (3, 5)]>>> b[1](2, 2)>>> b[1][1]2>>> b[1][0]2 关于enumerate()使用方法(copy来的)

谈谈Python中pop与remove的用法

remove() 函数用于移除列表中某个值的第一个匹配项. remove()方法语法:  list.remove(obj) 如果obj不在列表中会引发 ValueError 错误,通常先使用count方法查看有多少个obj pop() 函数用于移除列表中的一个元素(默认最后一个元素),并且返回该元素的值. pop()方法语法:  list.pop(obj=list[-1]) 接下来发现网上的另一篇文章貌似说的不是很合理 https://www.jb51.net/article/132501.ht