एक निश्चित आकार का ढेर बनाना

Question

मैं जावा में एक स्टैक बनाना चाहता हूं, लेकिन आकार को ठीक करना चाहता हूं। उदाहरण के लिए, एक नया स्टैक बनाएं, आकार को 10 पर सेट करें, फिर जब मैं स्टैक पर आइटम को पुश करता हूं तो यह भर जाता है और जब यह दस तक भर जाता है, तो स्टैक में अंतिम आइटम को हटा दिया जाता है (हटाया जाता है)। मैं स्टैक का उपयोग करना चाहता हूं क्योंकि यह लिफो का उपयोग करता है और मेरी आवश्यकताओं को बहुत अच्छी तरह से फिट करता है।

लेकिन सेटसेज() विधि जो वेक्टर से स्टैक विरासत में है, वास्तव में स्टैक के आकार को सीमित नहीं लगती है। मुझे लगता है कि स्टैक्स कैसे काम करता है, इस बारे में मुझे कुछ याद आ रहा है, या शायद ढेर को बाधित नहीं किया गया था, इसलिए यह असंभव है। कृपया मुझे शिक्षित करें!

Answer 1

आप इस तरह एक बहुत ही सरल ढेर बना सकते हैं:

public class FixedStack<T> 
{ 
    private T[] stack; 
    private int size; 
    private int top; 

    public FixedStack<T>(int size) 
    { 
     this.stack = (T[]) new Object[size]; 
     this.top = -1; 
     this.size = size; 
    } 

    public void push(T obj) 
    { 
     if (top >= size) 
      throw new IndexOutOfBoundsException("Stack size = " + size); 
     stack[++top] = obj; 
    } 

    public T pop() 
    { 
     if (top < 0) throw new IndexOutOfBoundsException(); 
     T obj = stack[top--]; 
     stack[top + 1] = null; 
     return obj; 
    } 

    public int size() 
    { 
     return size; 
    } 

    public int elements() 
    { 
     return top + 1; 
    } 
} 

Answer 2

आप Stack उपclass कर सकते हैं और इस कस्टम व्यवहार को लागू करने के लिए उचित विधि (ओं) को ओवरराइड कर सकते हैं। और इसे एक स्पष्ट नाम देना सुनिश्चित करें (उदा। FixedStack)।

Answer 3

एक शुद्ध ढेर इसके आकार को सीमित नहीं करेगा, क्योंकि कई समस्याएं हल करने के लिए आपको पता नहीं है कि आपको कितने तत्वों की आवश्यकता होगी।

आप एक कस्टम स्टैक लिख सकते हैं जो आपके द्वारा वर्णित आवश्यकताओं को लागू करता है। हालांकि, यदि आप करते हैं तो आप लिफो को तोड़ देंगे। यदि अधिकतम आकार पूरा हो गया है, और आप स्टैक पर कुछ नया धक्का देते हैं, तो आप पहले जोड़े गए आइटम को खो देते हैं। तो यदि आप अपने स्टैक से आइटम पॉप अप करना शुरू करते हैं, तो आप कुछ याद करेंगे।

Answer 4

ए LinkedBlockingDeque एक साधारण विकल्प है। LinkedBlockingQueue(int) कन्स्ट्रक्टर का उपयोग करें जहां पैरामीटर आपकी स्टैक सीमा है।

---

आप मनाया के रूप में, Stack और Vector मॉडल असीम दृश्यों। setSize() विधि स्टैक/वेक्टर को छीनती है। यह डेटा संरचना को उस आकार से आगे बढ़ने से नहीं रोकता है।

Answer 5

आपको जो चाहिए वह एक डबल-एंडेड कतार है जैसे LinkedList। यह स्वचालित रूप से फ्रंट पर तत्वों को नहीं छोड़ देगा, लेकिन इसे उप-वर्गीकरण/सजाने से आप उस कार्यक्षमता को जोड़ सकते हैं।

Answer 6

यह असंभव नहीं है :) आपको बस अपना खुद का कार्यान्वयन प्रदान करना होगा।

मैं this जैसे रिंगबफर से शुरू करूंगा और तदनुसार इसे समायोजित कर दूंगा।

Answer 7

आप LinkedHashMap उपयोग कर सकते हैं और उसके removeEldestEntry विधि ओवरराइड:

public class FixedStack extends LinkedHashMap<Long, String> { 

    private final int capacity; 

    public FixedStack(int capacity) { 
     this.capacity = capacity; 
    } 

    @Override 
    protected boolean removeEldestEntry(final Map.Entry<Long, String> eldest) { 
     return super.size() > capacity; 
    } 
} 

और यह परीक्षण करने के लिए:

public static void main(String[] args) { 

     FixedStack stack = new FixedStack(10); 

     long added = 0; 
     for (Locale locale : Locale.getAvailableLocales()) { 
      if (locale.getDisplayCountry().length() > 0) { 
       stack.put(added, locale.getDisplayCountry()); 
       System.out.println(locale.getDisplayCountry()); 
       added++; 
      } 
     } 
     System.out.println(String.format(">>>>>>>>> %s added", 
       added)); 
     Iterator<Entry<Long, String>> iterator = stack.entrySet().iterator(); 
     while (iterator.hasNext()) { 
      System.out.println(iterator.next().getValue()); 
     } 
    } 

आपको बस यह तय करना होगा कि आप कुंजी के रूप में क्या उपयोग करना चाहते हैं, मैंने उदाहरण में एक साधारण काउंटर का उपयोग किया।

import java.util.Stack; 

public class SizedStack<T> extends Stack<T> { 
    private int maxSize; 

    public SizedStack(int size) { 
     super(); 
     this.maxSize = size; 
    } 

    @Override 
    public T push(T object) { 
     //If the stack is too big, remove elements until it's the right size. 
     while (this.size() >= maxSize) { 
      this.remove(0); 
     } 
     return super.push(object); 
    } 
} 

इस तरह इसका इस्तेमाल: SizedStack<Float> mySizedStack = new SizedStack<Float>(10);

Answer 8

यहाँ एक SizedStack प्रकार है कि Stack फैली हुई है। आकार के अलावा, यह किसी अन्य Stack की तरह काम करता है।