排序技术哪家强，各种排序算法。

wei_Y

不是各种啦，只写出来4种，有的效率好点，有的跑不出结果- -。

1. 选择排序。
每次选择最小的一项放到最前面。
这个不用太动脑子，直接min上。
效率 : 需要的次数是取决于列表的长度。


简单暴力！

def sel(lst):
        newlist = []
        for i in range(len(lst)):
                newlist.append(min(lst))
                lst.remove(min(lst))
        return newlist

2. 冒泡排序。
不知道为啥要叫这个名字。
潜水的来冒个泡，顶一下嘛?

每两个数比较，互换。

效率: 因为不会一次性换完，效率最小会是列表长度的平方。(慢。)




写了两种。第二个效率好点。

def bubb(lst):
        for c in range(len(lst)):
                for i in range(len(lst)-1):
                        if lst[i] > lst[i+1]:
                                lst[i],lst[i+1] = lst[i+1],lst[i]
        return lst

--------------------------------------------------------------------我叫凶残分割线----------------------------------------------------------------------

def bub2(lst):
        for i in range(len(lst)):
                for j in range(len(lst)-1,i,-1):
                        if lst[i] > lst[j]:
                                lst[i],lst[j] = lst[j],lst[i]
        return lst

3. 插入排序。


从前或后(想从中间也不是不可以。)依次选取，然后选择他应该的位置，然后狠狠的插进去(tip: 姿势要正确)。

效率: 最差应该是列表长度的平方，但是比冒泡要好(至少我试的是这样)。

也是写出来两种，第一种比较暴力，写的也短点。

def insert(lst):
        for i  in range(1,len(lst)):
                j = 0
                while lst[i] > lst[j]:
                        j += 1
                results = lst[i]
                lst.pop(i)
                lst.insert(j,results)
        return lst

第二种写的贼长，(其实本来我以为是堆排序，写完发现还是插入排序。)

def insert2(lst):
        result = []
        for i  in lst:
                if len(result) == 0:
                        result.append(i)
                else:
                        for j in range(len(result)-1,-1,-1):
                                if i < result[j]:
                                        if i > result[j-1]:
                                                result.insert(j,i)
                                                break
                                        elif j-1 < 0:
                                                result.insert(j,i)
                                                break                                                
                                        else:
                                                continue
                                else:
                                        result.insert(j+1,i)
                                        break
        return result

4. 快速排序。

选择一个数(随机数，中位数，指定数等。)
每次将列表分成小于这个数，和大于这个数。(这个数归在哪里都可以。)
然后一直分啊分，直到每个分组都剩下一个。
效率: 高，要不怎么叫快速排序~，人品不好也只能是列表长度的平方了。



代码也好写，速度也快，利用递归。

def fast(lst):
        if len(lst) <= 1:
                return lst
        else:
                temp1 = [i for i in lst[1:] if i < lst[0]]
                temp2 = [i for i in lst[1:] if i >= lst[0]]
                return fast(temp1)+ lst[:1] +fast(temp2)

5.堆排序。
这个没写出来，不知道该怎么弄个二叉树。效果图。



代码

游客，如果您要查看本帖隐藏内容请回复

6. 归并排序。
依然不会写，效果图。



代码:

游客，如果您要查看本帖隐藏内容请回复

7. 到底哪家强?。
这一坨长代码。

if __name__ == '__main__':
        import time
        import random
        list2 = []
        for i in range(5000):
                list2.append(random.randint(1,10000))
        list1 = list2[:]
        print('列表长度:%d'%(len(list1)))
        t1 = time.clock()
        t = sel(list1)
        t2 = time.clock()
        print(t,'\n')
        list1 = list2[:]
        print('选择排序用时%f'%(t2-t1))
        t1 = time.clock()
        t = bubb(list1)
        t2 = time.clock()
        print(t,'\n')
        list1 = list2[:]
        print('冒泡排序第一种用时%f'%(t2-t1))
        t1 = time.clock()
        t = bub2(list1)
        t2 = time.clock()
        print(t,'\n')
        list1 = list2[:]
        print('冒泡排序第二种用时%f'%(t2-t1))
        t1 = time.clock()
        t = insert(list1)
        t2 = time.clock()
        print(t,'\n')
        list1 = list2[:]
        print('插入排序第一种用时%f'%(t2-t1))
        t1 = time.clock()
        t = insert2(list1)
        t2 = time.clock()
        print(t,'\n')
        list1 = list2[:]
        print('插入排序第二种用时%f'%(t2-t1))
        t1 = time.clock()
        t = fast(list1)
        t2 = time.clock()
        print(t,'\n')
        list1 = list2[:]
        print('快速排序用时%f'%(t2-t1))
        t1 = time.clock()
        t = sorted(list1)
        t2 = time.clock()
        print(t,'\n')
        print('内置sorted排序用时%f'%(t2-t1))

还是python内置的牛掰，完全不是一个等级，难道是我写的太渣了。。
堆排序和归并排序有兴趣自己搞搞吧，我反正木搞懂。。

～风介～

冒泡排序是这样解释的：大的往下沉，小的往上浮——就像冒泡泡一样！

微逻辑

好

默然

厉害厉害~~

opqrew99

真心复杂，编程好费脑细胞啊

左半边的翅膀丶

编程好复杂啊

wei_Y

～风介～ 发表于 2014-12-3 22:43
冒泡排序是这样解释的：大的往下沉，小的往上浮——就像冒泡泡一样！

呦西，原来如此。

啡色围巾

{:1_1:}

月光骑士

强烈支持

xiaom

专业的样子

碧蓝疯子

           支持！！

wing1995

可以收藏哟

longtian

这么高大上

zxg810874

很牛啊，看来还需很努力学习才行啊

zh741

太叼了！！！

王乐山

已经对楼主无语

wei_Y

王乐山 发表于 2014-12-4 20:25
已经对楼主无语

怎么了- -。

bj584767285

这个好屌，赶快mark

Codel

太厉害了 怒赞{:1_1:}

wmh.

给力