స్టాక్ డేటా స్ట్రక్చర్ అంటే ఏమిటి
అన్నింటిలో మొదటిది, స్టాక్ డేటా నిర్మాణం అంటే ఏమిటో శీఘ్రంగా పరిశీలిద్దాం. ఇది లాస్ట్-ఇన్-ఫస్ట్-అవుట్ (LIFO) సూత్రంపై ఆధారపడిన లీనియర్ డేటా స్ట్రక్చర్. ఇది ఒక రకమైన వ్యతిరేక క్యూ. ఒక పెట్టెలో కార్డుల డెక్ లేదా పుస్తకాల స్టాక్ను ఊహించుకోండి. మీరు మొదట స్టాక్లో ఉంచిన పుస్తకం దిగువన ఉంది మరియు మేము పెట్టెలో నుండి మొదట తీయడం పైన ఉన్న పుస్తకం - అంటే, బాక్స్లోకి చివరిగా వచ్చింది. ఈ సూత్రాన్ని ప్రదర్శించడానికి ఇక్కడ gif చిత్రం ఉంది.
స్టాక్ డేటా నిర్మాణం దేనికి?
సబ్రూటీన్ కాల్లను నిర్వహించడం స్టాక్ యొక్క అత్యంత ముఖ్యమైన ఉపయోగాలలో ఒకటి. స్టాక్లోని కాల్ పాయింట్ సబ్ట్రౌటిన్ను ముగించిన తర్వాత దాని నుండి తిరిగి వచ్చే చిరునామాను నిల్వ చేస్తుంది (మరియు బహుశా పారామితులు ఆమోదించబడి ఉండవచ్చు). సబ్ట్రౌటీన్ల ప్రతి సమూహ (పునరావృతతతో సహా) కాల్తో, కొత్త రిటర్న్ చిరునామాలు స్టాక్కు జోడించబడతాయి. సబ్రూటీన్ (రిటర్న్) నుండి ప్రతి రిటర్న్ ఆపరేషన్తో, రిటర్న్ అడ్రస్ స్టాక్ నుండి తీసివేయబడుతుంది మరియు నియంత్రణ దానికి బదిలీ చేయబడుతుంది. ప్రోగ్రామింగ్కు ఈ అప్లికేషన్ చాలా ముఖ్యమైనది, చాలా ప్రాసెసర్లలో రిటర్న్ స్టాక్ ఇన్స్ట్రక్షన్ సెట్లోని హార్డ్వేర్లో అమలు చేయబడుతుంది. అయితే, ఇతర సందర్భాల్లో, స్టాక్ మరింత సాధారణ డేటా నిర్మాణాలపై నమూనాగా ఉండాలి.జావా స్టాక్ క్లాస్ ఆఫ్ కలెక్షన్ ఫ్రేమ్వర్క్
జావా స్టాక్ క్లాస్లో జాబితా ఇంటర్ఫేస్ను అమలు చేసే మరియు వెక్టర్ క్లాస్ని విస్తరించే కలెక్షన్ ఫ్రేమ్వర్క్ నుండి ఒక తరగతి. ఇది ఇంటర్ఫేస్లను కూడా అమలు చేస్తుంది కలెక్షన్, ఇటరబుల్, క్లోనబుల్, సీరియలైజబుల్. మీరు బహుశా ఇప్పటికే ఊహించినట్లుగా, ఈ తరగతి వస్తువుల LIFO స్టాక్ను సూచిస్తుంది. ఇక్కడ స్టాక్ క్లాస్ యొక్క కన్స్ట్రక్టర్కు కాల్ ఉంది , అంటే, ఈ తరగతికి చెందిన వస్తువును సృష్టించడం.
Stack<E> stack = new Stack<E>();
ఇక్కడ E అనేది ఆబ్జెక్ట్ రకం.
జావా స్టాక్ పద్ధతులు
ఈ తరగతికి ఒక డిఫాల్ట్ కన్స్ట్రక్టర్ మరియు వెక్టర్ క్లాస్ యొక్క అన్ని పద్ధతులు మాత్రమే ఉన్నాయి . అదనంగా, స్టాక్ దాని స్వంత 5 పద్ధతులను కలిగి ఉంది:-
బూలియన్ ఖాళీ() పద్ధతి స్టాక్ ఖాళీగా ఉందో లేదో తనిఖీ చేస్తుంది. స్టాక్ ఖాళీగా ఉంటే ఒప్పు , కాకపోతే తప్పు అని చూపుతుంది .
-
ఆబ్జెక్ట్ పీక్() పద్ధతి స్టాక్ ఎగువన ఉన్న మూలకాన్ని అందిస్తుంది.
-
ఆబ్జెక్ట్ పాప్() పద్ధతి స్టాక్ ఎగువన ఉన్న ఎలిమెంట్ను తిరిగి ఇస్తుంది మరియు దానిని తీసివేస్తుంది.
-
ఆబ్జెక్ట్ పుష్ (ఆబ్జెక్ట్ ఎలిమెంట్) పద్ధతి పేర్కొన్న మూలకాన్ని స్టాక్ పైభాగానికి జోడిస్తుంది.
-
int శోధన (ఆబ్జెక్ట్ మూలకం) పద్ధతి పేర్కొన్న మూలకం కోసం స్టాక్ను శోధిస్తుంది. అవసరమైన మూలకం కనుగొనబడితే, ఎగువ నుండి దాని "దూరం" (క్రమ సంఖ్య) తిరిగి ఇవ్వబడుతుంది. మూలకం కనుగొనబడకపోతే, -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());
}
}
}
అవుట్పుట్ ఇక్కడ ఉంది:
GO TO FULL VERSION