在C中,气泡排序最优雅的方式是什么?

你贴的东西没有 bubble sort . 这是一种“蛮力”类型,但不是泡沫类型。下面是一个通用气泡排序的示例。它使用一个任意的比较器,但您可以省略它,在这种情况下,默认比较器用于相关类型。它将对的任何(非只读)实现进行排序 IList<T> ,其中包括数组。阅读上面的链接(到维基百科),了解泡沫排序的工作原理。请注意,在每个循环中,我们从开始到结束都是如何进行的,但只将每个项目与其邻居进行比较。还是一个O(N) ^二 )排序算法,但在许多情况下,它会比您提供的版本更快。

public void BubbleSort<T>(IList<T> list)
{
    BubbleSort<T>(list, Comparer<T>.Default);
}

public void BubbleSort<T>(IList<T> list, IComparer<T> comparer)
{
    bool stillGoing = true;
    while (stillGoing)
    {
        stillGoing = false;
        for (int i = 0; i < list.Count-1; i++)
        {
            T x = list[i];
            T y = list[i + 1];
            if (comparer.Compare(x, y) > 0)
            {
                list[i] = y;
                list[i + 1] = x;
                stillGoing = true;
            }
        }
    }
}

最优雅的分类方法是

Array.Sort( object[] )

这在任何地方都适用,除了在家庭作业中,老师要求你实现不优雅的气泡排序算法。 ;-)

总的来说,泡沫排序的实现没有任何问题。如果我正在进行真正的代码检查,我将进行以下更改:

选择更多描述性变量名

为什么你的数组刚被调用 c ?

最小化变量范围

所有变量都声明在函数的顶部。除非这是一个作业要求或编码标准,否则更惯用的方法是将变量“接近”到使用它们的位置,最好这样它们就具有尽可能小的范围。

所以,去掉第一行 int i = 0,j = 0,t = 0; . 内联声明循环计数器:

for(int i = 0; i < 20; i++)

并在使用温度变量的地方声明您的温度变量:

                Console.WriteLine("c[{0}]={1}, c[{2}]={3}", i, c[i], j, c[j]);
                int t=c[i];
                c[i]=c[j];
                c[j]=t;

消除硬编码数组边界。

这是:

for(i=0;i<20;i++)

变成这样:

for(i = 0; i < c.Length; i++)

大多数人不会费心做一个 冒泡排序 优雅的。在 一般的 不过,我发现这样做:

for (int i = 0; i < items.Length; i++) {
    Item item = items[i];
    // do something with item
}

比这样做更优雅、更易于维护:

Item item;
int i;
for (i = 0; i < items.Length; i++) {
    item = items[i];
    // do something with item
}

换言之, 在最小适用范围内声明变量 . 否则你会发现自己在做什么 i 或 item 在代码中的另一个点上,然后在不应该出现的地方再次使用它们。

• 我将使用交换方法来交换两个数组项。 (关于如何将交换方法写为家庭作业的详细信息!)

• 你应该在物品已经整理好的时候考虑一下这个案子。

• 您应该阅读有关插入排序的更多标记:-)

• 与其从键盘上读取测试数据,不如看看你是否能学会如何使用nunit。

我个人更喜欢这样:

string foo [] = new string[] {"abc", "def", "aaa", "feaf", "afea" };
Array.Sort(foo);

但那只是我。排序是一个解决的问题,为什么要重新发明轮子?

我相信在 answer 提出的 Jon Skeet . 在每个循环之后,迭代次数应该排除上一次迭代中处理的最后一个项目。下面是代码:

public void BubbleSortImproved<T>(IList<T> list)
{
    BubbleSortImproved<T>(list, Comparer<T>.Default);
}

public void BubbleSortImproved<T>(IList<T> list, IComparer<T> comparer)
{
    bool stillGoing = true;
    int k = 0;
    while (stillGoing)
    {
        stillGoing = false;
        //reduce the iterations number after each loop
        for (int i = 0; i < list.Count - 1 - k; i++)
        {
            T x = list[i];
            T y = list[i + 1];
            if (comparer.Compare(x, y) > 0)
            {
                list[i] = y;
                list[i + 1] = x;
                stillGoing = true;
            }
        }
        k++;
    }
}

int[] array = {4,5,7,1,8};           

int n1, n2;
bool stillgoing = true;

while (stillgoing)
{
    stillgoing = false;
    for (int i = 0; i < (array.Length-1); i++)
    {                  
        if (array[i] > array[i + 1])
        {
            n1 = array[i + 1];
            n2 = array[i];

            array[i] = n1;
            array[i + 1] = n2;
            stillgoing = true; 
        }
    }
}
for (int i = 0; i < array.Length; i++)
{
    Console.WriteLine(array[i]);
}

从乔恩·斯基特那里得到一些想法…

    public int[] BubbleSortInAesc(int[] input)
    {
        for (int i = input.Length; i > 0; i--)
        {
            for (int j = 0; j < i-1; j++)
            {
                if (input[j] > input[j + 1])
                {
                    //Swap the numbers
                    input[j] = input[j + 1]+input[j];
                    input[j + 1] = input[j] - input[j + 1];
                    input[j] = input[j] - input[j + 1];
                }
            }
        }
        return input;
    }

我认为你的算法可以,但我会把排序功能放在一个单独的类和方法中。