Python date 比大小 python函数比大小

python基础排序函数

比较排序：从第一个元素开始比较相邻元素的大小，若大小顺序有误，则对调之后进行下一个元素的比较。

def bubble_sort(data):
    n=len(data)
    for i in range(n-1):
        for j in range(n-i-1):
            if data[j]>data[j+1]:
                data[j],data[j+1]=data[j+1],data[j]
        print('\n第%3d次排序的结果是： ' %(i+1),end=' ')
        for j in range(n):
            print('%3d' %data[j], end='')
    print('\n排序后的结果为： ')
    for j in range(n):
        print('%3d'%data[j],end=' ')

s=[16,25,39,27,12,8,45,63]
bubble_sort(s)

第  1次排序的结果是：   16 25 27 12  8 39 45 63
第  2次排序的结果是：   16 25 12  8 27 39 45 63
第  3次排序的结果是：   16 12  8 25 27 39 45 63
第  4次排序的结果是：   12  8 16 25 27 39 45 63
第  5次排序的结果是：    8 12 16 25 27 39 45 63
第  6次排序的结果是：    8 12 16 25 27 39 45 63
第  7次排序的结果是：    8 12 16 25 27 39 45 63
排序后的结果为： 
  8  12  16  25  27  39  45  63

选择排序：反复从未排序的数列中取出最小的元素加入到另一个数列中，最后的结果即为已排序的数列。例如遍历所有元素第一遍，把最小的放在第一个位置。再挑选除了第一个以外的另外所有元素，把最小的放在第二个位置。继续循环。

def show(data):
    n=len(data)
    for j in range(n):
        print('%3d'%data[j],end=' ')
def selection_sort(data):
    n=len(data)
    for i in range(n-1):
        for j in range(i+1,n):
            if data[i]>data[j]:
                data[j],data[i]=data[i],data[j]
        print('\n第%3d次排序的结果为：'%(i+1))
        show(data)
    print('\n排序后的结果为： ')
    show(data)
    return data
a=[213,34,56,7,8,9,0,34,5666]
selection_sort(a)

第  1次排序的结果为：
  0 213  56  34   8   9   7  34 5666 
第  2次排序的结果为：
  0   7 213  56  34   9   8  34 5666 
第  3次排序的结果为：
  0   7   8 213  56  34   9  34 5666 
第  4次排序的结果为：
  0   7   8   9 213  56  34  34 5666 
第  5次排序的结果为：
  0   7   8   9  34 213  56  34 5666 
第  6次排序的结果为：
  0   7   8   9  34  34 213  56 5666 
第  7次排序的结果为：
  0   7   8   9  34  34  56 213 5666 
第  8次排序的结果为：
  0   7   8   9  34  34  56 213 5666 
排序后的结果为： 
  0   7   8   9  34  34  56 213 5666 




[0, 7, 8, 9, 34, 34, 56, 213, 5666]

插入排序：将数组中的元素逐一与已经排序好的元素相比较，前两个元素先排好，再将第三个元素插入到前两个元素适当的位置，所以这三个元素依旧是已经排好序的。接着重复。插入，即再应该插入的位置上留空，将该位置之后的所有元素向后推一个位置。

def insert_sort(data):
    n=len(data)
    for i in range(1,n):
        tmp=data[i]
        num=i-1
        while num>=0 and tmp<data[num]:
            data[num+1]=data[num]
            num-=1
        data[num+1]=tmp
    return data
insert_sort(a)

[0, 7, 8, 9, 34, 34, 56, 213, 5666]

def shell_sort(data):
    n=len(data)
    k=1
    d=n//2
    while d!=0:
        for i in range(d,n):
            tmp=data[i]
            j=i-d
            while tmp<data[j] and j>=0:
                data[j+d]=data[j]
                j-=d
            data[j+d]=tmp
        print('\n第%d次排序过程：'%k,end='')
        k+=1
        show(data)
        d=d//2
a2=[312,435,6,7,88,53,342,13]         
shell_sort(a2)

第1次排序过程： 88  53   6   7 312 435 342  13 
第2次排序过程：  6   7  88  13 312  53 342 435 
第3次排序过程：  6   7  13  53  88 312 342 435

合并排序：将数据分为两部分：中间值mid左边的left，右边的right，接下来对left和right依次按照顺序取出，进行比较，小的放入result，大的接着与下一个比较。

def merge(left,right,compare):
    result=[]
    i,j=0,0
    while i<len(left) and j<len(right):
        if compare(left[i],right[j]):
            result.append(left[i])
            i+=1
        else:
            result.append(right[j])
            j+=1
    while i<len(left):
        result.append(left[i])
        i+=1
    while j<len(right):
        result.append(right[j])
        j+=1
    return result
def merge_sort(l,compare=lambda x,y :x<y):
    if len(l)<2:
        return l[:]
    else:
        mid=len(l)//2
        left=merge_sort(l[:mid],compare)
        right=merge_sort(l[mid:],compare)
        return merge(left,right,compare)

lis1=[23,456,765,758,9,4324,43255,22,2345,5768,8]
mergeSort(lis1)

[8, 9, 22, 23, 456, 758, 765, 2345, 4324, 5768, 43255]

快速排序：使用分而治之的方法，现在数据中找到一个虚拟的中间值，并按照这一个中间值将所有打算排序的数据分为两部分，其中小于中间值的数据放在左边，大于中间值的数据放在右边，在以同样的方式分别处理左右的数据，知道排序完成。

假设有10个数据，a0,a1,a2,aa3,a4,a5,a6,a7,a8,a9无序排列，随意取定一个数据a4为虚拟中间值（不论实际大小）那么第一次，从左到右遍历一遍，找出所有小于a4的数据（a1,a5,a7,a9）放在a4的左边，大于的(a0,a2,a3,a6,a8)放在a4的右边，接着对左右两个小列表，重新取定一个随机的中间值，左边a5右边a6分别遍历，将每一个小列表分割成左右两部分。多次循环,一般关于虚拟中间值的取定我们按照顺序从左至右。

def quickSort(data):
    if len(data)<2:
        return data
    else:
        statics=data[0]
        smaller=[i for i in data[1:] if i <statics]
        bigger=[i for i in data[1:] if i>statics]
        print("\n基准点（中间值）是: ",data[0])
        print('smaller的排列为: ' ,smaller)
        print("bigger的排列为: ", bigger)
    return quickSort(smaller)+[statics]+quickSort(bigger)

data1=[23,435,7567,76,789,3,345,75,1,233,445]
quickSort(data1)

基准点（中间值）是:  23
smaller的排列为:  [3, 1]
bigger的排列为:  [435, 7567, 76, 789, 345, 75, 233, 445]

基准点（中间值）是:  3
smaller的排列为:  [1]
bigger的排列为:  []

基准点（中间值）是:  435
smaller的排列为:  [76, 345, 75, 233]
bigger的排列为:  [7567, 789, 445]

基准点（中间值）是:  76
smaller的排列为:  [75]
bigger的排列为:  [345, 233]

基准点（中间值）是:  345
smaller的排列为:  [233]
bigger的排列为:  []

基准点（中间值）是:  7567
smaller的排列为:  [789, 445]
bigger的排列为:  []

基准点（中间值）是:  789
smaller的排列为:  [445]
bigger的排列为:  []





[1, 3, 23, 75, 76, 233, 345, 435, 445, 789, 7567]