shell sort 最后一列排序_十大排序算法（python实现）

最新推荐文章于 2024-06-30 09:40:00 发布

weixin_39616503

最新推荐文章于 2024-06-30 09:40:00 发布

阅读量148

点赞数

文章标签： shell sort 最后一列排序

十大排序算法（python）

在计算机编程时，我们经常需要对一系列数进行排序，在这里，我将列出十种不同的排序算法，给出它们的python代码，并计算出它们的时间复杂度。

0排序算法说明

0.1排序的定义

对一序列对象根据某个关键字进行排序。

0.2 术语说明

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；

不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；

内排序：所有排序操作都在内存中完成；

外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；

时间复杂度：一个算法执行所耗费的时间。

空间复杂度：运行完一个程序所需内存的大小。

0.3 算法总结

名词解释：

· n: 数据规模

· k: “桶”的个数

· In-place: 占用常数内存，不占用额外内存

· Out-place: 占用额外内存1

0.4算法分类

Figure 1注：我使用的shell排序是交换排序，当然也可以用插入排序

0.5比较和非比较的区别

常见的快速排序、归并排序、堆排序、冒泡排序等属于比较排序。在排序的最终结果里，元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较，才能确定自己的位置。

在冒泡排序之类的排序中，问题规模为n，又因为需要比较n次，所以平均时间复杂度为O(n²)。在归并排序、快速排序之类的排序中，问题规模通过分治法消减为logN次，所以时间复杂度平均O(nlogn)。

比较排序的优势是，适用于各种规模的数据，也不在乎数据的分布，都能进行排序。可以说，比较排序适用于一切需要排序的情况。

计数排序、基数排序、桶排序则属于非比较排序。非比较排序是通过确定每个元素之前，应该有多少个元素来排序。针对数组arr，计算arr[i]之前有多少个元素，则唯一确定了arr[i]在排序后数组中的位置。

非比较排序只要确定每个元素之前的已有的元素个数即可，所有一次遍历即可解决。算法时间复杂度O(n)。

非比较排序时间复杂度底，但由于非比较排序需要占用空间来确定唯一位置。所以对数据规模和数据分布有一定的要求。[1]

1冒泡排序（bubble sort）

冒泡排序通过重复走访要排序的数列，依次比较数列中相邻的两个数，如果逆序，则将这两个数交换，变为顺序。算法终止的条件是对数列中的任意两个数我们都不可交换它们的位置，也就是数列中所有数都为顺序。在操作n次之后，整个数列将按从小到大的顺序排列。在每一次操作中，我们需要比较O(n)次,共执行n次，算法的时间复杂度为O（n^2）。

算法描述：从第一个数开始，依次比较相邻两个数，如果第一个数大于第二个数，则交换它们之间的位置。在经过一轮操作后，最大的数将被移动到数列最右端。我们继续对剩下的n-1个数进行操作，从而可以将这n-1个数中最大的数移动到剩下的数最右端。重复进行，直到遍历完整个数列，算法终止。

def

2选择排序（selection sort）

选择排序是从未排序数列中选择最小的数，存放到排序数列中的起始位置，然后再选出第二小的数，附在已排序数列的最后。这样我们就可以将数列从小到大地进行排序。算法终止的条件是遍历完原数列。我们每次操作需要在原数列中比较O（n）次，共执行n次，算法的时间复杂度为O（n^2）。

算法描述：我们从原数列中选出最小的数，将其导出（pop，缩短原列表长度，可以减少运算时间），并将其返回到一个新数列中。重复操作，直到原数列中不含元素，算法终止。

def selection_sort(n):
    '''选择排序
    
    对列表进行排序，并返回一个排序好的列表
    :param n: 列表对象
    :return: 排序结果列表
    '''
    s=[]#输出列表
    i=0
    while i < len(n):
        min_num=n[i]
        for j in range(i,len(n)):
            if n[j]<min_num:
                min_num=n[j]
        n.remove(min_num)
        s.append(min_num)
    return s

3插入排序(insertion sort)

插入排序是先构建一个有序数列，然后从无序数列中选出一个数，将其插入到有序数列对应位置中。插入时需要比较O（n）次，共需操作n次，算法的时间复杂度为O(n^2）

算法描述：选出原数列第一个元素作为有序数列的起始，然后从原数列中选出下一个数，将所选出的数从后向前与有序数列中的数进行比较，若小于则与有序数列中的前一个数进行比较，直到选出的数大于有序数列中的某个数，此时我们将选出的数插入到有序数列的中的那个数之后。依次遍历整个原数列，遍历结束，算法终止。

def insertion_sort(n):
    '''插入排序
    
    对列表进行排序，并返回一个排序好的列表
    :param n: 列表对象
    :return: 排序结果列表
    '''
    s=[n[0]]
    i=1
    while i < len(n):
        j=-1
        if n[i]>=s[j]:
            s.append(n[i])
        elif n[i]<=s[0]:
            s.insert(0,n[i])
        else:
            while n[i] < s[j]:
                if n[i] >= s[j-1]:
                    s.insert(j,n[i])
                j-=1
        i+=1
    return s

4希尔排序(shell sort)

希尔排序是通过将原数列进行多次分组，在每一组内部进行排序。它会优先比较距离比较远的元素，从而可以使操作次数大幅下降。希尔排序是对原数列按一定增量分组，对每组进行排序；随着增量逐渐减少，每组包含的数越来越多，当增量减至1时，整个文件恰被分成一组，算法终止。每次操作需要比较n次共需操作次，算法的时间复杂度为O（nlogn）。

算法描述：我们先选择增量gap=len（n）//2，每次操作后依次后缩小增量为gap=gap//2，直到gap=1。然后我们根据增量对原数列进行分组，在每组内部使用冒泡排序算法进行排序（也可以使用插入排序算法，插入排序算法更快）。当增量为1时，程序进行最后一次操作，之后算法终止。

def shell_sort(n):
    '''希尔排序
    
    对列表进行排序，并返回一个排序好的列表
    :param n: 列表对象
    :return: 排序结果列表
    '''
    gap=len(n)//2#间距
    while gap > 0:
        for i in range(gap,len(n)):
            j=i
            while j>=gap:
                if n[j] < n[j-gap]:
                    n[j],n[j-gap]=n[j-gap],n[j]
                    j-=gap
                else:
                    break
        gap=gap//2
    return n

5归并排序(merge sort)

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法，将原数列进行分组，分为左右两个数列，然后继续对左右两个数列进行分组，直到每组所含元素为1。然后对每个子序列进行排序，将有序的子数列合并，然后继续排序，直到得到完全有序的原数列。即先使每个子序列有序，再使子序列段间有序，最终返回一个完全有序的数列。分组需要操作 次，每次操作排序需要n次，算法时间复杂度为O（nlogn）

算法描述：将原数列进行分组，分为左右两个数列，然后继续对左右两个数列分别采用归并排序。最后将两个排序好的子序列合并成一个最终的排序序列。算法终止，直到递归结束。

def merge_sort(n):
    '''归并排序
    
    对列表进行排序，并返回一个排序好的列表
    :param n: 列表对象
    :return: 排序结果列表
    '''
    if len(n)==1:
        return n
    mid=len(n)//2
    left=merge_sort(n[:mid])
    right=merge_sort(n[mid:])
    s=[]#输出列表
    while left and right:
        if left[0]<right[0]:
            s.append(left.pop(0))
        else:
            s.append(right.pop(0))
    if left:
        s.extend(left)
    if right:
        s.extend(right)
    return s

6快速排序(quick sort)

快速排序是通过先选出一个数，将所有小于等于它的数放到它的左边，将所有大于等于它的数放到它的右边。重复操作直到数列有序。我们发现在一次操作后就确定了一个数的位置，每次操作需要比较O（n）次，需要操作次（以每个递归循环为参考对象），算法时间复杂度为O（nlogn）

算法描述：以某个数为参考对象将一个数列分为左右两个部分，然后从数列左边开始查找，直到找到一个大于该数的数，记录它的位置为左标，再从数列右边开始查找，直到找到一个小于该数的数，记录它的位置为右标，将左右标数互换。继续执行算法，直到左右标相遇，最后将该数与左标数互换，此时该数满足：数列中所有小于等于它的数在它的左边，所有大于等于它的数在它的右边，该次算法结束。我们再对左右两个数列分别进行快速排序。算法完全终止，直到每个数列所含元素个数为1个，最后返回一个有序的数列。

def quick_sort(n,l,r):#l:left,r:right
    '''快速排序
    
    对列表进行排序，并返回一个排序好的列表
    :param n: 列表对象
    :return: 排序结果列表
    '''
    if l>=r:
        return n
    i,j=l,r
    while True:
        while l<=r and n[l]<n[i]:
            l+=1
        while l<=r and n[r]>=n[i]:
            r-=1
        if l>r:
            break
        n[l],n[r]=n[r],n[l]
    n[i],n[l]=n[l],n[i]
    quick_sort(n,i,l-1)
    quick_sort(n,l+1,j)
    return n

[2]

7堆排序(heap sort)

堆排序是是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。在每次操作后，原数列返回一个最大值，在每次操作中，需比较次，算法的时间复杂度为O（nlogn）。[1]

算法描述：我们可以对堆编写一个索引，原数列中的每个值都有相应的索引与它对应。然后用列表模拟堆，编写一个操作，每次返回列表中的最大值。然后将所有最大值逆序排列即可得到一个有序的数列。

def heap_sort(n):
    '''堆排序
    
    对列表进行排序，并返回一个排序好的列表
    :param n: 列表对象
    :return: 排序结果列表
    '''
    s=[]
    while len(n)>0:
        k=0
        while len(n)>2**k-1:
            k+=1
        while k>1:
            for i in range(2**(k-2)-1,2**(k-1)-1):
                if len(n)>=2*i+2:
                    if n[i]<n[2*i+1]:
                        n[i],n[2*i+1]=n[2*i+1],n[i]
                if len(n)>=2*i+3:
                    if n[i]<n[2*i+2]:
                        n[i],n[2*i+2]=n[2*i+2],n[i]
            k-=1
        n[0],n[len(n)-1]=n[len(n)-1],n[0]
        s.append(n.pop())
    s.reverse()
    return s

8计数排序(counting sort)

计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。假设需要k个键来储存数列中的值，我们可以得到算法的时间复杂度为O（n+k）。

算法描述：我们将数列中的最大值最小值拿出，将k设置为最大值与最小值之差。对每个在原数列中的数，统计它出现的次数，并将其赋值给相应的键。最后将键按照值次序依次加入到一个新列表中。

def counting_sort(n):
    '''计数排序
    
    对列表进行排序，并返回一个排序好的列表
    :param n: 列表对象
    :return: 排序结果列表
    '''
    a=min(n)
    b=max(n)#这里偷懒了，用了内置函数，这样的话就可以不断取出最小值最大值然后放入一个新列表中
    s=list(range(a,b+1))
    d=dict.fromkeys(s,0)
    for i in n:
        if i in d:
            d[i]+=1
    sss=[]
    for j in range(a,b+1):
        while j in d:
            if d[j]==0:
                del d[j]
            else:
                sss.append(j)
                d[j]-=1
    return sss

9桶排序(bucket sort)

桶排序是计数排序的升级版。我们将数据分到有限数量的桶中（k个），对每个桶再分别排序。算法时间复杂度为O（n+k）

算法描述：先进行分组，然后对每组中的数用计数排序进行排序。

import math
def bucket_sort(n):
    '''桶排序
    
    对列表进行排序，并返回一个排序好的列表
    :param n: 列表对象
    :return: 排序结果列表
    '''
    k=math.ceil(math.sqrt(len(n)))
    max_num=max(n)
    min_num=min(n)
    num=math.ceil((max_num-min_num)/k)
    s=[]
    for i in range(k-1):
        s.append(list(range(i*num,(i+1)*num)))
    s.append(list(range((i+1)*num,max_num+1)))
    sss=[]
    for j in s:
        d=dict.fromkeys(j,0)
        for i in n:
            if i in d:
                d[i]+=1
        for t in range(min(j),max(j)+1):
            while t in d:
                if d[t]==0:
                    del d[t]
                else:
                    sss.append(t)
                    d[t]-=1
        
    return sss

10基数排序(radix sort)

基数排序是对每一位进行排序，从最低位到最高位依次进行排序。这样每次操作后都会使得它前面的数在某位（i位）大于它的，程序迭代到最高位时，该数前面的数就一定会比它大。算法时间复杂度为O(kn),k为数组中最大数的位数。

算法描述：对数列中的每个数进行操作，得到它第i次操作时的第i位（从右往左）,然后将数列中的数通过第i位排序，重复进行直到i达到最大值k。算法终止。

def radix_sort(n):
    '''基数排序
    
    对列表进行排序，并返回一个排序好的列表
    :param n: 列表对象
    :return: 排序结果列表
    '''
    k=0
    while max(n)>10**k-1:
        k+=1
    j=1
    while j<k+1:
        i=0
        s=[]
        for iii in range(10):
            s.append([])  
        while i <len(n):
            k1=n[i]%10**j
            k2=k1//10**(j-1)
            s[k2].append(n[i])
            i+=1
        n=[]
        for i1 in s:
            n.extend(i1)
        j+=1
    return n

11检验

我编写了一个程序，程序中载入了系统模块random（用于生成随机数）、time（用于记录每种算法的执行时间）。载入了我们编写的十种算法，用于测试每种算法的效率。

11.1我们取1000个在1000000之内的随机数，分别用不同的算法对其排序，记录每种算法的排序时间。

结果如下：

在这种情况下，我们发现希尔排序算法与归并排序算法表现很好，而快速排序与堆排序表现不行(在我的算法中，原因未知）。而计数排序、桶排序，基数排序则是因为在样本相对离散的情况下，执行效率会很低。

11.2我们再取1000个在1000之内的随机数，分别用不同的算法对其排序，记录每种算法的排序时间。

结果如下：

在这种情况下，我们发现希尔排序算法与归并排序算法表现依旧很好，而快速排序与堆排序表现依旧不行。但是这一次计数排序、桶排序，基数排序在样本相对集中的情况下，执行效率提升了很多。（在我的算法中，桶排序执行效率低于计数排序，这个原因未知）

还望诸位大佬赐教。

检验代码

import random,time,bubble_sort,selection_sort,insertion_sort,bucket_sort,copy
import shell_sort,heap_sort,merge_sort,quick_sort,counting_sort,radix_sort
g=[]
i=0
while i <1000:
    k=random.randint(1,10**6)
    g.append(k)
    i+=1
print(g)
s=copy.deepcopy(g)
t1=time.time()
print('bubble_sort:')
bubble_sort.bubble_sort(s)
t2=time.time()
tt=t2-t1
print(tt)

s=copy.deepcopy(g)
t1=time.time()
print('selection_sort:')
selection_sort.selection_sort(s)
t2=time.time()
tt=t2-t1
print(tt)

s=copy.deepcopy(g)
t1=time.time()
print('insertion_sort:')
insertion_sort.insertion_sort(s)
t2=time.time()
tt=t2-t1
print(tt)

s=copy.deepcopy(g)
t1=time.time()
print('shell_sort:')
shell_sort.shell_sort(s)
t2=time.time()
tt=t2-t1
print(tt)

s=copy.deepcopy(g)
t1=time.time()
print('merge_sort:')
merge_sort.merge_sort(s)
t2=time.time()
tt=t2-t1
print(tt)

s=copy.deepcopy(g)
t1=time.time()
print('quick_sort:')
quick_sort.quick_sort(s,0,len(s)-1)
t2=time.time()
tt=t2-t1
print(tt)

s=copy.deepcopy(g)
t1=time.time()
print('heap_sort:')
heap_sort.heap_sort(s)
t2=time.time()
tt=t2-t1
print(tt)

s=copy.deepcopy(g)
t1=time.time()
print('counting_sort:')
counting_sort.counting_sort(s)
t2=time.time()
tt=t2-t1
print(tt)

s=copy.deepcopy(g)
t1=time.time()
print('bucket_sort:')
bucket_sort.bucket_sort(s)
t2=time.time()
tt=t2-t1
print(tt)

s=copy.deepcopy(g)
t1=time.time()
print('radix_sort:')
radix_sort.radix_sort(s)
t2=time.time()
tt=t2-t1
print(tt)

注：[1]引自：

https://blog.csdn.net/weixin_41190227/article/details/86600821?ops_request_misc=&request_id=&biz_id=102&utm_term=%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-1-86600821作者：Top_Spirit

[2]快速排序算法的代码参考了：

https://blog.csdn.net/weixin_36913190/article/details/80550347?ops_request_misc=&request_id=&biz_id=102&utm_term=%E5%BF%AB%E9%80%9F%E6%8E%92%E5%BA%8F%20python&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-2-80550347作者小海Code

weixin_39616503

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
shell sort 最后一列排序_十大排序算法（python实现）

十大排序算法（python）在计算机编程时，我们经常需要对一系列数进行排序，在这里，我将列出十种不同的排序算法，给出它们的python代码，并计算出它们的时间复杂度。0排序算法说明0.1排序的定义对一序列对象根据某个关键字进行排序。0.2 术语说明稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；内...
复制链接

扫一扫