C#中的冒泡排序[关闭]答案

【问题标题】：Bubble Sort in C# [closed]C#中的冒泡排序[关闭]
【发布时间】：2014-04-26 11:41:18
【问题描述】：

我正在研究算法，我有两个冒泡排序函数/方法，它们都提供了相似的结果。谁能告诉我更多关于他们的信息，比如性能等？

public void BubbleSort() {
        int temp;
        for (int outer = upper; outer >= 1; outer--) {
            for (int inner = 0; inner <= outer - 1; inner++) {
                if ((int)arr[inner] > arr[inner + 1]) {
                    temp = arr[inner];
                    arr[inner] = arr[inner + 1]; 
                    arr[inner + 1] = temp;
                }
            }
        }
    }

public void BubbleSor2() {
    int temp;
    for (int outer = 0; outer < upper - 1; outer++) {
        for (int inner = 1; inner <= upper; inner++) {
           if ((int)arr[outer] > arr[inner]) {
               temp = arr[inner];
               arr[inner] = arr[outer];
               arr[outer] = temp;
            }
        }
    }
}

【问题讨论】：

标签： algorithm sorting c#-4.0 bubble-sort

【解决方案1】：

它们是相反的，但是，实现是不正确的。用这个替换它：

public void BubbleSort() {
        int temp;
        for (int outer = upper; outer >= 1; outer--) {
            for (int inner = outer - 1; inner >= 0; inner--) {
                if (arr[inner] < arr[outer]) {
                    temp = arr[inner];
                    arr[inner] = arr[outer]; 
                    arr[outer] = temp;
                }
            }
        }
    }

public void BubbleSor2() {
    int temp;
    for (int outer = 0; outer < upper - 1; outer++) {
        for (int inner = outer + 1; inner < upper; inner++) {
           if (arr[inner] > arr[outer]) {
               temp = arr[inner];
               arr[inner] = arr[outer];
               arr[outer] = temp;
            }
        }
    }
}

两者的复杂度都是二次的(O(n^2))

【讨论】：

【解决方案2】：

试试这个版本的冒泡排序。

public void BubbleSort()
{
    int temp;
    for (int outer = 0; outer < upper - 1; outer++)
    {
        for (int inner = 0; inner < upper - outer; inner++)
        {
            if (arr[inner + 1] < arr[inner])
            {
                temp = arr[inner + 1];
                arr[inner + 1] = arr[inner];
                arr[inner] = temp;
            }
        }
    }
}

【讨论】：

【解决方案3】：

第一个在外面有一个 n 循环。这里 n = 上 - 1;在每次迭代中，它的运行次数都比前一次迭代少一个。所以它运行(n*(n-1))/2 = (n^2-n)/2 次。这是 O(n^2) 复杂度。

第二个不是冒泡排序，尽管它的结果与第一个相同。它的运行复杂度为 O(n^2)。

第一次迭代中的第一个将最大值放在arr 的upperth 位置。在第二次迭代中，将第二个最大值放在upper-1 th 位置的arr 中，第三次迭代将第三个最大值放在upper-2th 位置，依此类推。每次将最大值放在(last position of array - iteration number)th 位置。因此冒泡排序。

第二个目标相同，但方法不同。在第一次迭代中，将arr 中的最小值放在0th 位置。在第二次迭代中，将第二个最小值放在1 位置中的arr 中，第三次迭代将第三个最大值放在2nd 位置，依此类推。每次将最小值放在iteration number-1th 位置。

【讨论】：