什么是最优雅的方式来冒泡排序在C＃中？(What's the most elegant wa

Can this be cleaned up?

using System;  
class AscendingBubbleSort 
{     
    public static void Main()
    {
        int i = 0,j = 0,t = 0;
        int []c=new int[20];
        for(i=0;i<20;i++)
        {
            Console.WriteLine("Enter Value p[{0}]:", i);
            c[i]=int.Parse(Console.ReadLine());
        }
        // Sorting: Bubble Sort
        for(i=0;i<20;i++)
        {
            for(j=i+1;j<20;j++)
            {
                if(c[i]>c[j])
                {
                    Console.WriteLine("c[{0}]={1}, c[{2}]={3}", i, c[i], j, c[j]);
                    t=c[i];
                    c[i]=c[j];
                    c[j]=t;
                }
            }
        }
        Console.WriteLine("bubble sorted array:");
        // sorted array output
        for(i=0;i<20;i++)
        {
            Console.WriteLine ("c[{0}]={1}", i, c[i]);
        }
    }
}

Answer 1:

什么你已经粘贴有不冒泡排序。这是一种“暴力”之类的，但它不是冒泡排序。这里有一个通用的冒泡排序的例子。它使用一个任意的比较器，但是可以让你忽略它在默认的比较被用于相关类型的情况。它将任何排序（非只读）执行IList<T>它包括阵列。看了上面的链接（维基百科），以获得更多的冒泡排序是怎么打算的工作理念。注意如何在每个循环中，我们经历从开始到结束，但只有每个项目与邻国进行比较。这仍然是一个O（N ^2）排序算法，但在许多情况下，它会比你给的版本更快。

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;
            }
        }
    }
}

Answer 2:

在C＃中排序最优雅的方式是

Array.Sort( object[] )

这将工作无处不在，除了在家庭作业的问题何老师问你实现非优雅的冒泡排序算法。 ;-)

Answer 3:

总体而言，没有什么不对您的冒泡排序的实现。如果我做一个真正的代码审查，我会做如下修改：

选择更具描述性的变量名称

为什么你的阵列刚打电话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++)

Answer 4:

大多数人不会理会做出冒泡排序优雅。 总的来说 ，虽然，我发现，这样做：

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在代码中的一些其他点，然后再使用它们，你不应该。

Answer 5:

我会用基法交换两个数组项的交换。（如何编写交换方法的细节留家庭作业！）
你应该考虑的情况下，当项目已经为了
您应该插入排序的多个标记阅读了:-)
而不是阅读从键盘测试数据，看看你能不能学会如何使用NUnit

Answer 6:

我个人比较喜欢这样的：

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

但是，这只是我的。排序是一个解决问题，为什么另起炉灶？

Answer 7:

我相信这是在改善答案提出乔恩斯基特。每个循环后，迭代的次数应排除在先前的迭代处理的最后一个项目。所以，这里的代码：

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++;
    }
}

Answer 8:

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]);
}

从接过乔恩斯基特一些想法...

Answer 9:

    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;
    }