यहां पूर्णांकों या संरचनाओं की एक सरणी के लिए उपयोग करने के लिए सॉर्ट एल्गोरिदम है जो पूर्णांक द्वारा कुंजीबद्ध हैं। विशेष रूप से तब उपयोगी होता है जब पूर्णांकों की सीमा इनपुट के आकार के क्रम में होती है।

मुख्य विचार पूर्णांकों की घटना की आवृत्ति निर्धारित करना और क्रमबद्ध क्रम निर्धारित करने के लिए इसका उपयोग करना है।

एक उदाहरण: मान लें कि हमें सरणी {1,3,1,2} मिलती है।

पहले इस इनपुट के लिए पूर्णांक, अधिकतम और न्यूनतम, 1 और 3 की सीमा निर्धारित करें।

अगला एक ऐरे बनाएं, इसे काउंट्स ऐरे कहें, जो कि पूर्णांक रेंज 1 का आकार है, इसलिए इस मामले में 3 (3-1 1)।
गिनती में उचित प्रविष्टि को बढ़ाते हुए, इनपुट सरणी पर पुनरावृति करें। किसी दिए गए इनपुट मान की गिनती गिनती [मान - मिनट] पर रखी जाएगी। दिए गए इनपुट के लिए, counts[0] मान 1 के लिए गिनती रखेगा।

इसका परिणाम गिनती सरणी में होता है: {2,1,1}

अब संचयी गिनती निर्धारित करें, जो अनिवार्य रूप से गिनती है[i] = गिनती[i-1] गिनती[i]।

इसका परिणाम संचयी गणना सारणी में होता है: {2,3,4}

सॉर्ट किए गए इनपुट के लिए एक आउटपुट ऐरे बनाएं।

अब, इनपुट पर उल्टे क्रम में पुनरावृति करें।

प्रत्येक चरण पर, इनपुट सरणी में मान के लिए संचयी गणना पुनर्प्राप्त करें। मान को पुनर्प्राप्त गणना के अनुरूप आउटपुट ऐरे इंडेक्स पर रखा जाएगा - 1. फिर संचयी गणना मान घटाएं।

पहले चरण में, मान 2 पुनर्प्राप्त किया जाता है और 3 की संचयी गणना की जाती है। मान को आउटपुट में सूचकांक 2 (3-1) पर रखा जाना चाहिए।

अगले पुनरावृत्ति में, मान 1 और संचयी गिनती 2; इसलिए इस '1' को आउटपुट के इंडेक्स 1 (2-1) पर रखा गया है।

जारी रखते हुए, मान 3 और संचयी गिनती 4; इसे आउटपुट के इंडेक्स 3 पर रखें।

अंत में, दूसरी बार मान 1 और 1 की संचयी गिनती (चूंकि पहली बार देखी गई गिनती कम हो गई थी); इसलिए यह '1' आउटपुट के सूचकांक 0 पर रखा गया है।

, देखें कि कैसे विपरीत क्रम में दोहराने से समान तत्वों का क्रम सुरक्षित रहता है जिससे सॉर्ट 'स्थिर' हो जाता है

परिणामस्वरूप क्रमबद्ध सरणी {1,1,2,3} है

func CountingSort(in []int) []int {
    // find the min/max values
    min := slices.Min(in)
    max := slices.Max(in)
    // create the count array
    counts := make([]int, max-min 1)
    for _, v := range in {
        counts[v-min]  
    }
    // determine cumulative counts
    for i := 1; i 



क्या इसे और अधिक कुशल बनाया जा सकता है? अपनी टिप्पणियाँ और सुझाव नीचे दें।

धन्यवाद!

इस पोस्ट और इस श्रृंखला के सभी पोस्ट का कोड यहां पाया जा सकता है