C# 一种使用二进制方法的快速冒泡排序变体

我一直在做一些面试问题的准备，在这个过程中，我提出了一个关于冒泡排序的小变体，它将我学到的关于二进制搜索的知识整合到了交换的内部循环中。因此，时间复杂度比O（n^2）大约降低了50%。我想我的问题是我是不是在浪费时间搞泡泡排序？我应该学习桶排序并完成它吗

我一直在使用以下输入进行测试

int[] nums = { 9878, 1, 4, 8, 5, 7, 88, 1, 54, 2, 2, 9878, 5, 7, 3, 11, 1, 4, 8, 5, 7, 88, 1, 54, 2, 2, 5, 7, 3, 11 };

public static int[] sortWBinary(int[] ar)
{
      var swapped = true;
      for (int i = 0; i < ar.Length && swapped; i++)
      {
          swapped = false;
          for (int k = i, j = ar.Length - 1; k < ar.Length - i - 1 && j > 0; k++, j--)
          {
              if (ar[k] > ar[k + 1])
              {
                  var temp = ar[k];
                  ar[k] = ar[k + 1];
                  ar[k + 1] = temp;
                  swapped = true;
              }

              if (ar[j - 1] > ar[j])
              {
                  var temp = ar[j - 1];
                  ar[j - 1] = ar[j];
                  ar[j] = temp;
                  swapped = true;
              }

          }
      }

      return ar;
  }

int[]nums={9878,1,4,8,5,7,88,1,54,2,2,9878,5,7,3,11,1,4,8,5,7,88,1,54,2,2,5,7,3,11}；
公共静态int[]sortWBinary（int[]ar）
{
var交换=真；
对于（int i=0；i0；k++，j--）
{
if（ar[k]>ar[k+1]）
{
var-temp=ar[k]；
ar[k]=ar[k+1]；
ar[k+1]=温度；
交换=真；
}
if（ar[j-1]>ar[j]）
{
var-temp=ar[j-1]；
ar[j-1]=ar[j]；
ar[j]=温度；
交换=真；
}
}
}
返回ar；
}

VS.

public static int[] sortWoBinary(int[] ar)
{
    var swapped = true;
    for (int i = 0; i < ar.Length && swapped; i++)
    {
        swapped = false;
        for (int k = 0; k < ar.Length - i - 1; k++)
        {
            if (ar[k] > ar[k + 1])
            {
                var temp = ar[k];
                ar[k] = ar[k + 1];
                ar[k + 1] = temp;
                swapped = true;
            }
        }
    }
    return ar;
}

公共静态int[]sortWoBinary（int[]ar）
{
var交换=真；
对于（int i=0；iar[k+1]）
{
var-temp=ar[k]；
ar[k]=ar[k+1]；
ar[k+1]=温度；
交换=真；
}
}
}
返回ar；
}

对于排序，请了解

O（n log（n））

和

O（n^2）

之间的区别，并知道如果您有足够的数据关心您正在做的事情，您总是希望使用前者

以下是你应该能够谈论的所有类型。如果我在面试你，我只在乎你知道前两个。在告诉您如何编写之后，我可能会要求您实现第三个，但我不在乎您是否知道它

你图书馆里有什么。任何程序员如果不知道如何首先达到这一点，都会对他们的代码库造成威胁，因此不应该因此而被雇佣

外部排序工具，如Unix

sort

实用程序或SQL中的

orderby

函数。当您需要随意处理数据并进行选择时，不要将其吸入内存进行排序，而是首先将其排序到更有效的位置

合并排序。（对于专家来说）在我的一生中，我需要写两次排序，前两个选项是不够的。两次都是同一个故事。太多的数据无法使用库例程，并且由于一系列复杂的原因不适合使用外部工具。因此，它必须是一个外部排序（即中间文件保存在磁盘内存之外）。如果您需要编写外部排序，合并排序是您的朋友

快速排序。（当被想成为专家的人采访时）偶尔有人会问你图书馆分类是如何运作的。我会说，“有很多方法可以实现，但在很长一段时间里，快速排序是标准的。你想让我展示一下它是如何工作的吗？”这通常是他们想要的答案。很少有人知道快速排序在很大程度上已被timsort取代。有人可以进一步挖掘，并被告知，“在本世纪，平台一直朝着timsort发展。它是为Python而发明的，已经被Java、Chrome和其他平台采用。我必须看看它是如何工作的。”

基数排序。（在接受smartasses采访时）如果有人问你是否可以比

O（n log（n））

更快排序，你需要知道这一点。知道答案可能会让他们更加努力地工作，以表明他们的书呆子资历比你的好。这将是我不愿意与他们合作的标志

---

在我看来，学习“最佳”排序方法是浪费时间。如果您使用的是C#，那么唯一需要的排序方法就是

source.sort（）

。对.NETAPI、流行框架和CICD的了解将使您在这个世界上走得更远。我的意思是，你改变了现有的排序算法，现在正在寻找改进算法的方法，这一事实向我表明你有解决问题的能力和团队合作意识。这比复杂的排序算法知识更有价值。你为什么说第一个aproach要快50%。这两种方法的复杂度是相同的（除了你想并行执行第一种方法），我取了这两种方法之间关于各自迭代次数的差值，然后除以原始执行的迭代次数。结果是大约有50%的变化。这是有意义的，因为我们可能会在每次迭代中进行两次交换，而在每次外部循环的迭代中，内部循环的下限增量会增加一倍。因此，对于内部的不完全对数（n），但更接近。@cSkillzMartin没有最佳排序算法。每个都有其用途，其选择取决于数据集属性、大小、可用内存等。。。使用冒泡排序在某些情况下是可以的，在其他情况下则不是。。。同样适用于快速排序、合并排序、桶排序和所有其他。。。在某些情况下，冒泡排序可能比快速排序更快，甚至比桶式排序更快，而在另一些情况下，冒泡排序无法。。。