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

Posted two-peanuts

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了冒泡选择插入归并希尔等排序算法的Python实现相关的知识,希望对你有一定的参考价值。

一,冒泡排序

 

时间复杂度:O(n2)

 

稳定性:稳定

 

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

技术图片

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

 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(n2)

稳定性:不稳定

如: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(n2)

稳定性:稳定

 

技术图片

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

 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)

 

以上是关于冒泡选择插入归并希尔等排序算法的Python实现的主要内容,如果未能解决你的问题,请参考以下文章

链表排序(冒泡选择插入快排归并希尔堆排序)

冒泡选择插入希尔归并快速排序等python实现

十大经典排序(下)——Python3实现

常见排序算法的实现(归并排序快速排序堆排序选择排序插入排序希尔排序)

插入.希尔.选择.堆排.冒泡.快排.归并.计数_8排序

学习数据结构笔记====>不同的排序算法(Sort Algorithm)[冒泡,选择,插入,快速,希尔,基数,归并]