जावा स्टैक

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

स्टैक डेटा स्ट्रक्चर क्या है

सबसे पहले, आइए देखें कि स्टैक डेटा संरचना क्या है। यह एक रेखीय डेटा संरचना है जो लास्ट-इन-फर्स्ट-आउट (LIFO) सिद्धांत पर आधारित है। यह एक तरह की विरोधी कतार है। एक बॉक्स में ताश के पत्तों की गड्डी या किताबों के ढेर की कल्पना करें। जो किताब आप पहले ढेर में डालते हैं, वह सबसे नीचे है, और सबसे पहले हम बॉक्स से बाहर निकालेंगे, वह किताब है जो सबसे ऊपर थी - यानी, वह जो बॉक्स में सबसे अंत में आई थी। यहाँ इस सिद्धांत को प्रदर्शित करने के लिए एक GIF चित्र है। यहाँ क्या चल रहा है? हमारे पास एक फ्लास्क है जिसमें एक समय में केवल एक ही गेंद हिट हो सकती है। फ्लास्क में पहली नारंगी गेंद है, फिर बैंगनी, और अंत में हरा (मैं उन लोगों से माफी मांगता हूं जो इन रंगों के अधिक सटीक नाम जानते हैं)। हालाँकि हमारे फ्लास्क-स्टैक से एक नारंगी गेंद निकालने के लिए, हमें सबसे पहले उस गेंद को निकालने की आवश्यकता होती है जो वहाँ अंतिम (हरी वाली) मिली थी, फिर वह जो अंतिम थी (लेकिन निष्कर्षण के समय यह अंतिम थी एक)। जावा या अन्य प्रोग्रामिंग में स्टैक डेटा संरचना में दो सबसे महत्वपूर्ण ऑपरेशन, पुश और पॉप हैं । पुश ऑपरेशन एक तत्व को स्टैक में सम्मिलित करता है और पॉप ऑपरेशन एक तत्व को स्टैक के शीर्ष से हटा देता है।

स्टैक डेटा संरचना किसके लिए है?

स्टैक के सबसे महत्वपूर्ण उपयोगों में से एक सबरूटीन कॉल्स को व्यवस्थित करना है। स्टैक पर कॉल पॉइंट सबरूटीन से रिटर्न एड्रेस को समाप्त होने के बाद स्टोर करता है (और संभवतः पास किए गए पैरामीटर)। सबरूटीन्स के प्रत्येक नेस्टेड (रिकर्सिव सहित) कॉल के साथ, स्टैक में नए रिटर्न एड्रेस जोड़े जाते हैं। उपनेमका (रिटर्न) से प्रत्येक रिटर्न ऑपरेशन के साथ, रिटर्न एड्रेस को स्टैक से हटा दिया जाता है और नियंत्रण को स्थानांतरित कर दिया जाता है। यह एप्लिकेशन प्रोग्रामिंग के लिए इतना महत्वपूर्ण है कि अधिकांश प्रोसेसर में निर्देश सेट में हार्डवेयर में रिटर्न स्टैक लागू किया जाता है। हालाँकि, अन्य मामलों में, स्टैक को अधिक सामान्य डेटा संरचनाओं पर मॉडलिंग करना पड़ता है।

जावा स्टैक क्लास ऑफ़ कलेक्शन फ्रेमवर्क

जावा स्टैक क्लास में संग्रह ढांचे से एक वर्ग है जो सूची इंटरफ़ेस को लागू करता है और वेक्टर वर्ग का विस्तार करता है। यह इंटरफ़ेस संग्रह, Iterable, Cloneable, Serializable को भी लागू करता है। जैसा कि आप शायद पहले ही अनुमान लगा चुके हैं कि यह वर्ग वस्तुओं के LIFO स्टैक का प्रतिनिधित्व करता है। यहां स्टैक क्लास के कंस्ट्रक्टर को कॉल किया गया है , यानी इस क्लास के ऑब्जेक्ट का निर्माण।

Stack<E> stack = new Stack<E>();

जहाँ E वस्तु का प्रकार है।

जावा स्टैक के तरीके

इस क्लास में केवल एक डिफॉल्ट कंस्ट्रक्टर और वेक्टर क्लास के सभी तरीके हैं । साथ ही, स्टैक की अपनी 5 विधियाँ हैं:

• बूलियन खाली () विधि जांचती है कि स्टैक खाली है या नहीं। यदि स्टैक खाली है तो सत्य लौटाता है , यदि नहीं तो असत्य लौटाता है।

• ऑब्जेक्ट पीक () विधि उस तत्व को लौटाती है जो स्टैक के शीर्ष पर है।

• ऑब्जेक्ट पॉप () विधि उस तत्व को लौटाती है जो स्टैक के शीर्ष पर है और इसे हटा देता है।

• ऑब्जेक्ट पुश (ऑब्जेक्ट एलिमेंट) विधि निर्दिष्ट तत्व को स्टैक के शीर्ष पर जोड़ती है।

• int search (ऑब्जेक्ट एलिमेंट) विधि निर्दिष्ट तत्व के लिए स्टैक खोजती है। यदि आवश्यक तत्व पाया जाता है, तो शीर्ष (सीरियल नंबर) से इसकी "दूरी" वापस आ जाती है। यदि तत्व नहीं मिलता है, तो -1 वापस कर दिया जाता है।

ढेर कोड उदाहरण

चलिए एक प्रोग्राम उदाहरण बनाते हैं जो काम करता है जैसे कि ऊपर दी गई gif तस्वीर। हम स्टैक पर तीन "गेंदें", नारंगी, बैंगनी और हरा रखेंगे। आइए खालीपन के लिए ढेर की जाँच करें। फिर, हम ढेर से गेंदों को तब तक निकालेंगे जब तक कि ढेर खाली न हो जाए।

import java.util.Stack;

public class myStackTest2 {

       public static void main(String[] args)
       {

           Stack myStack= new Stack<>();

           System.out.println("Is my stack empty? " + myStack.empty());
// pushing elements into stack
           myStack.push("Orange Ball");
           myStack.push("Violet Ball");
           myStack.push("Green Ball");

//prints elements of the stack
           System.out.println("Elements in Stack: " + myStack);
           System.out.println("Is my stack empty? " + myStack.empty());
           while (!myStack.isEmpty()) {
               myStack.pop();
               System.out.println("Elements in Stack: " + myStack);
               System.out.println("Is my stack empty? " + myStack.empty());
           }
       }
   }

यहाँ इस कार्यक्रम का आउटपुट है: चूंकि स्टैक वेक्टर वर्ग से विरासत में मिला है और तत्वों को जोड़ने और निकालने के लिए इस डेटा संरचना के लिए क्लासिक पुश और पॉप संचालन के अलावा, सूची इंटरफ़ेस, स्टैक को लागू करता है, इसमें सूची संरचना जोड़ने () और हटाने () संचालन के लिए मानक भी हैं। हमारे उदाहरण में, ऐड () विधि का उपयोग करके तत्वों को जोड़ना उसी तरह लागू किया जा सकता है। हालाँकि आप केवल निर्दिष्ट तत्व के साथ निकालें () का उपयोग करके निकाल सकते हैं , जो स्टैक डेटा संरचना के लिए कोई मायने नहीं रखता है।

import java.util.Stack;

public class myStackTest2 {

       public static void main(String[] args)
       {

           Stack myStack= new Stack<>();

           System.out.println("Is my stack empty? " + myStack.empty());
// pushing elements into stack
           myStack.add("Orange Ball");
           myStack.add("Violet Ball");
           myStack.add("Green Ball");

//prints elements of the stack
           System.out.println("Elements in Stack: " + myStack);
           System.out.println("Is my stack empty? " + myStack.empty());
           while (!myStack.isEmpty()) {
               myStack.pop();
               System.out.println("Elements in Stack: " + myStack);
               System.out.println("Is my stack empty? " + myStack.empty());
           }
       }
   }

बेशक, कार्यक्रम के काम का नतीजा बिल्कुल वैसा ही होगा।

आपके अपने स्टैक कार्यान्वयन के बारे में क्या?

आप सरणियों या लिंक्ड सूची वर्गों का उपयोग करके जावा में अपनी खुद की स्टैक डेटा संरचना बना सकते हैं। पहले मामले में, स्मृति में मूल्यों को संग्रहीत करने के लिए कोशिकाओं की एक सतत सरणी आवंटित की जाती है, जिनका उपयोग आवश्यकतानुसार किया जाता है। दूसरे में, स्टैक के प्रत्येक तत्व के लिए, मेमोरी का एक ब्लॉक ऑर्डर किया जाता है, जो स्टैक के पिछले और अगले तत्वों के मान और संदर्भों को संग्रहीत करने के लिए पर्याप्त है। सरणी-आधारित कार्यान्वयन सरल, अधिक कुशल और अधिक मेमोरी कुशल है, लेकिन इसके लिए स्टैक आकार सीमा के पूर्व ज्ञान की आवश्यकता होती है और यह मुश्किल-से-ढूंढने वाले बग को जन्म दे सकता है। सूची-आधारित कार्यान्वयन अधिक मजबूत लेकिन कम कुशल है। आइए स्टैक का एक सरल सरणी-आधारित कार्यान्वयन करें। इसमें फंक्शन शामिल होंगे।

• धक्का - एक विधि जो एक तत्व को जोड़ना सुनिश्चित करेगी (शीर्ष स्थिति में)

• पॉप - एक विधि जो एक तत्व को हटाने (शीर्ष स्थिति से) प्रदान करेगी

• readTop - एक विधि जो उस तत्व का मान लौटाती है जो शीर्ष स्थिति में है

• sEmpty — एक विधि जो ढेर की शून्यता की जांच करेगी

• isFull - एक विधि जो यह जांचेगी कि क्या हमारा वह सरणी जिसमें हम स्टैक को स्टोर करते हैं, भरा हुआ नहीं है

import java.util.Arrays;

public class MyStack {

   private int maxSize;
   private String[] stackArray;
   private int top;

   public MyStack(int size) {
       this.maxSize = size;
       stackArray = new String[maxSize];
       top = -1;
   }

   public String push (String element) {
       return stackArray[++top] = element;
      
   }

   public String pop (String element) {

       if (isEmpty())
       {
           System.out.println("Underflow\nProgram Terminated");
           System.exit(-1);
       }

       System.out.println("Removing " + readTop());
      
       return stackArray[top--];

   }

   public String readTop() {
       return stackArray[top];

   }

   public boolean isEmpty() {
       return (top ==  -1);
   }

   public boolean isFull() {
       return (top == maxSize - 1);
   }

   public void printStack(){
       System.out.println(Arrays.toString(stackArray));
   }
}

अब अपने स्टैक पर आधारित तीन गेंदों के साथ एक उदाहरण लागू करते हैं:

public class myStackTest {
   public static void main(String[] args) {
       MyStack  myStack = new MyStack(3);
       System.out.println("Is my stack empty? " + myStack.isEmpty());

       myStack.push("Orange Ball");
       myStack.push("Violet Ball");
       myStack.push("Green Ball");

      myStack.printStack();

       System.out.println("Is my stack empty? " + myStack.isEmpty());
       while (!myStack.isEmpty()) {
           myStack.pop(myStack.readTop());
           System.out.println("Is my stack empty? " + myStack.isEmpty());
       }
   }

}

आउटपुट यहाँ है: यदि आप बारीकी से देखते हैं, तो शीर्ष चर में वास्तव में अंतिम तत्व का सूचकांक होता है, और वस्तु का संदर्भ सरणी में रहता है। इसलिए इस कार्यान्वयन में कुछ सुधार की आवश्यकता है। ऐसा करने का सबसे आसान तरीका सोचें।

क्या हमें जावा स्टैक का उपयोग करना चाहिए?

वास्तव में, जावा स्टैक , अपने वेक्टर माता-पिता की तरह, एक विरासत वर्ग है। इसके बजाय, आमतौर पर ArrayList वर्ग का उपयोग किया जाता है। वेक्टर सिंक्रनाइज़ होने पर ArrayList सिंक्रनाइज़ नहीं होता है । इसका मतलब है कि वेक्टर के साथ एक समय में केवल एक थ्रेड कोड तक पहुंच सकता है, जबकि ऐरेलिस्ट कई थ्रेड्स के साथ काम कर सकता है। साथ ही, ArrayList अधिक कुशल और तेज़ है। तो आप इस वर्ग को केवल विरासत कोड में देखेंगे। लेकिन स्टैक डेटा स्ट्रक्चर का उपयोग प्रोग्रामिंग में बहुत बार किया जाता है।