2011-10-18 20 views
21

के लिए एक प्रतिलिपि निर्माता बनाना यह होमवर्कएक लिंक्ड सूची

मैं अपने सी ++ वर्ग के लिए एक लिंक की गई सूची वर्ग को लागू करने पर काम कर रहा हूँ है, और प्रतिलिपि निर्माता मेरे लिए बहुत भ्रामक हो गया है।

लिंक्ड सूची structs elems कहा जाता है के शामिल है:

struct Elem 
    { 
     int pri; 
     data info; 
     Elem * next; 
    }; 
    Elem * head; 

की जानकारी है कि Elem में संग्रहित है एक अलग, कस्टम वर्ग है।

प्रतिलिपि निर्माता के लिए हस्ताक्षर है:

linkedList::linkedList(const linkedList &v) 

मुद्दा मैं कर रहा हूँ ज्यादातर मेरे तर्क ले रहे हैं और वास्तव में कोड के रूप में यह लिख रहा है। करने के लिए

मेरे सामान्य विचार है:

  1. सेट सिर v.head को (सिर = v.head)
  2. वी के (pri = v.pri को Elem के मूल्यों सेट, जानकारी = v.info अगले = v.next)
  3. दोहराएं के माध्यम से, चरण दोहराते 2.

इस सामान्य विचार है?

कोई भी मदद महान होगी। याद रखें, यह होमवर्क है, इसलिए कोई सीधा जवाब नहीं है!

अपना समय

के लिए धन्यवाद =================================== ================================================== ================================================== =============================

आपके समय के लिए धन्यवाद!

मुझे लगता है मैं यह पता लगा है:

//Copy Constructor 
LinkedList::LinkedList(const LinkedList &v) 
{ 
Elem * p1 = 0;//current 
Elem * p2 = 0;//next 

if(v.head == 0) 
    head = 0; 

else 
{ 
    head = new Elem; 
    head -> pri = v.head -> pri; 
    head -> info = v.head -> info; 

    p1 = head; 
    p2 = v.head -> next; 
} 

while(p2) 
{ 
    p1 -> next = new Elem; 
    p1 = p1 -> next; 
    p1 -> pri = p2 -> pri; 
    p1 -> info = p2 -> info; 

    p2 = p2 -> next; 
} 
p1 -> next = 0; 
} 

मुझे लगता है कि काम करता है यकीन है कि हूँ। मैंने मदद करने के लिए कुछ तार्किक चित्र खींचे, और मैंने किसी भी मुद्दे में भाग नहीं लिया।

+0

वास्तव में प्रतिलिपि बनाने वाले को क्या करना चाहिए? उचित लिंक के साथ प्रत्येक नोड की प्रतिलिपि बनाना उचित लगता है, लेकिन यह एकमात्र संभावना नहीं है। –

+2

+1 चुपचाप होमवर्क * के लिए और कोई सीधा जवाब मांगने के लिए *। –

+0

मुझे सही संकेत देने के लिए धन्यवाद!मैंने अपने नोड्स के लिए एक गहरी प्रतिलिपि निर्माता को लागू किया, ताकि "अंतिम" नोड के ऑब्जेक्ट को पैरेंट नोड और उसके पैरेंट नोड के संदर्भ संदर्भ के साथ ... संरचना में बने रहने के लिए सक्षम किया जा सके। पेड़ खोज एल्गोरिदम के लिए इसे इस्तेमाल किया – mtosch

उत्तर

21

आपको चरण 1 और चरण 2 के भाग से सावधान रहना होगा। चरण 1 को एक नया नोड आवंटित करना चाहिए और head के रूप में उपयोग करना चाहिए। चरण 2 में, next = v.next का हिस्सा, जब तक कि आपका इरादा एक उथली प्रतिलिपि बनाना नहीं है, गलत है।

जब आप एक कंटेनर की तरह एक कंटेनर की प्रतिलिपि बनाते हैं, तो आप शायद एक गहरी प्रतिलिपि चाहते हैं, इसलिए नए नोड्स को बनाने की आवश्यकता है और केवल डेटा कॉपी किया गया है। नई सूची के नोड्स में next और prior पॉइंटर्स को उस सूची के लिए विशेष रूप से बनाने वाले मूल नोड्स के नोड्स को संदर्भित करना चाहिए, न कि मूल सूची से नोड्स। इन नए नोड्स में मूल सूची से संबंधित डेटा की प्रतियां होंगी, ताकि नई सूची को मूल्य, या गहरी प्रतिलिपि माना जा सके।

enter image description here

सूचना कैसे आरेख के दीप कॉपी भाग में, नोड्स में से कोई भी पुरानी सूची में नोड्स को इंगित:

यहाँ एक चित्र उथले और गहरी नकल के बीच मतभेद को दर्शाया गया है । उथले और गहरी प्रतियों के बीच के अंतर के बारे में अधिक जानकारी के लिए, object copying पर विकिपीडिया लेख देखें।

+3

ओह! चित्रों! यह निश्चित रूप से स्पष्ट करने में मदद करेगा। +1 –

4
  1. आपको this->head = v.head सेट नहीं करना चाहिए। क्योंकि सिर बस एक सूचक है। आपको एक नया सिर बनाने और v.head से अलग-अलग मानों को अपने नए सिर में कॉपी करने की आवश्यकता है। अन्यथा आपके पास एक ही चीज़ को इंगित करने वाले दो पॉइंटर्स होंगे।

  2. फिर आप एक अस्थायी Elem सूचक है कि v.head साथ शुरू होता है बना सकते हैं और सूची के माध्यम से पुनरावृति, नई प्रतिलिपि में नए Elem संकेत करने के लिए अपने मूल्यों को कॉपी करना होगा।

  3. ऊपर देखें।

+3

नोट: जब आप इसकी मानों की प्रतिलिपि बनाते हैं, तो _not_ को इसके पॉइंटर की प्रतिलिपि बनाएँ। आम तौर पर, कभी प्रतिलिपि बनाने वाले में एक सूचक की प्रतिलिपि न लें। ऑब्जेक्ट की ओर इशारा करते हुए कॉपी करें। –

2

आपकी कॉपी कन्स्ट्रक्टर प्रति को क्या चाहिए? इसे pri कॉपी करना चाहिए - आसान। इसे info कॉपी करना चाहिए - साथ ही साथ आसान भी। और यदि next शून्य नहीं है, तो इसे भी कॉपी करना चाहिए। आप next कैसे कॉपी कर सकते हैं? रिकर्सिव सोचें: ठीक है, next एक Elem * है, और Elem में एक कॉपी कन्स्ट्रक्टर है: संदर्भित Elem को कॉपी करने के लिए इसका उपयोग करें और इसका संदर्भ लें।

आप इसे भी हल कर सकते हैं, लेकिन पुनरावर्ती समाधान अधिक सहज ज्ञान युक्त है।

+0

सच है, यह आसान है अगर एलेम की प्रतिलिपि बनाने वाला –

+0

हम जानबूझकर रिकर्सन नहीं कर रहे हैं, इसलिए हम देख सकते हैं कि अधिक आसानी से क्या होता है। उसने हमें रिकर्सिव तरीके दिखाया और जानबूझकर कहा कि अगर हम इसे इस तरह से करते हैं तो हम असफल हो जाएंगे। O_O – Joshua

+0

@ जोशुआ: आपको ऐसी बाधाओं का जिक्र करना चाहिए। – Landei

0

तो यहाँ मेरा उत्तर है (कि अगर अपना होमवर्क या नहीं करने के लिए फिट बैठता है पता नहीं - प्रशिक्षकों कभी कभी अपने स्वयं के विचारों हो जाते हैं;):

आम तौर पर एक प्रति निर्माता चाहिए "प्रतिलिपि" अपने वस्तु। अर्थात। मान लें कि आपने लिंक्ड लिस्ट एल 1 किया है, और एक लिंक्ड लिस्ट एल 2 = एल 1 (जो लिंक्ड लिस्ट :: लिंक्डलिस्ट (एल 1) कहता है), फिर एल 1 और एल 2 इस अर्थ में पूरी तरह अलग वस्तुएं हैं कि एल 1 में संशोधन एल 2 को प्रभावित नहीं करता है और इसके विपरीत।

जब आप केवल पॉइंटर्स असाइन करते हैं तो आपको वास्तविक प्रति प्राप्त नहीं होगी, क्योंकि उनमें से किसी एक को संदर्भित करने और संशोधित करने से दोनों ऑब्जेक्ट प्रभावित होंगे।

आप अपनी स्रोत सूची में प्रत्येक तत्व की वास्तविक गहरी प्रतिलिपि बनाना चाहते हैं (या केवल एक प्रति-मांग मांगें, यदि आप कल्पना करना चाहते हैं)।

0

आप लाइन return;

if(v.head == 0) 
    head = 0; 

आप बाहर निकलने के लिए की जरूरत है के बाद, सही भूल गए?

संबंधित मुद्दे