【Python】【排序算法总结】

没有写堆排序的，构造堆结构感觉太麻烦了0.0

先上几种排序算法的时间和空间复杂度

1.冒泡排序

思想：比较相邻两个数的大小，较大的放在后面。不停的循环直到一次循环过程后没有改动排序结束。

每次都有一个数（乱序最大的）被放到最后。

代码（Python）：

def Bubble_Sort(s):
    l = len(s)
    for i in range(l):
        flag = 1
        for j in range(1,l):
            if s[j-1]>s[j]:
                s[j-1], s[j] = s[j], s[j-1]
                flag = 0
        if flag:
            return s
    return s


def main():
    s = [3,5,1,9,8,4,2,0]
    a = Bubble_Sort(s)
    print(a)


if __name__ == '__main__':
    main()

2. 选择排序

思想：找一个最大/小的放在第一个，再找最大/小的放在之前排序的序列末尾，循环迭代。

每次循环都有一个最大/小的被放到确s定位置

代码（Python）：

def Selection_Sort(s):
    l = len(s)
    for i in range(l):
        nmin = i
        for j in range(i,l):
            if s[j]<s[nmin]:
                nmin = j
        s[i], s[nmin] = s[nmin], s[i]
    return s


def main():
    s = [3,5,1,9,8,4,2,0]
    a = Selection_Sort(s)
    print(a)


if __name__ == '__main__':
    main()

3.插入排序

思想：从第一个开始，认为已经排序。从下一个元素，每一个都和前面的进行比较，直到找到小于等于这个数的位置，这个数插入到找出的位置后面，循环迭代到每个排序后。插入排序在每次循环后没有数在最后确定的位置。

代码（Python）

def Insertion_Sort(s):
    for i in range(1,len(s)):
        temp = s.pop(i)
        for j in range(i-1,-1,-1):
            if temp >= s[j]:
                s.insert(j+1,temp)
                break
        if temp<s[0]:
            s.insert(0, temp)
    return s


def main():
    s = [3,5,1,9,8,4,2,0]
    a = Insertion_Sort(s)
    print(a)


if __name__ == '__main__':
    main()

4.希尔排序

思想：通过一个动态的间隔对list进行排序t1,t2.....tk，t1>t2且tk=1，按间隔数对序列个数ti（比如总共有20个数，ti等于5，分4堆，每堆还是5个）进行ti次排序，循环到最后tk=1。

这个排序每次还是没有确定的数放到最终确定的位置。

代码（Python）

def Shell_Sort(s):
    gap = 1
    while gap<len(s)//3:
        gap = 3*gap+1
    while gap>0:
        for i in range(gap,len(s)):
            ind = i
            while ind-gap>=0 and s[ind - gap]>s[ind]:
                s[ind], s[ind-gap] = s[ind-gap],s[ind]
                ind = ind-gap
        if gap == 2:
            gap = 1
        else: gap = gap//3
    return s


def main():
    s = [84,88,83,87,61,50,70,60,80,99]
    a = Shell_Sort(s)
    print(a)


if __name__ == '__main__':
    main()

5.归并排序

思想：通过将序列二分为n/2的子序列，不断二分到只有两个数字，再进行比较，返回结果，将结果不断合并成一个有序序列

代码：

def Merge_Sort(s):
    if len(s)==1: return s
    if len(s)==2:
        if s[0]>s[1]:
            return [s[1],s[0]]
        else: return s
    mid = len(s)//2
    left = Merge_Sort(s[:mid])
    right = Merge_Sort(s[mid:])
    return Merge(left, right)

def Merge(left,right):
    i,j = 0,0
    s = []
    while i<len(left) and j<len(right):
        if left[i]<right[j]:
            s.append(left[i])
            i+=1
        else:
            s.append(right[j])
            j+=1
    if j<len(right):
        s = s+right[j:]
    elif i<len(left):
        s = s+left[i:]
    return s

def main():
    s = [3,5,1,9,8,4,2,0]
    a = Merge_Sort(s)
    print(a)


if __name__ == '__main__':
    main()

6.快速排序

思想：从序列中挑出一个元素 ，称为基准；将比基准大的放在基准数的后面，比基准数小的放在基准数前面；在子序列中递归直到结束。

每次的基准数都是放在了最后的准确位置上

代码：（这是算法导论上的代码，使用迭代的方法，所以非常简洁）

def Quick_Sort(s,start,end):
    if start<end:
        p = partition(s,start,end)
        Quick_Sort(s,start,p-1)
        Quick_Sort(s, p+1,end)

def partition(s,start,end):
    temp = s[end]
    m = start-1
    for i in range(start,end):
        if s[i]<=temp:
            m+=1
            s[i],s[m] = s[m],s[i]
    s[end],s[m+1] = s[m+1],s[end]
    return m+1


def main():
    s = [3,5,2,7,6,9,10,8,11,69]
    Quick_Sort(s, 0, len(s)-1)
    print(s)

参考文献：

https://www.cnblogs.com/onepixel/articles/7674659.html

https://blog.csdn.net/razor87/article/details/71155518

http://www.cnblogs.com/taizy/p/3906568.html