Python 在什么情况下双向冒泡排序优于标准冒泡排序？

我已经实现了双向气泡排序算法。但是我想不出一个双向冒泡排序比标准冒泡排序更好的场景。有人能给我一些线索吗

我的Python实现：

def bubbleSort_v(my_list):
    s = 0
    e = 0
    right = True
    for index in range(len(my_list)-1,0,-1):
        if right:
            right = False
            for idx in range(s,index+e,1):
                if my_list[idx] > my_list[idx+1]:
                    my_list[idx],my_list[idx+1] = my_list[idx+1],my_list[idx]
            s += 1
        else:
            right = True
            for idx in range(index-1+s,e,-1):
                if my_list[idx] < my_list[idx-1]:
                    my_list[idx],my_list[idx-1] = my_list[idx-1],my_list[idx]
            e += 1
    return my_list

def bubbleSort_v（我的列表）：
s=0
e=0
右=真
对于范围内的索引（len（my_列表）-1,0，-1）：
如果正确：
右=假
对于范围（s，索引+e，1）内的idx：
如果我的列表[idx]>我的列表[idx+1]：
我的清单[idx]，我的清单[idx+1]=我的清单[idx+1]，我的清单[idx]
s+=1
其他：
右=真
对于范围内的idx（索引-1+s，e，-1）：
如果我的清单[idx]<我的清单[idx-1]：
我的清单[idx]，我的清单[idx-1]=我的清单[idx-1]，我的清单[idx]
e+=1
返回我的列表

---

谢谢

如果有一个元素位于列表的右侧（例如最后一个索引），则应将其移动到列表的左侧（例如第一个索引）。使用单向气泡排序需要很长时间：每次只移动一步

但是，如果执行双向bubblesort，元素将在向右的第一步中向左移动

因此，一般来说，最好将一个或多个元素（在大量位置上）移动到与单向泡泡排序相反的方向。

但是，对于您的bubblesort实现来说，这并没有多大区别：通常，bubblesort会在排序时进行测试。如果它可以在没有交换的情况下进行完整的运行，它将停止工作

例如，向右移动的单向气泡端口：

def单气泡（数据）：
对于范围内的i（len（数据））：
can_exit=True
对于范围内的j（透镜（数据）-i-1）：
如果数据[j]>数据[j+1]：
数据[j]，数据[j+1]=数据[j+1]，数据[j]
can_exit=False
如果您可以退出：
返回

因此，如果您想将一个元素向左移动大量位置，那么对于每一个这样的步骤，您将不得不再次执行完整的循环。我们可以进一步优化上述方法，但这种行为无法消除

双向bubblesort的实现方式如下：

def single_bubble(data):
    for i in range(len(data)):
        can_exit = True
        for j in range(len(data)-i-1):
            if data[j] > data[j+1]:
                data[j],data[j+1] = data[j+1],data[j]
                can_exit = False
        if can_exit:
            return
        for j in range(len(data)-i,i,-1):
            if data[j-i] > data[j]:
                data[j-1],data[j] = data[j],data[j-1]
                can_exit = False
        if can_exit:
            return

def单气泡（数据）：
对于范围内的i（len（数据））：
can_exit=True
对于范围内的j（透镜（数据）-i-1）：
如果数据[j]>数据[j+1]：
数据[j]，数据[j+1]=数据[j+1]，数据[j]
can_exit=False
如果您可以退出：
返回
对于范围内的j（len（数据）-i，i，-1）：
如果数据[j-i]>数据[j]：
数据[j-1]，数据[j]=数据[j]，数据[j-1]
can_exit=False
如果您可以退出：
返回

也就是说，气泡排序通常不是一个好的排序算法。有更好的算法，如快速排序、合并排序、timsort、radixsort（用于数字数据）等

Bubblesort实际上是一个非常糟糕的算法，即使在O（n2）算法中也是如此，因为它会一次将对象移动一个位置。插入排序将简单地首先计算必须移动的内容，然后快速移动列表中的该部分，从而节省大量无用的移动。然而，当学习设计、实现和分析算法时，这些算法可以起到教育的作用，因为与更先进的算法相比，这些算法的性能会非常差

---

自己实现（通用）排序功能可能没有好处：所有流行编程语言都实现了好的算法，这些算法速度快，占用内存少，等等。

在所有情况下都很糟糕介绍和“与冒泡排序的区别”在维基百科上，用例子讨论你的问题。朋友不允许朋友使用冒泡排序。研究冒泡排序家族的唯一原因是因为它们易于理解，而且通常很容易解释为什么几乎任何其他排序算法都优于它（当然，不包括像bogosort这样疯狂的东西）。@GarrGodfrey。如果您的数据已经排序或接近排序，则可以接受冒泡排序。也许仍然不是最好的选择，但至少不可怕。马克·兰森是这么说的。OTOH，Python出色的TimSort也非常擅长对包含已排序序列的数据进行排序。因此，如果您有一个已排序的列表，并在其中附加（或插入）随机内容&重新排序，TimSort将有效地处理该作业。类似地，它将有效地合并一组已连接在一起的已排序列表中的数据。对于大列表，O（n logn）排序（如quicksort或mergesort）将更优越，但对于较小的列表，O（n^2）可能更快，这就是为什么我们有混合算法，对小（子）列表使用O（n^2）。但即使在O（n^2）排序中，bubblesort也比（例如）选择排序或插入排序更糟糕。@PM2Ring：是的，但对于小列表，性能通常不是问题。我认为，无论采用何种算法，对包含10个元素的列表进行排序都不会对程序的性能产生显著影响。通常在这种情况下，瓶颈在其他地方。当然，在Python中，你几乎应该总是使用TimSort，除非你知道像radixsort这样的东西适合你的数据。OTOH，虽然所有现代语言都提供排序设施，但对于compsci学生来说，学习各种标准排序算法仍然是一个好主意，这不是因为他们需要在现实世界中实现它们，而是因为它们是学习算法分析的一个很好的主题。

def single_bubble(data):
    for i in range(len(data)):
        can_exit = True
        for j in range(len(data)-i-1):
            if data[j] > data[j+1]:
                data[j],data[j+1] = data[j+1],data[j]
                can_exit = False
        if can_exit:
            return
        for j in range(len(data)-i,i,-1):
            if data[j-i] > data[j]:
                data[j-1],data[j] = data[j],data[j-1]
                can_exit = False
        if can_exit:
            return