熟悉排序算法

冒泡排序

def bubble_sort(data):
    u"""
    冒泡排序
    """
    for i in range(len(data)-1): 
        #一次循环下来，最大的就在最后面了。
        for j  in range(len(data) - i -1): 
             if data[j] > data[j+1]:
                data[j], data[j+1] = data[j+1] , data[j]

    return data

if __name__ == "__main__":
    import random
    
    data = []
    for i in range(10):
        data.append(random.randint(1,100))
    print("source data======",data)
    result = bubble_sort(data)
    print("sort result data====",result)

快速排序

 

# -*- coding: utf-8 -*-


def quick_sort(q):
    if not q:
        return []
    
    m = q.pop()
    left_q = []
    right_q = []
    for e in q:
        if e>m:
            right_q.append(e)
        else:
            left_q.append(e)
            
    left_result =  quick_sort(left_q)
    
    right_result = quick_sort(right_q)
    
    return left_result + [m] + right_result


if __name__ == "__main__":
    u"""
    1、列表 2、字符串 3、树 4、图
    """
    import random
    q = []
    for i  in range(1,10):
        q.append(random.randint(1,100))
        
    print 'init list=',q
    result = quick_sort(q)
    print 'sorted list=',result

合并排序

 

 

def merge_sort(s_list1,s_list2):
    result = []

    while s_list1 and s_list2:
        q = s_list1[0]
        p = s_list2[0]
            
        if q<p:
            result.append(q)
            s_list1 = s_list1[1:]
        else:
            result.append(p)
            s_list2 = s_list2[1:]
            
    if s_list1:
        result.extend(s_list1)
    
    if s_list2:
        result.extend(s_list2)
        
    return result


def merge_main_sort(s_list):
    length = len(s_list)
    if length <=1:
        return s_list
    
    s_list1 = s_list[0:length/2]
    s_list2 = s_list[length/2:]
    
    rs1 = merge_main_sort(s_list1)
    rs2 = merge_main_sort(s_list2)
    
    result = merge_sort(rs1,rs2)
    return result

    
if __name__ == "__main__":
    import random
    c = []
    for i in range(100):
        i_random = random.randint(1,1000)
        c.append(i_random)
        
    print 'before sort=="%s"'%c
    rs = merge_main_sort(c)
    print 'after sort=="%s"'%rs

插入排序

 

 

# -*- coding: utf-8 -*-


def insert_sort(sorted_list,insert_list):
    u"sorted_list 是从小到大排列好了的队列"
    for e in insert_list:
        length = len(sorted_list)
        i_index = length  #如果都比列表中的元素都大，则说明自己新插入的元素最大
        for i in range(length): #找寻插入的位置
            if e<=sorted_list[i]:
                i_index = i
                break
            
        sorted_list.insert(i_index,e)
    
    return sorted_list
            
if __name__ == "__main__":
    import random
    d = []
    for i in range(16):
        e = random.randint(1,100)
        d.append(e)
        
    print "init list-------",d
    
    sored_list = []
 
    for index,elem in enumerate(d):
        sored_list = insert_sort(sored_list,[elem])
        print "***",index+1,"->",sored_list,"->",elem
    
    print "result---------",sored_list

选择排序

def select_sort(data):
    u"""
    第一次从待排序的数据元素中选出最小（或最大）的一个元素，
    存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，
    然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。
    选择排序是不稳定的排序方法。
    """
    for i in range(0, len (data)-1):
        min_index = i #最小索引
        for j in range(i + 1, len(data)):
            if data[j] < data[min_index]:
                min_index = j
        data[i], data[min_index] = data[min_index], data[i]  # swap
    
    return data


if __name__ == "__main__":
    import random
    
    data = []
    for i in range(10):
        data.append(random.randint(1,100))
    print("source data======",data)
    result = select_sort(data)
    print("sort result data====",result)