algorithm - Is there a way to reduce the memory use of this queue? -

उदारीकृत सी में:

  / * मैं * / struct quueItem { QueueItem * अगला; शून्य * डेटा; } संरचना कतार {QueueItem * head; QueueItem * पूंछ; } / * + --- + + --- + 0 0 | | * * | लेन 1 + --- + + | - | + वी वी लेन + --- + 0 | डी 0 | + --- + + --- + | * * ---------...--- + + - - + | लैन एन वी वी + --- + + --- + + --- एक * - & gt; | बी * --...- & gt; | z 0 | + + --- + --- + + --- + / /  

यह ओ (1) सभी धक्का / पॉप / पीक और ओ (एन) ट्रवर्सल के लिए देता है, लेकिन इसका उपयोग करता है 2 + 2 एन मेमोरी एक सापेक्ष सरणी संस्करण न्यूनतम 2 + एन (इष्टतम के बारे में) देता है, लेकिन आमतौर पर खराब होता है, और कभी-कभी (फिर से आवंटन के लिए) अधिक समय लेने के लिए संशोधनों का कारण बनता है।

  struct que {size_t len; आकार_टी सिर; शून्य (* डेटा) []; } / * + ----- + | * * * ----- ~~~ - + + | - | - + | वी + - + | + ---- v ----- ~~~ -v + | 0 0 ए बी सी । z | + ---------- ~~~ - + * /  

ऐसा लगता है कि स्मृति उपयोग को प्राथमिकता के साथ स्मृति में सुधार करने का कोई तरीका नहीं है, लेकिन मैं चाहता हूं

संपादित करें (क्योंकि मैं टिप्पणी में कोड नहीं कर सकता है):

  struct QueueItem {QueueItem * अगला; Size_t लेन; शून्य (* डेटा) []; } संरचना कतार {QueueItem * head; QueueItem * पूंछ; Size_t प्रारंभ; Size_t एंड; // संपादित करें: पता करने की आवश्यकता है कि डेटा को कहां से निकालना है संपादित करें: प्रति-आइटम नहीं} / * + ----- + | * * * ------------------------------ + + | - | - + | वी + --- + (2x लंबा) वी (अधिक लंबा) + ------ v ---- + ----------- + + -------- ------- + | @ 0 0 एबी * - & gt; | @ सी । एच * - & gt; ... & gt; | @ । । X y z 0 | + ----------- + + ----------- + + --------------- + * /  < सबसे पहले, मुझे लगता है कि आप क्यूईइटेम्स को आवंटित करने की लागत की उपेक्षा करते हैं। तो आपके दोनों दृष्टिकोणों के बीच आवंटन की लागत एक समान है। (मेमोरी आवंटन के बारे में कोई और अधिक जानकार, कृपया अगर मैं ग़लत हूँ, तो कृपया बात करें।) 
 
 आप सरणी में पॉप / रिकल्ले आइटम के लिए व्यर्थ स्थान को कम करने के लिए ऐसा कर सकते हैं। सूची और सरणी के एक संकर बनाएं। प्रत्येक सूची नोड में आकार की एक सरणी होते हैं। 
 
  struct पंक्तिबद्धता {QueueItem * next; शून्य (* डेटा) [के]; } संरचना कतार {QueueItem * head; QueueItem * पूंछ; आकार_टी सिर; Size_t एंड; }  
 
 अब आपका प्रदर्शन आपके द्वारा सरणी के लिए चुनने वाले आकार से तय होता है। यह छोटा है, आपके पास कम बर्बाद स्थान है। यह बड़ा है, कम आपके क्यूईइइटम ओवरहेड आपको समग्र स्थान के प्रतिशत के रूप में खर्च करते हैं। अगर आप जानते थे, तो कहें, कि आपकी कतार आमतौर पर आकार के एन का हो, तो आप कश्मीर एन / 10 होने का चयन कर सकते हैं। उस मामले में, कुल मेमोरी की लागत एन / के + 4 + एन है। अप्रयुक्त तत्वों पर आप सरणी में बर्बाद अधिकतम मात्रा 2 * K-2 है। 
 
 उपयोग के पैटर्न वास्तविक प्रदर्शन। लेकिन अगर आप अपने उपयोग के पैटर्न की आशा कर सकते हैं, तो आप कश्मीर चुन सकते हैं जो अच्छी तरह से काम करता है। यहां तक ​​कि प्रत्येक नोड के लिए अनुकूलन करने का भी अनुकूल तरीका भी हो सकता है ताकि बेहतर प्रदर्शन प्राप्त हो सके, लेकिन मुझे लगता है कि यह अभी से परे है।