什么'；C#中最优雅的冒泡排序方法是什么？

这个能清理一下吗

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

使用系统；
类升序泡泡排序
{     
公共静态void Main（）
{
int i=0，j=0，t=0；
int[]c=新的int[20]；
对于（i=0；i我个人更喜欢：

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

但那只是我。排序是一个已解决的问题，为什么要重新发明轮子呢？
我认为你的算法还可以，但我会将排序功能放在一个单独的类和方法中。
C中最优雅的排序方式是

这将适用于任何地方，除了在家庭作业问题中，老师要求你实现非优雅的气泡排序算法。
；-）

我将使用交换方法来交换这两个数组项。
（关于如何编写swap方法的详细信息留作家庭作业！）

你应该考虑一下，当物品已经整理好的时候

您应该仔细阅读插入排序以了解更多标记：-）

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

您粘贴的内容不是。它是一种“暴力”排序，但不是冒泡排序。下面是一个通用冒泡排序的示例。它使用任意比较器，但允许您忽略它，在这种情况下，默认比较器用于相关类型。它将对任何类型进行排序（非只读）IList的实现，其中包括数组。阅读上面的链接（到维基百科），了解冒泡排序的工作原理。注意我们从开始到结束的每个循环，但只将每个项目与其相邻项目进行比较。它仍然是一个O（n2）排序算法，但在许多情况下，它会比您给出的版本更快

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

public void BubbleSort（IList列表）
{
BubbleSort（列表，Comparer.Default）；
}
public void BubbleSort（IList列表、IComparer比较器）
{
bool-stillGoing=true；
虽然（仍在进行）
{
仍然继续=错误；
对于（int i=0；i0）
{
列表[i]=y；
列表[i+1]=x；
仍然继续=正确；
}
}
}
}
大多数人不会费心让气泡排序变得优雅。不过，一般来说，我发现这样做：

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
}

for（int i=0；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
}

项目；
int i；
对于（i=0；i

换句话说，在最小的适用范围内声明变量。否则，您可能会发现自己在代码中的某个其他点使用
i
或
项
，然后在不应该的地方再次使用它们。
总体而言，冒泡排序实现没有问题如果要进行真正的代码审查，我将进行以下更改：

选择更多描述性变量名称

为什么您的数组被称为
c

最小化可变范围

所有变量都在函数顶部声明。除非这是作业要求或编码标准，否则更惯用的方法是将变量声明为“接近”使用位置，最好使变量具有尽可能小的作用域

因此，删除第一行，该行读取
inti=0，j=0，t=0；
。声明循环计数器内联：

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

消除硬编码数组边界。

这：

for（i=0；i我相信建议的方法有改进。每次循环后，迭代次数应排除上一次迭代中处理的最后一项。因此，代码如下：

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

public void BubbleSortImproved（IList列表）
{
BubbleSortImproved（列表，Comparer.Default）；
}
公共无效气泡或改进（IList列表、IComparer比较器）
{
bool-stillGoing=true；
int k=0；
虽然（仍在进行）
{
仍然继续=错误；
//减少每个循环后的迭代次数
for（int i=0；i0）
{
列表[i]=y；
列表[i+1]=x；
仍然继续=正确；
}
}
k++；
}
}
int[]数组={4,5,7,1,8}；
int n1，n2；
bool-stillgoing=true；
虽然（仍在进行）
{
仍然继续=错误；
对于（int i=0；i<（array.Length-1）；i++）
{                  
if（数组[i]>数组[i+1]）
{
n1=阵列[i+1]；
n2=阵列[i]；
数组[i]=n1；
阵列[i+1]=n2；
仍然继续=正确；
}
}
}
for（int i=0；i

从Jon skeet那里得到一些想法…
public int[]BubbleSortInAesc（int[]输入）
    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;
    }

{
对于（int i=input.Length；i>0；i--）
{
对于（int j=0；j输入[j+1]）
{
//交换号码
输入[j]=输入[j+1]+输入[j]；
输入[j+1]=输入[j]-输入[j+1]；
输入[j]=输入[j]-输入[j+1]；
}
}
}
返回输入；
}
优雅和气泡排序不属于同一句话，IMHO。如果这是一个家庭作业，我会让代码尽可能难看，并在上面乱扔评论，比如“故意给代码添加恶心，以反映我对该算法的厌恶”…老师会尊重你的原则。这不是空谈…@Ian:学习h是有价值的
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;
    }