लिंक्डलिस्ट एक साक्षात्कार के परीक्षण

Question

[संपादित करें] में अपना कोड तय किया गया। जबकि (temp! = NULL) है, जबकि नहीं (temp-> अगला! = NULL)। गलत कोड डालने के लिए खेद है।

आज मैंने एक ऑनलाइन प्रोग्रामिंग परीक्षण में भाग लिया है। साक्षात्कारकर्ता ने मेरे कोड और अन्य साक्षात्कारकर्ताओं का मूल्यांकन करने के लिए कोडिलिटी का उपयोग किया। कुछ पल में लिंक्ड सूची के बारे में एक सवाल बनाया गया था। यह गिनने वाला है कि एक लिंक की गई सूची में कितनी चीज़ें हैं। मैं यह करने के ही संभव दृष्टिकोण था, AFAIK:

//This is struct declaration 
struct SomeStruct 
{ 
    int value; 
    SomeStruct* next; 
} 

int elementCount(SomeStruct* list) 
{ 
    int count = 0; 
    if(list != NULL) 
    { 
     SomeStruct* temp = list; 
     while(temp != NULL) 
     { 
      count++; 
      temp = temp->next; 
     } 
    } 
    return count; 
} 

मुझे याद है जब मैं इस प्रश्न के लिए उत्तर के रूप में इस कोड को भेजने के लिए, Codility मुझे बताते हैं इस समाधान गलत है, क्योंकि इसके अमल करने के लिए बहुत अधिक समय का उपभोग काम। मेरे सिर में और this thread में SO पर लिंक किए गए सूची के आकार को प्राप्त करने के अलावा कोई आसान तरीका नहीं है, सरल तरीके से नहीं।

क्या कोड कहता है कि यह समाधान गलत है? या एक और दृष्टिकोण हैं?

पुनश्च: परीक्षण एसटीएल

Answer 1

का उपयोग करते हुए अच्छी तरह से आप अविवेक temp->nextदो बार प्रत्येक यात्रा के लिए का मूल्यांकन करने की जरूरत नहीं है की अनुमति दी।

आप बस

int count(SomeStruct const* pNode) 
{ 
    int result = 0; 
    while(pNode != 0) 
    { 
     ++result; 
     pNode = pNode->next; 
    } 
    return result; 
} 

इसके अलावा WhozCraig notes के रूप में, अपने कोड तार्किक गलत था (एक परिणाम से एक ऑफ उपज), बस संभावित अक्षम नहीं कर सकते हैं।

Answer 2

कोडिविटी जांच के लिए एक गोलाकार रूप से जुड़ी सूची का उपयोग कर सकता है, इस मामले में, आपका कोड कभी खत्म नहीं होगा।

एसटीएल trivilailzes का उपयोग हालांकि यह एक आकार विधि के साथ एक सूची <> है।

Answer 3

आपका समाधान गलत है, क्योंकि यह वास्तविक गणना से 1 कम है। बस इसे 1 तत्व के साथ एक सूची में लागू करने का प्रयास करें।

आप इस अजीब दो-स्तरीय संरचना के साथ if और एक चक्र जो temp->next की जांच करता है? क्यों नहीं बस

unsigned elementCount(const SomeStruct *list) 
{ 
    unsigned count = 0; 
    for (const SomeStruct *temp = list; temp != NULL; temp = temp->next) 
    ++count; 
    return count; 
} 

मुझे लगता है कि आप तत्व "शीर्षक" तत्व अप्रयुक्त और सुरक्षित रूप list द्वारा बताया इलाज का फैसला किया। दरअसल, कभी-कभी इसे इस तरह के सूचियों को लागू करने का अर्थ हो सकता है। लेकिन मैं आपकी पोस्ट में बताए गए कुछ भी नहीं देखता हूं। क्या उन्होंने आपको इस तरह से विशेष रूप से इलाज करने के लिए कहा था?