Comment implémenter l'algorithme de tri par compartiment en C#

Comment implémenter l'algorithme de tri par bucket en C#

Bucket Sort est un algorithme de tri qui divise les éléments à trier dans différents buckets en fonction de leurs tailles, puis trie chaque bucket séparément. Fusionnez ensuite les éléments de chaque compartiment afin d’obtenir un résultat ordonné. La complexité temporelle du tri par seau est O(n), et dans certains cas spécifiques, il peut même atteindre l'efficacité du tri linéaire.

Ce qui suit présente comment implémenter l'algorithme de tri par bucket en C# et donne des exemples de code spécifiques :

using System;
using System.Collections.Generic;

class BucketSort
{
    /// <summary>
    /// 桶排序算法实现
    /// </summary>
    /// <param name="data">待排序的数组</param>
    public static void Sort(double[] data)
    {
        if (data == null || data.Length <= 1)
        {
            return;
        }

        int bucketCount = data.Length;
        List<double>[] buckets = new List<double>[bucketCount];
        for (int i = 0; i < bucketCount; i++)
        {
            buckets[i] = new List<double>();
        }

        // 将数据分配到各个桶中
        for (int i = 0; i < data.Length; i++)
        {
            int bucketIndex = (int)(data[i] * bucketCount);
            buckets[bucketIndex].Add(data[i]);
        }

        // 对每个桶中的数据进行插入排序
        for (int i = 0; i < bucketCount; i++)
        {
            InsertionSort(buckets[i]);
        }

        // 合并各个有序桶中的数据
        int dataIndex = 0;
        for (int i = 0; i < bucketCount; i++)
        {
            for (int j = 0; j < buckets[i].Count; j++)
            {
                data[dataIndex++] = buckets[i][j];
            }
        }
    }

    /// <summary>
    /// 插入排序算法实现
    /// </summary>
    /// <param name="data">待排序的数组</param>
    private static void InsertionSort(List<double> data)
    {
        for (int i = 1; i < data.Count; i++)
        {
            double temp = data[i];
            int j = i - 1;
            while (j >= 0 && data[j] > temp)
            {
                data[j + 1] = data[j];
                j--;
            }
            data[j + 1] = temp;
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        double[] data = { 0.5, 0.2, 0.8, 0.3, 0.6, 0.1, 0.9, 0.7, 0.4 };
        Console.WriteLine("原始数组：");
        PrintData(data);
        BucketSort.Sort(data);
        Console.WriteLine("排序后的数组：");
        PrintData(data);
    }

    /// <summary>
    /// 打印数组元素
    /// </summary>
    /// <param name="data">待打印的数组</param>
    private static void PrintData(double[] data)
    {
        foreach (var item in data)
        {
            Console.Write(item + " ");
        }
        Console.WriteLine();
    }
}

Ce qui précède est l'exemple de code pour implémenter l'algorithme de tri par bucket en C#. Dans la fonction principale, un tableau contenant des décimales aléatoires est créé et la fonction BucketSort.Sort方法对其进行排序。最后，通过调用PrintData est utilisée pour afficher le tableau trié sur la console.

En exécutant le code ci-dessus, vous obtiendrez un résultat similaire au suivant :

原始数组：
0.5 0.2 0.8 0.3 0.6 0.1 0.9 0.7 0.4
排序后的数组：
0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9

Le tri par bucket est un algorithme de tri efficace, particulièrement adapté aux situations où les éléments de données sont uniformément répartis. Grâce aux exemples de code ci-dessus, vous pouvez apprendre à implémenter l'algorithme de tri par compartiment en C# et vous pouvez utiliser le tri par compartiment pour effectuer des opérations de tri dans vos propres projets. Dans le même temps, vous pouvez également modifier et étendre le code en fonction des besoins réels pour répondre à des besoins de tri spécifiques.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!