algorithm
बकेट सॉर्ट

बकेट सॉर्ट बेसिक जानकारी

बाल्टी सॉर्ट एक छँटाई एल्गोरिथ्म है जिसमें इनपुट सरणी के तत्वों को बाल्टी में वितरित किया जाता है। सभी तत्वों को वितरित करने के बाद, एक और छँटाई एल्गोरिथ्म द्वारा बाल्टी को व्यक्तिगत रूप से सॉर्ट किया जाता है। कभी-कभी इसे पुनरावर्ती विधि द्वारा भी हल किया जाता है।

बकेट सॉर्ट के लिए छद्म कोड

1. चलो इनपुट सूची एल की लंबाई हो;
2. प्रत्येक तत्व के लिए मैं एल से
3. यदि B [i] खाली नहीं है
4. A [i] को B [i] में रखो;
5. Else B [i]: = A [i]
6. कॉनकैट बी [i .. n] को एक क्रमबद्ध सूची में लौटाएं;

बाल्टी प्रकार का उदाहरण:

ज्यादातर लोग थोड़े से अनुकूलन के लिए सम्मिलन प्रतिमान का उपयोग करते हैं।
सहायक स्थान: O{n}

C # कार्यान्वयन

public class BucketSort
{
    public static void SortBucket(ref int[] input)
    {
        int minValue = input[0];
        int maxValue = input[0];
        int k = 0;

        for (int i = input.Length - 1; i >= 1; i--)
        {
            if (input[i] > maxValue) maxValue = input[i];
            if (input[i] < minValue) minValue = input[i];
        }

        List<int>[] bucket = new List<int>[maxValue - minValue + 1];

        for (int i = bucket.Length - 1; i >= 0; i--)
        {
            bucket[i] = new List<int>();
        }

        foreach (int i in input)
        {
            bucket[i - minValue].Add(i);
        }

        foreach (List<int> b in bucket)
        {
            if (b.Count > 0)
            {
                foreach (int t in b)
                {
                    input[k] = t;
                    k++;
                }
            }
        }
    }

    public static int[] Main(int[] input)
    {
        SortBucket(ref input);
        return input;
    }
}