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

wei_Y

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

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


简单暴力！

1. def sel(lst):
   
2.         newlist = []
   
3.         for i in range(len(lst)):
   
4.                 newlist.append(min(lst))
   
5.                 lst.remove(min(lst))
   
6.         return newlist

复制代码

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

每两个数比较，互换。

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




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

1. def bubb(lst):
   
2.         for c in range(len(lst)):
   
3.                 for i in range(len(lst)-1):
   
4.                         if lst[i] > lst[i+1]:
   
5.                                 lst[i],lst[i+1] = lst[i+1],lst[i]
   
6.         return lst

复制代码

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

1. def bub2(lst):
   
2.         for i in range(len(lst)):
   
3.                 for j in range(len(lst)-1,i,-1):
   
4.                         if lst[i] > lst[j]:
   
5.                                 lst[i],lst[j] = lst[j],lst[i]
   
6.         return lst

复制代码

3. 插入排序。


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

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

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

1. def insert(lst):
   
2.         for i  in range(1,len(lst)):
   
3.                 j = 0
   
4.                 while lst[i] > lst[j]:
   
5.                         j += 1
   
6.                 results = lst[i]
   
7.                 lst.pop(i)
   
8.                 lst.insert(j,results)
   
9.         return lst

复制代码

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

1. def insert2(lst):
   
2.         result = []
   
3.         for i  in lst:
   
4.                 if len(result) == 0:
   
5.                         result.append(i)
   
6.                 else:
   
7.                         for j in range(len(result)-1,-1,-1):
   
8.                                 if i < result[j]:
   
9.                                         if i > result[j-1]:
   
10.                                                 result.insert(j,i)
    
11.                                                 break
    
12.                                         elif j-1 < 0:
    
13.                                                 result.insert(j,i)
    
14.                                                 break                                                
    
15.                                         else:
    
16.                                                 continue
    
17.                                 else:
    
18.                                         result.insert(j+1,i)
    
19.                                         break
    
20.         return result

复制代码

4. 快速排序。

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



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

1. def fast(lst):
   
2.         if len(lst) <= 1:
   
3.                 return lst
   
4.         else:
   
5.                 temp1 = [i for i in lst[1:] if i < lst[0]]
   
6.                 temp2 = [i for i in lst[1:] if i >= lst[0]]
   
7.                 return fast(temp1)+ lst[:1] +fast(temp2)

复制代码

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



代码

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

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



代码:

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

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

1. if __name__ == '__main__':
   
2.         import time
   
3.         import random
   
4.         list2 = []
   
5.         for i in range(5000):
   
6.                 list2.append(random.randint(1,10000))
   
7.         list1 = list2[:]
   
8.         print('列表长度:%d'%(len(list1)))
   
9.         t1 = time.clock()
   
10.         t = sel(list1)
    
11.         t2 = time.clock()
    
12.         print(t,'\n')
    
13.         list1 = list2[:]
    
14.         print('选择排序用时%f'%(t2-t1))
    
15.         t1 = time.clock()
    
16.         t = bubb(list1)
    
17.         t2 = time.clock()
    
18.         print(t,'\n')
    
19.         list1 = list2[:]
    
20.         print('冒泡排序第一种用时%f'%(t2-t1))
    
21.         t1 = time.clock()
    
22.         t = bub2(list1)
    
23.         t2 = time.clock()
    
24.         print(t,'\n')
    
25.         list1 = list2[:]
    
26.         print('冒泡排序第二种用时%f'%(t2-t1))
    
27.         t1 = time.clock()
    
28.         t = insert(list1)
    
29.         t2 = time.clock()
    
30.         print(t,'\n')
    
31.         list1 = list2[:]
    
32.         print('插入排序第一种用时%f'%(t2-t1))
    
33.         t1 = time.clock()
    
34.         t = insert2(list1)
    
35.         t2 = time.clock()
    
36.         print(t,'\n')
    
37.         list1 = list2[:]
    
38.         print('插入排序第二种用时%f'%(t2-t1))
    
39.         t1 = time.clock()
    
40.         t = fast(list1)
    
41.         t2 = time.clock()
    
42.         print(t,'\n')
    
43.         list1 = list2[:]
    
44.         print('快速排序用时%f'%(t2-t1))
    
45.         t1 = time.clock()
    
46.         t = sorted(list1)
    
47.         t2 = time.clock()
    
48.         print(t,'\n')
    
49.         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.

给力