एक लिंक में सिंगल लिंक्ड सूची को कनवर्ट करना

Question

मुझे मौजूदा एक को अपग्रेड करने के लिए एक असाइनमेंट दिया गया है।

चित्रा बाहर कैसे प्रत्येक टर्मिनल लाइन के लिए एक मानचित्र का उपयोग कर योग्यता परीक्षा समस्या पुनःकूटित करना, धारणा है कि इस समस्या का आकार इनपुट लाइनों की संख्या का प्रभुत्व है पर, नहीं 500 टर्मिनल लाइनों

कार्यक्रम एक टेक्स्ट फ़ाइल में लेता है जिसमें संख्या, नाम है। संख्या पीसी नंबर है और नाम वह उपयोगकर्ता है जिसने लॉग ऑन किया है। कार्यक्रम प्रत्येक पीसी के लिए उपयोगकर्ता को सबसे अधिक लॉग ऑन करता है। यहां मौजूदा कोड

public class LineUsageData { 
    SinglyLinkedList<Usage> singly = new SinglyLinkedList<Usage>(); 


    //function to add a user to the linked list or to increment count by 1 
    public void addObservation(Usage usage){ 
     for(int i = 0; i < singly.size(); ++i){ 
      if(usage.getName().equals(singly.get(i).getName())){ 
       singly.get(i).incrementCount(1); 
       return; 
      } 
     } 

     singly.add(usage); 
    } 
    //returns the user with the most connections to the PC 
    public String getMaxUsage(){ 
     int tempHigh = 0; 
     int high = 0; 
     String userAndCount = ""; 
     for(int i = 0; i < singly.size(); ++i){//goes through list and keeps highest 
      tempHigh = singly.get(i).getCount(); 
      if(tempHigh > high){ 
       high = tempHigh; 
       userAndCount = singly.get(i).getName() + " " + singly.get(i).getCount(); 
      } 
     } 

     return userAndCount; 
    } 
} 

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

Answer 1

मैंने इसे ऑफ़लाइन हल किया और कुछ जवाब देखने का मौका नहीं मिला जो दोनों बहुत उपयोगी थे। निक और ऐवन के बारे में खेद है और प्रतिक्रियाओं के लिए धन्यवाद। यहां कोड है जिसे मैंने काम करने के लिए लिखने के लिए लिखा है।

public class LineUsageData { 

    Map<Integer, Usage> map = new HashMap<Integer, Usage>(); 
    int hash = 0; 
    public void addObservation(Usage usage){ 
     hash = usage.getName().hashCode(); 
     System.out.println(hash); 
     while((map.get(hash)) != null){ 
      if(map.get(hash).getName().equals(usage.name)){ 
       map.get(hash).count++; 
       return; 
      }else{ 
       hash++; 
      } 

     } 
     map.put(hash, usage); 
    } 






    public String getMaxUsage(){ 
     String str = ""; 
     int tempHigh = 0; 
     int high = 0; 

    //for loop 
     for(Integer key : map.keySet()){ 
      tempHigh = map.get(key).getCount(); 
      if(tempHigh > high){ 
       high = tempHigh; 
       str = map.get(key).getName() + " " + map.get(key).getCount(); 
      } 
     } 

     return str; 
    } 


} 

Answer 2

जांच करते समय Usage सूची में मौजूद है, तो आप प्रत्येक बार एक रैखिक खोज करते हैं (O(N))। यदि आप अपनी सूची को Map<String,Usage> से प्रतिस्थापित करते हैं, तो आप सबलाइनर समय में name खोज सकते हैं। TreeMap में O(log N) खोज और अद्यतन के लिए समय है, HashMapO(1) (स्थिर) समय amortized है।

तो, इस मामले में सबसे प्रभावी डेटा संरचना HashMap है।

import java.util.*; 

public class LineUsageData { 
    Map<String, Usage> map = new HashMap<String, Usage>(); 

    //function to add a user to the map or to increment count by 1 
    public void addObservation(Usage usage) { 
     Usage existentUsage = map.get(usage.getName()); 
     if (existentUsage == null) { 
      map.put(usage.getName(), usage); 
     } else { 
      existentUsage.incrementCount(1); 
     } 
    } 

    //returns the user with the most connections to the PC 
    public String getMaxUsage() { 
     Usage maxUsage = null; 
     for (Usage usage : map.values()) { 
      if (maxUsage == null || usage.getCount() > maxUsage.getCount()) { 
       maxUsage = usage; 
      } 
     } 

     return maxUsage == null ? null : maxUsage.getName() + " " + maxUsage.getCount(); 
    } 

    // alternative version that uses Collections.max 
    public String getMaxUsageAlt() { 
     Usage maxUsage = map.isEmpty() ? null : 
       Collections.max(map.values(), new Comparator<Usage>() { 
        @Override 
        public int compare(Usage o1, Usage o2) { 
         return o1.getCount() - o2.getCount(); 
        } 
       }); 

     return maxUsage == null ? null : maxUsage.getName() + " " + maxUsage.getCount(); 
    } 

} 

Map भी समय यह के आकार के लिए आनुपातिक में दोहराया जा सकता है ताकि आप एक ही प्रक्रिया का उपयोग कर सकते इसमें अधिकतम तत्व खोजने के लिए। मैंने आपको दो विकल्प दिए, मैन्युअल दृष्टिकोण, या Collections.max उपयोगिता विधि का उपयोग किया।

Answer 3

सरल शब्दों के साथ

: आप का प्रयोग कर एक LinkedList (अकेले या दोगुना) आप मदों की एक सूची है, और आप आम तौर पर उन्हें पार करने के लिए की योजना कब और एक Map कार्यान्वयन जब आप "शब्दकोश की तरह" प्रविष्टियों, जहां एक कुंजी एक मान के अनुरूप है और आप कुंजी का उपयोग कर मूल्य तक पहुंचने की योजना बना रहे हैं।

आदेश में अपने SinglyLinkedList एक HashMap या TreeMap में बदलने के लिए, आप अपने आइटम के जो संपत्ति अपने कुंजी के रूप में उपयोग किया जाएगा पता लगाने के जरूरत है (यह अद्वितीय मूल्यों के साथ एक तत्व होना चाहिए)।

आप अपने प्रयोग वर्ग से नाम संपत्ति का उपयोग कर रहे मान लिया जाये, तो आप इस (एक सरल उदाहरण) कर सकते हैं:

//You could also use TreeMap, depending on your needs. 
Map<String, Usage> usageMap = new HashMap<String, Usage>(); 

//Iterate through your SinglyLinkedList. 
for(Usage usage : singly) { 
    //Add all items to the Map 
    usageMap.put(usage.getName(), usage); 
} 

//Access a value using its name as the key of the Map. 
Usage accessedUsage = usageMap.get("AUsageName"); 

भी ध्यान रखें कि:

Map<string, Usage> usageMap = new HashMap<>(); 

, वैध है कारण diamond inference।