एरे एलिमेन्ट्सको समूह बहु घटना पहिलो घटना द्वारा आदेश  


कठिनाई तह सजिलो
बारम्बार सोधिन्छ समग्र एडोब अमेजन दिल्लीवरी फोरकाइट्स
एरे हैश

तपाईंलाई एक प्रश्न दिइन्छ जसमा तपाईं एक क्रमबद्ध नहुनु भएको छ array संख्याको बहु घटनाहरूको साथ। कार्य भनेको एर्रे एलिमेन्टहरूको सबै बहु घटनाहरू पहिलो घटना द्वारा क्रमबद्ध गरीएको छ। यस बीच, अर्डर आउने संख्या जस्तै हुनुपर्दछ।

उदाहरणका  

इनपुट:

[२, 2,१,3,4,3,1,3,2,4,२,XNUMX]

उत्पादन:

[२ २ 2 2 3 3 3 १]

इनपुट:

[१ 5,4,1,5,4,1,5,6 XNUMX XNUMX १२२]

उत्पादन:

[२ २ 5 5 5 4 4 १]

अल्गोरिदम  

  1. घोषणा गर्नुहोस् हशम्याप.
  2. एर्रे पार गर्नुहोस् र सबै तत्वहरू र यसको फ्रिक्वेन्सी ह्याशम्यापमा राख्नुहोस्।
  3. एर्रे ट्र्याभरिंग गर्दा र प्रत्येक तत्वको फ्रिक्वेन्सी पाउनुहोस्।
    1. त्यो फ्रिक्वेन्सी समयहरूमा त्यो कुञ्जी प्रिन्ट गर्नुहोस्।
    2. त्यो एरर हटाउनुहोस् [i] (कुञ्जी)।

एरे एलिमेन्ट्सको समूह बहु घटनाको लागि स्पष्टीकरण  

हामी यसको लागि ह्याशिing प्रयोग गर्दैछौं। ह्याशिंगले तत्वहरूलाई कुञ्जी-मान जोडीको रूपमा भण्डारण गर्ने सुविधा प्रदान गर्दछ। यस प्रश्नमा, हामी एक एर्रे एलिमेन्टको रूपमा कुञ्जी र प्रत्येक एलिमेन्टको फ्रिक्वेन्सीको रूपमा मान प्रयोग गर्ने छौं। हामी केवल एलिमेन्ट हाल्छौं यदि यो ह्यास तालिकामा छैन भने। अन्यथा तत्वको गणना (कुञ्जी-मान) वृद्धि गर्नुहोस्।

पहिले, हामी ह्यासम्याप घोषणा गर्नेछौं "मेरो म्याप"। हामी त्यसपछि सम्पूर्ण एर्रे पार र गणना र भण्डारण गर्दछौं आवृत्ति प्रत्येक तत्व को।

हामी एक उदाहरण विचार र यसलाई बुझौं।

उदाहरणका

एआर = [,,,, १,,,,, १,,,]]

पनि हेर्नुहोस्
दिइएको योगफलको साथ सबबार (फेला पार्नुहोस् नकारात्मक नम्बरहरू)

i = 0, एर [i] =।

myMap = {:: १}

i = 1, एर [i] =।

myMap = {:: १4: १}

i = 2, एर [i] =।

myMap = {१: १,1: १1,4: १}

i = 3, एर [i] =।

myMap = {१: १,1: १1,4: १}

i = 4, एर [i] =।

myMap = {१: १,1: १1,4: १}

i = 5, एर [i] =।

myMap = {१: १,1: १2,4: १}

i = 6, एर [i] =।

myMap = {१: १,1: १2,4: १}

i = 6, एर [i] =।

myMap={1:2,4:2,5:3,6:1}

अब हामीसँग यसको एक मेरो नक्सा र मानहरू हुनेछन्।

एर्रेमा अर्डर गरिएको एलिमेन्टको साथ एर्रे ट्र्याभर्स पछि हामी फ्रिक्वेन्सी पाउनेछौं। प्रत्येक एर्रे एलिमेन्टलाई यसको फ्रिक्वेन्सीको साथ लिईएको छ र त्यस फ्रिक्वेन्सी समय सम्म लूप बनाउँनुहोस् र आवृत्ति समय सम्म सबै एर्रे एलिमेन्ट्स प्रिन्टिंग पछि त्यो एरे कुञ्जी हटाउँनुहोस् ताकि यसले फेरि ट्रभर्सलमा फेरि प्रिन्ट हुँदैन।

एर [i] = frequency आवृत्ति = =

Printed पटक मुद्रित हुनेछ, times पटक, तब हामी त्यो कुञ्जीलाई मेरो नक्सामा हटाउनेछौं, त्यसैले जब हामी एर्रेमा read पढ्छौं यो ह्यासम्यापमा उपस्थित हुँदैन र प्रिन्ट हुँदैन।

एर [i] = frequency आवृत्ति = =

Printed पटक छापिने छ, २ पटक, कुञ्जी MyMap मा हटाईनेछ, त्यसैले जब हामी एक एर्रे मा read पढ्छौं यो हैशमैपमा उपस्थित हुँदैन र प्रिन्ट हुँदैन।

एर [i] = frequency आवृत्ति = =

१ प्रिन्ट हुनेछ, २ पटक, तब हामी त्यो कुञ्जीलाई MyMap मा हटाउनेछौं, त्यसैले जब हामी एर्रेमा read पढ्छौं र यो ह्यासमैपमा उपस्थित हुँदैन र प्रिन्ट हुँदैन।

अब ar एर्रेमा आउँदछन् तर यो ह्यासम्यापमा देखा पर्दैन र त्यस्तै घट्दछ र एलिमेन्ट नभएसम्म केहि पनि गर्दैन जुन ह्यासमैपमा अवस्थित छ।

एर [i] = frequency आवृत्ति = १

Printed प्रिन्ट हुनेछ, १ पटक, कुञ्जी MyMap मा हटाईनेछ, त्यसैले जब हामी एरेमा read पढ्छौं यो हैशमैपमा उपस्थित हुँदैन र प्रिन्ट हुँदैन।

हामीसँग आउटपुट अब 5 5 5 4 4 १ १ 1 छ।

कार्यान्वयन  

C ++ कार्यक्रम एरे एलिमेन्टहरूको समूह बहु घटनाहरूको लागि पहिलो घटना द्वारा आदेश दिइयो

#include<iostream>
#include<unordered_map>

using namespace std;
void arrangeInOrder(int arr[], int n)
{
    unordered_map<int, int> myMap;

    for (int i=0; i<n; i++)
    {
        myMap[arr[i]]++;
    }
    for (int i=0; i<n; i++)
    {
        int count = myMap[arr[i]];
        for (int j=0; j<count; j++)
            cout<<arr[i]<< " ";

        myMap.erase(arr[i]);
    }
}
int main()
{
    int arr[] = {10, 5, 3, 10, 10, 4, 1, 3};
    int n=sizeof(arr)/sizeof(arr[0]);
    arrangeInOrder(arr,n);
    return 0;
}
10 10 10 5 3 3 4 1

जावा कार्यक्रम

import java.util.HashMap;

class multipleOccurences
{
    public static void arrangeInOrder(int arr[])
    {
        HashMap<Integer, Integer> myMap= new HashMap<Integer, Integer>();

        for (int i=0; i<arr.length; i++)
        {
            Integer current = myMap.get(arr[i]);
            if (current == null)
                current = 0;

            myMap.put(arr[i], current + 1);
        }
        for (int i=0; i<arr.length; i++)
        {
            Integer count = myMap.get(arr[i]);
            if (count != null)
            {
                for (int j=0; j<count; j++)
                {
                    System.out.print(arr[i] + " ");
                }
                myMap.remove(arr[i]);
            }
        }
    }
    public static void main (String[] args)
    {
        int arr[] = {10, 5, 3, 10, 10, 4, 1, 3};
        arrangeInOrder(arr);
    }
}
10 10 10 5 3 3 4 1

एरे एलिमेन्ट्सको समूह बहु घटनाहरूको लागि जटिलता विश्लेषण  

समय जटिलता

ऊ) जहाँ "N" एर्रेमा एलिमेन्ट्सको संख्या हो।

पनि हेर्नुहोस्
संयोजन Sum Leetcode समाधान

ठाउँ जटिलता

ऊ) जहाँ "N" एर्रेमा एलिमेन्ट्सको संख्या हो।

संदर्भ