ஸ்டேக் டேட்டா ஸ்ட்ரக்சர் என்றால் என்ன
முதலில், ஸ்டாக் தரவு அமைப்பு என்றால் என்ன என்பதை விரைவாகப் பார்ப்போம். இது லாஸ்ட்-இன்-ஃபர்ஸ்ட்-அவுட் (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