java stack tutorial stack class implementation with examples
यह ट्यूटोरियल बताता है कि जावा में स्टैक क्या है, जावा स्टैक क्लास, स्टैक एपीआई तरीके, उदाहरणों की मदद से ऐरे और लिंक्ड सूची का उपयोग करके स्टैक इम्प्लीमेंटेशन:
स्टैक एक ऑर्डर की गई डेटा संरचना है जो जावा कलेक्शन फ्रेमवर्क से संबंधित है। इस संग्रह में, तत्वों को केवल एक छोर से जोड़ा और हटाया जाता है। वह तत्व जिस पर तत्वों को जोड़ा जाता है और हटाया जाता है, उसे 'शीर्ष का शीर्ष' कहा जाता है।
इसके अलावा और विलोपन केवल एक छोर पर किया जाता है, स्टैक में जोड़ा गया पहला तत्व स्टैक से निकाला गया अंतिम तत्व होता है। इस प्रकार स्टैक को एक LIFO (लास्ट-इन, फर्स्ट-आउट) डेटा संरचना कहा जाता है।
=> यहाँ जावा शुरुआती गाइड पर एक नज़र रखना
आप क्या सीखेंगे:
- जावा स्टैक संग्रह
- निष्कर्ष
जावा स्टैक संग्रह
स्टैक का एक सचित्र प्रतिनिधित्व नीचे दिया गया है।
जैसा कि प्रतिनिधित्व के उपरोक्त अनुक्रम में दिखाया गया है, शुरू में स्टैक खाली है और स्टैक के शीर्ष -1 पर सेट है। तब हम एक 'पुश' ऑपरेशन शुरू करते हैं जिसका उपयोग स्टैक में एक तत्व जोड़ने के लिए किया जाता है।
इसलिए दूसरे प्रतिनिधित्व में, हम तत्व 10 को धक्का देते हैं। इस बिंदु पर, शीर्ष बढ़ा हुआ है। हम स्टैक में फिर से तत्व 20 को आगे बढ़ाते हैं, जिससे शीर्ष में वृद्धि होती है।
अंतिम प्रतिनिधित्व में, हम एक 'पॉप' ऑपरेशन शुरू करते हैं। इस ऑपरेशन का उपयोग स्टैक से एक तत्व को हटाने के लिए किया जाता है। वर्तमान में 'टॉप' को इंगित किया गया एक तत्व पॉप ऑपरेशन द्वारा हटा दिया गया है।
एक स्टैक डेटा संरचना निम्न कार्यों का समर्थन करती है:
- धक्का दें: एक तत्व को ढेर में जोड़ता है। नतीजतन, शीर्ष का मूल्य बढ़ जाता है।
- पॉप: एक तत्व स्टैक से हटा दिया जाता है। पॉप ऑपरेशन के बाद, शीर्ष का मान कम हो जाता है।
- पीक: इस ऑपरेशन का उपयोग किसी तत्व को देखने या खोजने के लिए किया जाता है। शीर्ष का मान संशोधित नहीं है।
स्टैक के शीर्ष का उपयोग स्टैक से तत्वों को जोड़ने / हटाने के लिए एक अंत के रूप में किया जाता है, किसी विशेष पल में विभिन्न मान भी हो सकते हैं। यदि स्टैक का आकार N है, तो स्टैक के शीर्ष पर अलग-अलग स्थितियों में निम्नलिखित मान होंगे जो इस बात पर निर्भर करता है कि स्टैक किस स्थिति में है।
| ढेर की स्थिति | शीर्ष मूल्य |
|---|---|
| ढेर खाली | -1 |
| ढेर में एक तत्व | ० |
| ढेर भरा हुआ | एन -1 |
| अतिप्रवाह (तत्व> एन) | एन |
जावा में स्टैक क्लास
जावा कलेक्शन फ्रेमवर्क 'स्टैक' नामक एक वर्ग प्रदान करता है। यह स्टैक वर्ग वेक्टर क्लास का विस्तार करता है और स्टैक डेटा संरचना की कार्यक्षमता को लागू करता है।
नीचे का आरेख स्टैक वर्ग के पदानुक्रम को दर्शाता है।
जैसा कि ऊपर चित्र में दिखाया गया है, स्टैक वर्ग वेक्टर वर्ग को विरासत में देता है जो संग्रह इंटरफ़ेस की सूची इंटरफ़ेस को लागू करता है।
स्टैक वर्ग java.util पैकेज का एक हिस्सा है। कार्यक्रम में स्टैक वर्ग को शामिल करने के लिए, हम निम्नानुसार आयात विवरण का उपयोग कर सकते हैं।
import java.util.*; या
import java.util.Stack; जावा में एक ढेर बनाएँ
एक बार जब हम स्टैक वर्ग को आयात करते हैं, तो हम नीचे दिखाए गए अनुसार एक स्टैक ऑब्जेक्ट बना सकते हैं:
Stack mystack = new Stack(); हम निम्न प्रकार से स्टैक वर्ग ऑब्जेक्ट का एक सामान्य प्रकार भी बना सकते हैं:
Stack myStack = new Stack; यहाँ data_type जावा में कोई भी मान्य डेटा प्रकार हो सकता है।
उदाहरण के लिए ,हम निम्नलिखित स्टैक क्लास ऑब्जेक्ट बना सकते हैं।
Stack stack_obj = new Stack(); Stack str_stack = new Stack(); ढेर एपीआई तरीके जावा में
स्टैक वर्ग डेटा को जोड़ने, हटाने और स्टैक में खोज करने के तरीके प्रदान करता है। यह जांचने के लिए एक विधि भी प्रदान करता है कि क्या स्टैक खाली है। हम नीचे दिए गए अनुभाग में इन विधियों पर चर्चा करेंगे।
स्टैक पुश ऑपरेशन
पुश ऑपरेशन का उपयोग स्टैक में तत्वों को धकेलने या जोड़ने के लिए किया जाता है। एक बार जब हम स्टैक इंस्टेंस बनाते हैं, तो स्टैक ऑब्जेक्ट प्रकार के तत्वों को स्टैक में जोड़ने के लिए हम पुश ऑपरेशन का उपयोग कर सकते हैं।
मूल्यों के साथ पूर्णांक स्टैक को इनिशियलाइज़ करने के लिए कोड के निम्नलिखित टुकड़े का उपयोग किया जाता है।
Stack myStack = new Stack(); myStack.push(10); myStack.push(15); myStack.push(20); कोड निष्पादन के उपरोक्त टुकड़े के परिणामस्वरूप प्राप्त प्रारंभिक स्टैक नीचे दिखाया गया है:
यदि हम नीचे दिखाए अनुसार एक और धक्का () ऑपरेशन करते हैं,
push(25); परिणामी स्टैक होगा:
स्टैक पॉप ऑपरेशन
हम 'पॉप' ऑपरेशन का उपयोग करके स्टैक से तत्व निकाल सकते हैं। वर्तमान में शीर्ष द्वारा इंगित किया गया तत्व स्टैक से अलग है।
कोड का निम्नलिखित टुकड़ा इसे प्राप्त करता है।
Stack intStack = new Stack(); intStack.push(100); intStack.push(200); int val = intStack.pop(); वैरिएबल वैल में मान 200 होगा क्योंकि यह स्टैक में धकेल दिया गया अंतिम तत्व था।
पुश और पॉप ऑपरेशन के लिए स्टैक प्रतिनिधित्व निम्नानुसार है:
स्टैक पीक ऑपरेशन
तत्व को हटाए बिना, स्टैक के शीर्ष पर पीक ऑपरेशन लौटाता है। उपरोक्त स्टैक उदाहरण में, 'intStack.peek ()' 200 वापस आ जाएगी।
स्टैक इम्पोर्टेन्ट ऑपरेशन है
यदि स्टैक ऑब्जेक्ट खाली है, तो Stack वर्ग की isEmpty () कार्रवाई जाँचती है। यह सही है अगर स्टैक में कोई तत्व नहीं है तो यह गलत है।
स्टैक सर्च ऑपरेशन
हम खोज () ऑपरेशन का उपयोग करके स्टैक पर एक तत्व खोज सकते हैं। खोज () ऑपरेशन के लिए खोजे जा रहे तत्व के सूचकांक को लौटाता है। यह सूचकांक स्टैक के शीर्ष से गिना जाता है।
Stack intStack = new Stack (); intStack.push (100); intStack.push (200); int index = inStack.search(100); //index will have the value 2.ढेर का आकार
Stack ऑब्जेक्ट का आकार द्वारा दिया गया है java.util.Stack.size () तरीका। यह स्टैक में तत्वों की कुल संख्या लौटाता है।
निम्न उदाहरण स्टैक आकार को प्रिंट करता है।
Stack myStack = new Stack(); myStack.push(100); myStack.push(200); myStack.push(300); System.out.println('Stack size:' + myStack.size()); //Stack size: 3 प्रिंट / Iterate ढेर तत्व
हम स्टैक के लिए एक पुनरावृत्ति की घोषणा कर सकते हैं और फिर इस इटरेटर का उपयोग करके पूरे स्टैक के माध्यम से पार कर सकते हैं। इस तरह हम प्रत्येक स्टैक तत्व को एक-एक करके देख सकते हैं और प्रिंट कर सकते हैं।
निम्न प्रोग्राम इट्रेटर का उपयोग करके स्टैक को पुनरावृत्त करने का तरीका दिखाता है।
import java.util.*; public class Main { public static void main(String() args) { //declare and initialize a stack object Stack stack = new Stack(); stack.push('PUNE'); stack.push('MUMBAI'); stack.push('NASHIK'); System.out.println('Stack elements:'); //get an iterator for the stack Iterator iterator = stack.iterator(); //traverse the stack using iterator in a loop and print each element while(iterator.hasNext()){ System.out.print(iterator.next() + ' '); } } }आउटपुट:
ढेर तत्व:
PUNE MUMBAI NASHIK
जावा 8 का उपयोग करना
हम स्ट्रीम 8 को स्ट्रीम एपीआई, फॉरएच, और फॉरचैमिंग बिल्डिंग जैसी सुविधाओं का उपयोग करके स्टैक तत्वों को प्रिंट या ट्रैस कर सकते हैं।
निम्न प्रोग्राम स्टैक के माध्यम से पार करने के लिए जावा 8 कंस्ट्रक्शन के उपयोग को प्रदर्शित करता है।
import java.util.*; import java.util.stream.*; public class Main { public static void main(String() args) { //declare and initialize a stack object Stack stack = new Stack(); stack.push('PUNE'); stack.push('MUMBAI'); stack.push('NASHIK'); System.out.println('Stack elements using Java 8 forEach:'); //get a stream for the stack Stream stream = stack.stream(); //traverse though each stream object using forEach construct of Java 8 stream.forEach((element) -> { System.out.print(element + ' '); // print element }); System.out.println('
Stack elements using Java 8 forEachRemaining:'); //define an iterator for the stack Iterator stackIterator = stack.iterator(); //use forEachRemaining construct to print each stack element stackIterator.forEachRemaining(val -> { System.out.print(val + ' '); }); } } आउटपुट:
जावा 8 का उपयोग कर ढेर तत्वों:
PUNE MUMBAI NASHIK
जावा 8 का उपयोग कर ढेर तत्व
PUNE MUMBAI NASHIK
जावा में ढेर कार्यान्वयन
निम्नलिखित कार्यक्रम विभिन्न स्टैक संचालन को प्रदर्शित करने वाले विस्तृत स्टैक को लागू करता है।
import java.util.Stack; public class Main { public static void main(String a()){ //declare a stack object Stack stack = new Stack(); //print initial stack System.out.println('Initial stack : ' + stack); //isEmpty () System.out.println('Is stack Empty? : ' + stack.isEmpty()); //push () operation stack.push(10); stack.push(20); stack.push(30); stack.push(40); //print non-empty stack System.out.println('Stack after push operation: ' + stack); //pop () operation System.out.println('Element popped out:' + stack.pop()); System.out.println('Stack after Pop Operation : ' + stack); //search () operation System.out.println('Element 10 found at position: ' + stack.search(10)); System.out.println('Is Stack empty? : ' + stack.isEmpty()); } } आउटपुट:
प्रारंभिक स्टैक: ()
स्टैक खाली है? : सच
पुश ऑपरेशन के बाद स्टैक: (१०, २०, ३०, ४०)
तत्व पॉप आउट: 40
पॉप ऑपरेशन के बाद ढेर: (१०, २०, ३०)
तत्व 10 स्थिति में पाया गया: 3
स्टैक खाली है? : असत्य
ढेर करने के लिए जावा में
स्टैक वर्ग के .AAray () ’पद्धति का उपयोग करके स्टैक डेटा संरचना को एक ऐरे में परिवर्तित किया जा सकता है।
निम्न प्रोग्राम इस रूपांतरण को प्रदर्शित करता है।
import java.util.*; import java.util.stream.*; public class Main { public static void main(String() args) { //declare and initialize a stack object Stack stack = new Stack(); stack.push('PUNE'); stack.push('MUMBAI'); stack.push('NASHIK'); //print the stack System.out.println('The Stack contents: ' + stack); // Create the array and use toArray() method to convert stack to array Object() strArray = stack.toArray(); //print the array System.out.println('The Array contents:'); for (int j = 0; j आउटपुट:
जावा विंडोज 10 के साथ जार फाइलें कैसे खोलें
स्टैक सामग्री: (पन, मुंबई, नाशिक)
सरणी सामग्री:
PUNE MUMBAI NASHIK
जावा में ऐरे का उपयोग करके स्टैक इम्प्लीमेंटेशन
स्टैक को एक ऐरे का उपयोग करके लागू किया जा सकता है। सभी स्टैक ऑपरेशन एक ऐरे का उपयोग करके किए जाते हैं।
नीचे दिए गए कार्यक्रम एक सरणी का उपयोग करके स्टैक कार्यान्वयन को प्रदर्शित करता है।
import java.util.*; //Stack class class Stack { int top; //define top of stack int maxsize = 5; //max size of the stack int() stack_arry = new int(maxsize); //define array that will hold stack elements Stack(){ //stack constructor; initially top = -1 top = -1; } boolean isEmpty(){ //isEmpty () method return (top <0); } boolean push (int val){ //push () method if(top == maxsize-1) { System.out.println('Stack Overflow !!'); return false; } else { top++; stack_arry(top)=val; return true; } } boolean pop () { //pop () method if (top == -1) { System.out.println('Stack Underflow !!'); return false; } else { System.out.println('
Item popped: ' + stack_arry(top--)); return true; } } void display () { //print the stack elements System.out.println('Printing stack elements .....'); for(int i = top; i>=0;i--) { System.out.print(stack_arry(i) + ' '); } } } public class Main { public static void main(String() args) { //define a stack object Stack stck = new Stack(); System.out.println('Initial Stack Empty : ' + stck.isEmpty()); //push elements stck.push(10); stck.push(20); stck.push(30); stck.push(40); System.out.println('After Push Operation...'); //print the elements stck.display(); //pop two elements from stack stck.pop(); stck.pop(); System.out.println('After Pop Operation...'); //print the stack again stck.display(); } } आउटपुट:
प्रारंभिक स्टैक खाली: सच
पुश ऑपरेशन के बाद…
ढेर तत्वों मुद्रण ...
40 30 20 10
आइटम पॉपअप: 40
आइटम पॉपअप: 30
पॉप ऑपरेशन के बाद…
ढेर तत्वों मुद्रण ...
२० १०
लिंक की गई सूची का उपयोग करके स्टैक इम्प्लीमेंटेशन
स्टैक को एक लिंक की गई सूची का उपयोग करके भी लागू किया जा सकता है, जैसे हमने सरणियों का उपयोग करके कैसे किया है। स्टैक को लागू करने के लिए एक लिंक की गई सूची का उपयोग करने का एक फायदा यह है कि यह गतिशील रूप से बढ़ सकता है या सिकुड़ सकता है। हमें सरणियों में अधिकतम आकार प्रतिबंध की आवश्यकता नहीं है।
निम्नलिखित कार्यक्रम स्टैक ऑपरेशन करने के लिए एक लिंक की गई सूची को लागू करता है।
import static java.lang.System.exit; // Stack class using LinkedList class Stack_Linkedlist { // Define Node of LinkedList private class Node { int data; // node data Node nlink; // Node link } // top of the stack Node top; // stack class Constructor Stack_Linkedlist() { this.top = null; } // push () operation public void push(int val) { // create a new node Node temp = new Node(); // checks if the stack is full if (temp == null) { System.out.print('
Stack Overflow'); return; } // assign val to node temp.data = val; // set top of the stack to node link temp.nlink = top; // update top top = temp; } // isEmpty () operation public boolean isEmpty() { return top == null; } // peek () operation public int peek() { // check if the stack is empty if (!isEmpty()) { return top.data; } else { System.out.println('Stack is empty!'); return -1; } } // pop () operation public void pop() { // check if stack is out of elements if (top == null) { System.out.print('
Stack Underflow!!'); return; } // set top to point to next node top = (top).nlink; } //print stack contents public void display() { // check for stack underflow if (top == null) { System.out.printf('
Stack Underflow!!'); exit(1); } else { Node temp = top; System.out.println('Stack elements:'); while (temp != null) { // print node data System.out.print(temp.data + '->'); // assign temp link to temp temp = temp.nlink; } } } } public class Main { public static void main(String() args) { // Create a stack class object Stack_Linkedlist stack_obj = new Stack_Linkedlist(); // push values into the stack stack_obj.push(9); stack_obj.push(7); stack_obj.push(5); stack_obj.push(3); stack_obj.push(1); // print Stack elements stack_obj.display(); // print current stack top System.out.println('
Stack top : ' + stack_obj.peek()); // Pop elements twice System.out.println('Pop two elements'); stack_obj.pop(); stack_obj.pop(); // print Stack elements stack_obj.display(); // print new stack top System.out.println('
New Stack top:' + stack_obj.peek()); } } आउटपुट:
ढेर तत्व:
1-> 3-> 5-> 7-> 9->
स्टैक शीर्ष: 1
पॉप दो तत्व
ढेर तत्व:
5-> 7-> 9->
नया स्टैक शीर्ष: 5
बार बार पूछे जाने वाले प्रश्न
Q # 1) जावा में ढेर क्या हैं?
उत्तर: एक स्टैक तत्वों के लिए एक LIFO (अंतिम में, पहले बाहर) डेटा संरचना है। स्टैक तत्वों को जोड़ दिया जाता है या स्टैक से एक छोर से हटा दिया जाता है जिसे स्टैक के शीर्ष कहा जाता है।
स्टैक के लिए एक तत्व का जोड़ पुश ऑपरेशन का उपयोग करके किया जाता है। तत्वों का विलोपन पॉप ऑपरेशन का उपयोग करके किया जाता है। जावा में, स्टैक वर्ग का उपयोग करके एक स्टैक लागू किया जाता है।
Q # 2) जावा में एक संग्रह है?
उत्तर: हाँ। स्टैक जावा में एक विरासत संग्रह है जो जावा 1.0 में संग्रह एपीआई से उपलब्ध है। स्टैक सूची इंटरफ़ेस के वेक्टर वर्ग को विरासत में मिला है।
Q # 3) स्टैक एक इंटरफ़ेस है?
उत्तर: इंटरफ़ेस स्टैक एक ऐसा इंटरफ़ेस है जो अंतिम-इन, प्रथम-आउट संरचना का वर्णन करता है और इसका उपयोग पुनरावर्ती समस्याओं के भंडारण के लिए किया जाता है।
Q # 4) स्टैक का उपयोग किस लिए किया जाता है?
उत्तर: स्टैक के मुख्य अनुप्रयोग निम्नलिखित हैं:
- अभिव्यक्ति मूल्यांकन और रूपांतरण: स्टैक का उपयोग अभिव्यक्तियों को पोस्टफिक्स, इनफ़िक्स और प्रीफ़िक्स में परिवर्तित करने के लिए किया जाता है। इन भावों का मूल्यांकन करने के लिए भी इसका उपयोग किया जाता है।
- ढेर का उपयोग वाक्यविन्यास के पेड़ों को पार्स करने के लिए भी किया जाता है।
- स्टैक का उपयोग एक अभिव्यक्ति में कोष्ठक की जांच के लिए किया जाता है।
- स्टैक का उपयोग बैकट्रैकिंग समस्याओं को हल करने के लिए किया जाता है।
- स्टैक का उपयोग करके फ़ंक्शन कॉल का मूल्यांकन किया जाता है।
Q # 5) स्टैक के क्या फायदे हैं?
उत्तर: स्टैक पर संग्रहीत चर स्वचालित रूप से वापस आने पर नष्ट हो जाते हैं। जब मेमोरी आवंटित की जाती है और निपटाया जाता है तो स्टैक एक बेहतर विकल्प होता है। स्टैक भी स्मृति को साफ करता है। इसके अलावा कि भावों का मूल्यांकन करने और भावों का विश्लेषण करने के लिए ढेर का प्रभावी ढंग से उपयोग किया जा सकता है।
निष्कर्ष
यह जावा में ढेर पर हमारे ट्यूटोरियल को पूरा करता है। स्टैक वर्ग संग्रह एपीआई का एक हिस्सा है और धक्का, पॉप, झांकना और खोज कार्यों का समर्थन करता है। तत्वों को केवल एक छोर पर स्टैक से जोड़ा / हटाया जाता है। इस छोर को स्टैक के शीर्ष कहा जाता है।
इस ट्यूटोरियल में, हमने स्टैक क्लास द्वारा समर्थित सभी विधियों को देखा है। हमने सरणियों और लिंक की गई सूचियों का उपयोग करके स्टैक को भी लागू किया है।
हम अपने बाद के ट्यूटोरियल में अन्य संग्रह कक्षाओं के साथ आगे बढ़ेंगे।
=> आसान जावा प्रशिक्षण श्रृंखला के माध्यम से पढ़ें
अनुशंसित पाठ
- उदाहरणों के साथ जावा परावर्तन ट्यूटोरियल
- जावा स्कैनर क्लास ट्यूटोरियल उदाहरण के साथ
- एक जावा हैशटेबल क्या है - हैशटेबल कार्यान्वयन और उदाहरण
- जावा वेक्टर क्या है | उदाहरणों के साथ जावा वेक्टर क्लास ट्यूटोरियल
- जावा ऐरे क्लास ट्यूटोरियल - java.util.Arays क्लास उदाहरण के साथ
- जावा बेसिक्स: जावा सिंटैक्स, जावा क्लास और कोर जावा कॉन्सेप्ट
- LinkedHashMap जावा में - LinkedHashMap उदाहरण और कार्यान्वयन
- Java SWING Tutorial: कंटेनर, कंपोनेंट्स एंड इवेंट हैंडलिंग
