ஜாவா ஸ்டேக் 101: ஸ்டாக் கிளாஸை ஆராய்தல்

ஜாவாவில் உள்ள ஸ்டேக் என்பது வரிசை, வரிசை, இணைக்கப்பட்ட பட்டியல் அல்லது மரம் போன்ற தரவுக் கட்டமைப்பாகும். ஜாவா ஸ்டாக், லாஸ்ட் இன், ஃபர்ஸ்ட் அவுட் (LIFO) கொள்கையை அடிப்படையாகக் கொண்டது. இதன் பொருள் என்னவென்றால், அடுக்கில் இருந்து ஒரு உறுப்பைச் சேர்க்க மற்றும் அகற்ற இரண்டு கட்டளைகளைப் பயன்படுத்தும்போது, ​​​​நீங்கள் முதலில் அகற்றுவது எப்போதும் நீங்கள் கடைசியாகச் சேர்த்ததாக இருக்கும். ஜாவா ஸ்டாக் வகுப்பை இன்னும் விரிவாகப் பார்ப்போம்

ஜாவா ஸ்டாக் வகுப்பை ஆராய்கிறது

ஜாவா ஸ்டாக் கிளாஸ் என்பது வெக்டர் வகுப்பின் நீட்டிப்பாகும் , இதுவே பட்டியல் வகுப்பை விரிவுபடுத்துகிறது. திசையன்கள் மாறக்கூடியவை மற்றும் உள்ளே உள்ள உறுப்புகளின் தேவைகளுடன் வளர்ந்து சுருங்கக்கூடியவை என்பதால், ஸ்டாக் கள் தேவைக்கேற்ப அளவுகளையும் மாற்றலாம். திசையன் வகுப்பின் நீட்டிப்பு ஒரு திசையனை அடுக்காக மாற்றும் ஐந்து செயல்பாடுகளைச் சேர்க்கிறது . இந்த ஐந்து செயல்பாடுகள்:

• .push(E உருப்படி) - அடுக்கின் மேல் ஒரு உறுப்பை வைக்கிறது
• .pop() – அடுக்கின் மேல் உள்ள உறுப்பை நீக்கி, அதை செயல்பாட்டின் மதிப்பாக வழங்கும்
• .peek() – அடுக்கின் மேல் உள்ள உறுப்பை அகற்றாமல் பார்க்கிறது
• .empty() – ஸ்டேக் காலியாக உள்ளதா இல்லையா என்பதை சோதிக்க பூலியன் செயல்பாடு. 0 அல்லது 1ஐ வழங்கும்.
• .search(Object o) - o ஐத் தேடி அதன் நிலையைத் தருகிறது. மதிப்பு 1 அடிப்படையிலானது, 0 அடிப்படையிலானது அல்ல

ஸ்டாக் , வெக்டரின் ஒரு பகுதியாக இருக்கும் அனைத்து முறைகளையும் பெறுகிறது , இதில், toString() , கொண்டுள்ளது() , indexOf() , மற்றும் lastElement() .

ஜாவா ஸ்டாக் உதாரணம் குறியீட்டு முறை

இப்போது ஸ்டாக்கிற்கான செயல்பாடுகளை நாம் அறிந்திருக்கிறோம் , ஜாவா ஸ்டாக் உதாரணத்தை குறியிடுவோம். தற்காலிகமாகச் சேமிக்கப்பட்டு விரைவாக மீட்டெடுக்கப்பட வேண்டிய தரவைக் கையாள அடுக்குகள் மிகவும் பயனுள்ளதாக இருக்கும் . ஸ்டேக் LIFO என்பதால் , மர தரவு கட்டமைப்பை ஆராயும் போது, ​​முனை டிராவர்சலுக்கு இது மிகவும் பயனுள்ளதாக இருக்கும். நாம் அனைத்திற்கும் செல்வதற்கு முன், ஒரு அடிப்படை அடுக்கை உருவாக்குவோம். ஒரு அடுக்கை செயல்படுத்துவதற்கான குறியீடு பின்வருமாறு:

import java.util.*;

class Main {
  public static void main(String[] args) {
    Stack<Integer> stackExample = new Stack<Integer>();

காலியான அடுக்கை உருவாக்க நீங்கள் செய்ய வேண்டியது அவ்வளவுதான் . இதைப் பயன்படுத்தி தரவு வகையை அறிவிக்காமல் எளிமையாக அறிவிக்கலாம்:

Stack example = new Stack();

ஸ்டாக் கள் மாறக்கூடியவை என்பதால் , உறுப்புகளை அடுக்கின் மீது தள்ளும்போது, ​​அது தானாகவே அளவை சரிசெய்யும் என்பதை நினைவில் கொள்ளுங்கள். இப்போது Stack செயல்பாடுகளை எவ்வாறு பயன்படுத்துவது என்பதைப் பார்ப்போம் .

ஜாவா ஸ்டாக் செயல்படுத்தல்

நாம் முன்பு சுருக்கமாக ஆராய்ந்த ஐந்து முறைகளை எவ்வாறு பயன்படுத்துவது என்பதைப் பார்ப்போம். ஜாவா ஸ்டாக் செயலாக்கத்தை நீங்கள் தட்டுகளின் அடுக்காக நினைத்தால் நினைவில் கொள்வது எளிது. நீங்கள் தட்டுகளை அடுக்கி வைக்கிறீர்கள், ஆனால் ஒரு தட்டு பெற, நீங்கள் கீழே செல்ல வேண்டாம், மேலே இருந்து ஒன்றைப் பெறுவீர்கள். நீங்கள் கடைசியாகப் போடுவதை முதலில் கழற்றுவீர்கள். எங்களின் முந்தைய உதாரணத்தை StackExample உடன் நீட்டித்தால் , செயல்பாடுகள் பின்வருமாறு:

தள்ளு

// pushing integers onto the Stack
    stackExample.push(5);
    stackExample.push(10);

இந்த கட்டத்தில், இந்த இரண்டு முழு எண்களையும் ஒவ்வொரு முறையும் ஜாவா ஸ்டாக் எடுத்துக்காட்டுக்கு தள்ளியது போல் மற்ற செயல்பாடுகளைக் காட்டப் போகிறோம்.

பாப்

//popping integers off of the Stack
System.out.println(stackExample.pop());
System.out.println(stackExample.pop());

வெளியீடு:

10
5

காலியாக உள்ளது

இப்போது, ​​நீங்கள் ஒரு அடுக்கிலிருந்து அனைத்து உறுப்புகளையும் அகற்ற விரும்புகிறீர்கள் என்று வைத்துக்கொள்வோம், ஆனால் எத்தனை உறுப்புகள் உள்ளன என்பது உங்களுக்குத் தெரியவில்லை. நீங்கள் Boolean.isEmpty () செயல்பாட்டை ஒரு முன்நிபந்தனையுடன் இணைக்கலாம் . இந்த ஜாவா ஸ்டாக் செயல்படுத்தல் எவ்வாறு செய்யப்படுகிறது என்பதைப் பாருங்கள்.

while(!stackExample.isEmpty()) {      
  System.out.println(stackExample.pop());
}

வெளியீடு

10
5

எட்டிப்பார்

ஜாவாவில் .peek()ஐ ஸ்டாக் அமலாக்கமாகப் பயன்படுத்தி ஸ்டாக்கின் அடுத்த உருப்படியை அகற்றாமல் பார்க்கலாம் .

System.out.println(stackExample.peek());

வெளியீடு

10

நாம் ஸ்டாக்கை பாப் செய்து பிரிண்ட் செய்தால், அது 10 மற்றும் 5 ஐ வழங்கும், ஏனெனில் 10 இன்னும் அடுக்கில் உள்ளது. நாங்கள் அதைப் பார்த்தோம், பாப் செயல்பாடு மூலம் அதை அகற்றவில்லை. ஜாவாவில் ஸ்டாக் களுக்கு பீக் செயல்பாடு ஒரு சிறந்த கருவியாகும் .

தேடு

நாம் ஒரு குறிப்பிட்ட உறுப்பைக் கண்டுபிடிக்க விரும்பினால், ஜாவாவில் உள்ள அடுக்குகள் செயல்படுத்தல் .search(e); அதை கண்டுபிடிக்க.

System.out.println(stackExample.search(5));

வெளியீடு

2

இதற்குக் காரணம் நாம் ஸ்டேக்கின் மேலிருந்து எண்ணுவதும் , ஜாவா ஸ்டாக் கள் 1 இல் தொடங்குவதும், ஒரு வரிசையைப் போல 0 இல் அல்ல . எனவே, அடுக்கைப் பார்த்தால், அது (10) --> (5), மற்றும் 5 என்பது எண் 2 இடத்தில் உள்ளது. அடுக்கில் இல்லாத ஒரு உறுப்பைக் கண்டுபிடிக்க முயற்சித்தால் , வெளியீடாக -1 கிடைக்கும்.

மீண்டும் கூறுதல்

எந்தவொரு சேகரிப்பிலும் பணிபுரியும் போது, ​​நீங்கள் பல கூறுகளைத் தேட வேண்டிய நேரங்கள் இருக்கலாம். சிக்கலைச் சேமிக்கவும், ஸ்டேக் மூலம் பலமுறை தேடவும் , நீங்கள் மறு செய்கையைப் பயன்படுத்தலாம். ஜாவாவில் ஸ்டாக் பட்டியல் வகுப்பை நீட்டிப்பதால் , மீண்டும் மீண்டும் செய்ய பல விருப்பங்கள் உள்ளன. ListIterator செயல்பாட்டைப் பயன்படுத்துவது எளிதான ஒன்று . .hasPrevious() அல்லது .hasNext() ஐப் பயன்படுத்தி ஒரு அடுக்கை மேலிருந்து கீழாகவோ அல்லது கீழிருந்து மேல் நோக்கியோ பயணிக்க ListIterator உங்களை அனுமதிக்கிறது . இது எப்படி இருக்கிறது என்பது இங்கே:

ListIterator<Integer> exampleIterator = stackExample.listIterator(stackExample.size());

  while (exampleIterator.hasPrevious()) {
    int iteration = exampleIterator.previous();
    System.out.println(iteration);
  }

வெளியீடு

10
5

ஜாவாவில் உள்ள ஸ்டாக் கள் மூலம் நீங்கள் மீண்டும் செயல்படும் போது, ​​அதில் உள்ள எந்த உறுப்புகளையும் நீக்க மாட்டீர்கள் என்பதை நினைவில் கொள்ளவும் . மறு செய்கையானது அடுக்கில் உள்ள ஒவ்வொரு உறுப்புகளையும் வரிசையாகப் பார்க்க உங்களை அனுமதிக்கிறது. நீங்கள் இதைச் செய்யும்போது, ​​​​சில கூறுகள் இருக்கும் இடங்களைத் தேடலாம், பின்னர் அவற்றைக் கையாளலாம். தேவைப்பட்டால் அவற்றை எண்ணலாம், நீக்கலாம் அல்லது மாற்றலாம்.