c Sharp冒泡排序

下面是 C# 冒泡排序的实现代码：

public static void BubbleSort(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])
            {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

示例调用：

int[] arr = { 64, 34, 25, 12, 22, 11, 90 };
BubbleSort(arr);

该算法的时间复杂度为 O(n^2)，适合于小规模的数据排序。

相关问题

生成C sharp冒泡排序完整代码

### 回答1：
using System;

class BubbleSort
{
static void Main(string[] args)
{
int[] arr = { 5, 1, 4, 2, 8 };
int temp;

for (int i = 0; i < arr.Length; i++)
{
for (int j = 0; j < arr.Length - 1; j++)
{
if (arr[j] > arr[j + 1])
{
temp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = temp;
}
}
}

for (int i = 0; i < arr.Length; i++)
{
Console.Write(arr[i] + " ");
}
Console.ReadKey();
}
}

### 回答2：
下面是C#语言中冒泡排序的完整代码：

using System;

public class BubbleSort
{
    public static void Main(string[] args)
    {
        int[] array = { 64, 34, 25, 12, 22, 11, 90 };

        Console.WriteLine("排序前的数组：");
        PrintArray(array);

        BubbleSortArray(array);

        Console.WriteLine("排序后的数组：");
        PrintArray(array);
    }

    public static void BubbleSortArray(int[] array)
    {
        int n = array.Length;
        for(int i = 0; i < n-1; i++)
        {
            for(int j = 0; j < n-i-1; j++)
            {
                if(array[j] > array[j+1])
                {
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
    }

    public static void PrintArray(int[] array)
    {
        foreach(int num in array)
        {
            Console.Write(num + " ");
        }
        Console.WriteLine();
    }
}

以上代码定义了一个BubbleSort类和三个方法：Main方法、BubbleSortArray方法和PrintArray方法。在Main方法中，我们声明了一个整型数组，并且打印出排序前的数组。然后调用BubbleSortArray方法对数组进行冒泡排序。最后，再次打印出排序后的数组。BubbleSortArray方法使用两层循环来进行排序，通过比较相邻的元素并交换位置来实现排序。PrintArray方法用于打印数组中的每个元素。

### 回答3：
下面是C#语言实现冒泡排序的完整代码：

using System;

public class BubbleSort
{
    public static void Main(string[] args)
    {
        int[] arr = { 5, 2, 8, 9, 1, 3 };
        Console.WriteLine("排序前的数组：");
        PrintArray(arr);

        BubbleSortArray(arr);

        Console.WriteLine("排序后的数组：");
        PrintArray(arr);
    }

    public static void BubbleSortArray(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;
                }
            }
        }
    }

    public static void PrintArray(int[] arr)
    {
        foreach (int num in arr)
        {
            Console.Write(num + " ");
        }
        Console.WriteLine();
    }
}

这段代码定义了一个名为`BubbleSort`的类，包含了一个`BubbleSortArray`方法和一个`PrintArray`方法。`BubbleSortArray`方法接收一个整数数组作为参数，并对其进行冒泡排序。`PrintArray`方法接收一个整数数组，用于打印排序前和排序后的数组。

在`Main`方法中，我们声明了一个整数数组`arr`，并初始化了一些随机值。然后，我们先打印排序前的数组，再调用`BubbleSortArray`方法对数组进行排序，最后打印排序后的数组。

冒泡排序算法的核心是两层嵌套的循环，第一层循环控制比较的轮数，第二层循环控制每一轮中的比较次数。在每一轮中，如果前一个元素大于后一个元素，则交换它们的位置，直到没有需要交换的元素为止。

以上就是使用C#语言实现冒泡排序的完整代码。

写一个C Sharp的冒泡排序

### 回答1：

我可以为您编写一个C Sharp的冒泡排序算法：
public static void BubbleSort(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])
{
// swap temp and arr[i]
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}

### 回答2：
冒泡排序是一种简单的排序算法，通过交换相邻的元素将较大（或较小）的值向右（或向左）移动到列表的末尾。下面是一个使用C Sharp编写的冒泡排序算法的示例：

using System;

class BubbleSortExample
{
    static void BubbleSort(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;
                }
            }
        }
    }

    static void Main(string[] args)
    {
        int[] arr = { 64, 34, 25, 12, 22, 11, 90 };

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

        BubbleSort(arr);

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

        Console.ReadLine();
    }
}

以上代码定义了一个BubbleSortExample类，其中包含一个BubbleSort方法来实现冒泡排序。在Main方法中，定义了一个整数数组arr，并使用BubbleSort方法对其进行排序。

输出的结果为：

排序前的数组：
64 34 25 12 22 11 90 
排序后的数组：
11 12 22 25 34 64 90

这是冒泡排序算法对输入数组进行排序后的结果。

### 回答3：
冒泡排序是一种简单的排序算法，在C#中可以很容易地实现。下面是一个示例代码：

using System;

class BubbleSort
{
    static void Main()
    {
        int[] arr = { 5, 2, 8, 12, 1 };
        Console.WriteLine("排序前的数组:");
        PrintArray(arr);

        BubbleSortAlgorithm(arr);
        
        Console.WriteLine("\n排序后的数组:");
        PrintArray(arr);
    }

    static void BubbleSortAlgorithm(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])
                {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    static void PrintArray(int[] arr)
    {
        foreach (int element in arr)
        {
            Console.Write(element + " ");
        }
    }
}

上述代码首先定义了一个整数数组 `arr`，包含了要排序的元素。然后，通过 `BubbleSortAlgorithm` 函数实现了冒泡排序算法。该函数通过两个嵌套的循环遍历数组，并比较相邻的元素，若前者比后者大，则交换它们的位置。最内层的 `j` 循环控制每一轮的比较和交换，而外层的 `i` 循环用于控制整个排序的轮数。

在 `Main` 方法中，首先输出未排序的数组，然后调用 `BubbleSortAlgorithm` 函数对数组进行排序，并输出排序后的结果。

最后，输出结果如下所示：

排序前的数组:
5 2 8 12 1 
排序后的数组:
1 2 5 8 12 

这个示例代码可以帮助你理解如何使用C#编写一个冒泡排序算法。