冒泡选择插入归并希尔等排序算法的Python实现

Posted 2022-02-18 two-peanuts

一，冒泡排序

 

时间复杂度：O(n²)

 

稳定性：稳定

 

 　　冒泡排序我就不多讲了，大体上就是比较相邻的两个数，每次把较大的数沉底。流程图大致上如下：

　　图是截得别人的，只是说明一下，代码没有参看别人的，写的不好，有更好的写法可以一起探讨。下面是代码：

 1 def bubble(list):
 2     #print(list)
 3     for index in range(1,len(list)):  #比较6趟
 4         print("    index： %d" %index)
 5         for index2 in range(len(list)-1,0,-1):
 6             print("index2 =  %d:" %index2)
 7             if list[len(list) - index2-1] > list[len(list) - index2]:
 8                 temp = list[len(list) - index2-1]
 9                 list[len(list) - index2 - 1] = list[len(list) - index2]
10                 list[len(list) - index2] = temp
11         print(list)
12 list = [3, 6, 4, 2, 11, 10, 5,12,1,7,10]
13 bubble(list)

这里添加了新的解法（2019.6.25）：

‘‘‘
若list长度为n则迭代n-1次，每次迭代只要有前面大于后面便交换
‘‘‘
def buble_sort(list):

    n = 1
    while len(list)-n:
        for i in range(len(list)-1):
            if list[i] > list[i+1]:
                list[i],list[i+1] = list[i+1],list[i]
        n +=1
        print(n-1,":",list)

l = [3,6,4,2,11,10,5,1]
buble_sort(l)

二，选择排序

时间复杂度：O(n²)

稳定性：不稳定

如：8,9,8,6,7中第四个数6位最小的，将与第一个8交换，这时候第一个8就变为了第二个了，因此不稳定。

　　选择排序大体上就是每次在列表中找出最小的数，拿出来，然后再把拿出最小值后的列表在找最小数，就是这个思路。如图：

 1 def xuanze(list):
 2     list2 = []
 3     for index in range(1,len(list)):
 4         print("第 %d 次排序list,list2分别为：" %index)
 5         min = list[0]   #最小值
 6         for i in list:  #这里的i是里面的数值，而不是序号，print(i)可验证
 7             #print(i)
 8             if i < min:
 9                 min = i
10         #print(list.index(min))   #知道值求位置
11         locate = list.index(min)  #最小值的序号
12         temp = list[0]        #以下三行是交换
13         list[0] = list[locate]
14         list[locate] = temp
15 
16         print(list)
17         list2.append(list[0])
18         list.remove(list[0])
19         ‘‘‘当交换位置后的list第一个值被remove出去后，
20         此时的list是[56,80,91,20]了，依此类推，这里是
21         本算法利用list最好玩的地方，可以少写一个for‘‘‘
22         print(list2)
23 
24     print("最终的list2:")
25     list2.append(list[0])
26     print(list2)
27 if __name__ == ‘__main__‘:
28     list = [56,12,80,91,20,33,89,99]
29     xuanze(list)

17:06:26  2018-05-24

这里添加了新的解法（2019.6.25）：

 

def selection_sort(list):
    new_list = []
    while len(list):
        min = list[0]
        for i in range(0,len(list)):
            if list[i] < min:
                min= list[i]
        new_list.append(min)
        list.remove(min)
    print(new_list)

l = [10,6,7,11,8,3]
selection_sort(l)

 

三，插入排序

时间复杂度：O(n²)

稳定性：稳定

 

基本就是这个样子吧，看示意图能看明白，不再赘述。代码如下：

 1 def charu(list):
 2     num = len(list)
 3     for i in range(1,num):
 4         for j in range(0,i):
 5             print("i=",i,"j=",j,"      list[i]=",list[i],"list[j]=",list[j])
 6             if list[i] < list[j]:
 7                 temp = list[i]
 8                 list.remove(list[i])
 9                 list.insert(j,temp)
10                 print(list)
11                 break
12 list = [3,44,39,5,47,15,36,26,27,2,46,4,19,50,48]  #13个数
13 charu(list)

 

这里添加了新的解法（2019.6.26）：

def  insertion_sort(list):
    for i in range(1,len(list)):
        for j in range(0,i):
            temp = list[i]
            if temp < list[j]:
                list.pop(i)
                list.insert(j,temp)
    return list

l = [3,44,39,5,47,15,36,26,27,2,46,4,19,50,48]
insertion_sort(l)

四，归并排序

O(n*logn)，稳定

 归并用到了分治的思想。

def merge_sort(list):
    if len(list) == 1:
        return list
    else:
        mid = len(list)//2  #地板除
        left = list[:mid]
        right = list[mid:]
        return merge(left,right)
#合并两个排好的list
def merge(left,right):
    left.extend(right)
    sort_list = sorted(left)
    return sort_list

result = merge_sort([9,1,7,3,4,8,2,6])
print(result)

 五，快速排序

O(n*logn)  不稳定

引用：https://blog.csdn.net/morewindows/article/details/6684558

‘‘‘
基本思想：
1．先从数列中取出一个数作为基准数。
2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3．再对左右区间重复第二步，直到各区间只有一个数。
‘‘‘
def quick_sort(list):
    if len(list) == 1:
        return list
    else:
        base = list[0]
        left = []
        right = []
        for i in list:
            if i>=base:
                right.append(i)
            else:
                left.append(i)
        return combine(left,right)
#合并两个排好的list
def combine(left,right):
    left.extend(right)
    sort_list = sorted(left)
    return sort_list

l = [5,1,7,3,4,45,0,2,6]
result = quick_sort(l)
print(result)

六，希尔排序

不稳定

def shell_sort(list,gap):
    #导入的list的长度
    length = len(list)
    #gap为0则停止，不为0则继续迭代
    if gap == 0:
        return list
    else:
        #list_container用于装按照gap打散（分组）后的列表
        list_container = []
        for i in range(0,gap):
            temp_list = []
            for j in range(i,length,gap):
                temp_list.append(list[j])
            # print(temp_list)
            list_sep = sort(temp_list)
            list_container.append(list_sep)
        print("按照对应gap划分出的列表：",list_container)

        sorted_list = sort_all_list(list_container, length, gap)
        print("调用sort_all_list后:",sorted_list)
        #gap减小以达到最终迭代终止条件
        gap = gap//2
        #最后调用自己以迭代
        return shell_sort(sorted_list, gap)

def sort(list1):
    return sorted(list1)
#把按照gap打散（分组）后的列表排到一个理好顺序的list中
def sort_all_list(list2,length,gap):
    new_list = []
    for mm in range(length):
        new_list.append(0)
    #把l2每个数组按照每隔gap组成一个new_list
    for list in list2:
        N = list2.index(list)
        for i in range(N,length,gap):
            num = int((i-N)/gap)
            new_list[i] = list[num]
    # print("sort_all_list:",new_list)
    return new_list

l = [9,1,3,6,87,12,64,9,11,65,7]
#初始gap
if len(l) % 2 == 0:
    gap = int(len(l) / 2)
else:
    gap = int((len(l) - 1) / 2)
shell_sort(l,gap)