C# 冒泡排序

冒泡排序是一种简单的排序算法，它重复地遍历待排序的元素，比较相邻两个元素的大小，并按照规定的顺序交换它们，直到整个序列排序完成。

具体原理如下：

1. 从序列的第一个元素开始，比较相邻的两个元素，如果前一个元素大于后一个元素，则交换它们的位置。
2. 继续向后比较相邻的两个元素，重复上述步骤，直到将最大的元素移动到序列的最后位置。
3. 对除了已排序的最后一个元素的子序列重复上述步骤，直到整序列排序完成。

冒泡排序的时间复杂度为O(n^2)，其中n是待排序序列的长度。

冒泡排序是稳定的，即相等元素的相对顺序在排序前后保持不变。在比较相邻元素时，只有前一个元素大于后一个元素时才会交换它们的位置，所以相等元素不会发生位置交换。

class Program
{
    static void Main(string[] args)
    {
        int[] arr = { 5, 2, 8, 1, 4 ,4234,34,23 };

        BubbleSortTest(arr);

        Console.WriteLine("排序后的数组：");
        foreach (int num in arr)
        {
            Console.Write(num + " ");
        }
    }

    static void BubbleSortTest(int[] arr)
    {
        int n = arr.Length;
        for (int i = 0; i < n - 1; i++)
        {
            for (int j = 0; j < n - i - 1; j++)
            {
                if (arr[j] > arr[j + 1])
                {
                    // 交换arr[j]和arr[j+1]
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

运行结果

{ 5, 2, 8, 1, 4 ,4234,34,23 }; 冒泡排序这些数据比较几轮，每轮都是如何比较的

冒泡排序会进行 n-1 轮比较，其中 n 是待排序数据的个数。

第一轮比较时，会从第一个元素开始，依次与其后面的元素进行比较，如果发现前面的元素大于后面的元素，则交换它们的位置。比较的顺序如下：

5和2比较，发现5大于2，交换位置，数组变为 { 2, 5, 8, 1, 4, 4234, 34, 23 }；
5和8比较，发现5小于8，位置不变；
8和1比较，发现8大于1，交换位置，数组变为 { 2, 5, 1, 8, 4, 4234, 34, 23 }；
8和4比较，发现8大于4，交换位置，数组变为 { 2, 5, 1, 4, 8, 4234, 34, 23 }；
8和4234比较，发现8小于4234，位置不变；
4234和34比较，发现4234大于34，交换位置，数组变为 { 2, 5, 1, 4, 8, 34, 4234, 23 }；
4234和23比较，发现4234大于23，交换位置，数组变为 { 2, 5, 1, 4, 8, 34, 23, 4234 }；

第一轮比较结束后，最大的元素4234已经被移到了最后的位置。

第二轮比较时，会从第一个元素开始，依次与其后面的元素进行比较，比较的顺序如下：

2和5比较，发现2小于5，位置不变；
5和1比较，发现5大于1，交换位置，数组变为 { 2, 1, 5, 4, 8, 34, 23, 4234 }；
5和4比较，发现5大于4，交换位置，数组变为 { 2, 1, 4, 5, 8, 34, 23, 4234 }；
5和8比较，发现5小于8，位置不变；
8和34比较，发现8小于34，位置不变；
34和23比较，发现34大于23，交换位置，数组变为 { 2, 1, 4, 5, 8, 23, 34, 4234 }；

第二轮比较结束后，第二大的元素34已经被移到了倒数第二个位置。

依此类推，直到第 n-1 轮比较结束，整个数组就被排序好了。