பைத்தானில் ஸ்டேக் தரவு கட்டமைப்புகள் என்ன?

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

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



தரவு கட்டமைப்புகள் ஏன்?

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



சரி, பயன்படுத்தப்படும் வழிமுறை ஒரு முக்கிய பங்கைக் கொண்டிருந்தாலும், தரவு கட்டமைப்பு அல்லது பயன்படுத்தப்படும் கொள்கலன் அந்த வழிமுறையின் அடித்தளமாகும். எந்தவொரு பயன்பாட்டிலும், தரவை ஒரு வழியில் அல்லது அதன் பயன்பாட்டிற்கு மிகவும் பொருத்தமான ஒரு கட்டமைப்பில் ஒழுங்கமைத்து சேமித்து வைப்பது தரவின் திறமையான அணுகல் மற்றும் செயலாக்கத்திற்கு முக்கியமாகும்.

தரவு கட்டமைப்புகளின் வகைகள்

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



தரவு-கட்டமைப்பு வகைகள்

ஸ்டேக் தரவு அமைப்பு என்றால் என்ன?

சில நிஜ வாழ்க்கை உதாரணங்களைக் கவனியுங்கள்:

  • சரக்குகளில் ஏற்றுமதி
  • ஒரு தட்டில் தட்டுகள்
  • நாணயங்களின் அடுக்கு
  • இழுப்பறைகளின் அடுக்கு
  • ரயில்வே முற்றத்தில் ரயில்களை நிறுத்துதல்

plates-stacks-data-structure



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

நிரப்பு செயல்பாடுகளைத் தவிர, அடுக்கில் சாத்தியமான முக்கிய செயல்பாடுகள் பின்வருமாறு நான் கூறலாம்:

  1. ஒரு உறுப்பை அடுக்கின் மேலே தள்ளவும் அல்லது செருகவும்
  2. அடுக்கின் மேலிருந்து ஒரு உறுப்பை பாப் செய்யவும் அல்லது அகற்றவும்

அடுக்கு தரவு கட்டமைப்பை உருவாக்குதல்

வகுப்பு அடுக்கு: def __init __ (self, max_size): self .__ max_size = max_size self .__ element = [none] * self .__ max_size self .__ top = -1
  • அதிகபட்சம் என்பது அடுக்கில் எதிர்பார்க்கப்படும் உறுப்புகளின் அதிகபட்ச எண்ணிக்கை.
  • அடுக்கின் கூறுகள் பைதான் பட்டியலில் சேமிக்கப்படுகின்றன.
  • வெற்று அடுக்கைக் குறிக்க ஆரம்பத்தில் -1 எடுக்கப்பட்ட அடுக்கின் மேல் குறியீட்டை மேலே குறிக்கிறது.

அடுக்கின் ஆரம்ப நிலையை படத்தில் max_size = 5 காணலாம்

உறுப்பை அடுக்கி வைக்கவும்

இப்போது, ​​நீங்கள் உறுப்பை உள்ளிட அல்லது அடுக்கில் தள்ள விரும்பினால், அதை நினைவில் கொள்ள வேண்டும்

  • உறுப்பு செருகப்படும் குறியீட்டை மேலே சுட்டிக்காட்டும்.
  • அடுக்கு நிரம்பும்போது எந்த உறுப்பு செருகப்படாது, அதாவது அதிகபட்சம்_அளவு = மேல் போது.

எனவே வழிமுறை என்னவாக இருக்க வேண்டும் ??

# ஸ்டாக் டெஃப் get_max_size (self) இன் அதிகபட்ச அளவைத் தருகிறது: சுயமாகத் திரும்புக .__ max_size # ஸ்டாக் நிரம்பியிருந்தாலும் இல்லாவிட்டாலும் பூல் மதிப்பைத் தருகிறது, முழுதாக இருந்தால் உண்மை மற்றும் தவறானது def is_full (self): return self.get_max_size () - 1 == சுய .__ மேல் # ஸ்டாக் டெஃப் புஷின் (சுய, தரவு) மேலே உள்ள உறுப்பு: if (self.is_full ()): அச்சிடு ('ஸ்டேக் ஏற்கனவே நிரம்பியுள்ளது') வேறு: சுய .__ மேல் = சுய .__ மேல் + எண்ணாக (1 ) சுய .__ கூறுகள் [சுய .__ மேல்] = தரவு # நீங்கள் டி.எஸ் __str __ (சுய) ஐ பிழைதிருத்தம் செய்யும் போது டி.எஸ் பொருளின் கூறுகளை அச்சிட கீழே உள்ள __str __ () ஐப் பயன்படுத்தலாம்: msg = [] index = self .__ top போது (index> = 0): msg.append ((str) (சுய .__ கூறுகள் [குறியீட்டு])) index- = 1 msg = ''. சேருங்கள் (msg) msg ​​= 'தரவை அடுக்கி (மேலே இருந்து கீழே):' + msg return msg

இப்போது, ​​நீங்கள் பின்வருவனவற்றை இயக்கும்போது:

stack1 = அடுக்கு (4)

# தேவையான அனைத்து உறுப்புகளையும் (களை) அழுத்துங்கள்.

stack1.push (“A”)

stack1.push (“B”)

stack1.push (“C”)

stack1.push (“E”)

அச்சிடு (stack1.is_full ())

அச்சு (அடுக்கு 1)

வெளியீடு:

அடுக்கு ஏற்கனவே நிரம்பியுள்ளது
உண்மை
தரவு அடுக்கு (மேலே இருந்து கீழே): D C B A.

ஜாவாவில் mvc என்றால் என்ன

அடுக்கிலிருந்து பாப் கூறுகள்

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

  • அடுக்கு காலியாக இல்லை, அதாவது மேல்! = -1
  • நீங்கள் தரவை நீக்கும்போது, ​​மேலே அடுக்கின் முந்தைய மேற்புறத்தை சுட்டிக்காட்ட வேண்டும்.

எனவே, வழிமுறை என்னவாக இருக்கும் ??

# ஸ்டாக் காலியாக இருக்கிறதா இல்லையா என்பதை பூல் மதிப்பைத் தருகிறது, காலியாக இருந்தால் உண்மை மற்றும் தவறானது டெஃப் is_empty (சுய): சுயமாகத் திரும்புக .__ top == - 1 # பாப் செய்யப்பட்ட மதிப்பு டெஃப் பாப் (சுய): if (self.is_empty ()): அச்சிடு ('பாப் செய்ய எதுவுமில்லை, ஏற்கனவே காலியாக உள்ளது') வேறு: a = self .__ கூறுகள் [சுய .__ மேல்] சுய .__ மேல் = சுய .__ மேல் -1 ஒரு # திரும்பவும் # எல்லா ஸ்டேக் கூறுகளையும் மேலிருந்து கீழான டெஃப் டிஸ்ப்ளே (சுய) காண்பி: நான் வரம்பில் (சுய .__ மேல், -1, -1): அச்சு (சுய .__ கூறுகள் [i], முடிவு = '') அச்சு ()

இப்போது, ​​முன்பு உருவாக்கிய அடுக்கைக் கருத்தில் கொண்டு, உறுப்புகளை பாப் செய்ய முயற்சிக்கவும்

அச்சு (stack1.pop ())

அச்சு (stack1.pop ())

அச்சு (அடுக்கு 1)

அச்சு (stack1.pop ())

அச்சு (stack1.pop ())

அச்சு (stack1.pop ())

வெளியீடு:

டி

சி

ஸ்டேக் தரவு (மேலே இருந்து கீழே): பி ஏ

பி

TO

பாப் செய்ய எதுவும் இல்லை, ஏற்கனவே காலியாக உள்ளது

அடுக்கு தரவு கட்டமைப்பின் பயன்பாடுகள்

  • எடுத்துக்காட்டு 1:

எண்கணித வெளிப்பாடு மதிப்பீட்டிற்கான அடைப்புக்குறி பொருந்தும் வழிமுறையை செயல்படுத்துவதற்கும் முறை அழைப்புகளை செயல்படுத்துவதற்கும் ஒரு அடுக்கு பயன்படுத்தப்படுகிறது.

இதற்கு பதில் 5.

  • எடுத்துக்காட்டு 2:

விண்டோஸில் கிளிப்போர்டு செயல்தவிர்-மீண்டும் செய் (ctrl + z, ctrl + y) செயல்பாடுகளைச் செயல்படுத்த இரண்டு அடுக்குகளைப் பயன்படுத்துகிறது. எம்.எஸ்-வேர்ட், நோட்பேட் போன்ற விண்டோஸ் சொல் எடிட்டர்களில் நீங்கள் பணியாற்றியிருப்பீர்கள். இங்கே ஒரு உரை எம்.எஸ்-வேர்டில் எழுதப்பட்டுள்ளது. Ctrl-Z மற்றும் Ctrl-Y ஐக் கிளிக் செய்தால் உரை எவ்வாறு மாற்றப்பட்டது என்பதைக் கவனியுங்கள்.

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

# உருவாக்கும் வகுப்பு அடுக்கு வகுப்பு அடுக்கு: def __init __ (self, max_size): self .__ max_size = max_size self .__ element = [none] * self .__ max_size self .__ top = -1 def is_full (self): if (self .__ top == self .__ max_size-1): திரும்பவும் உண்மையான வருவாய் தவறான def is_empty (self): if (self .__ top == - 1): திரும்பவும் உண்மையான வருவாய் தவறான def push (self, data): if (self.is_full ()): if ('அடுக்கு நிரம்பியுள்ளது !!') வேறு: சுய .__ மேல் + = 1 சுய .__ கூறுகள் [சுய .__ மேல்] = தரவு டெஃப் பாப் (சுய): if (self.is_empty ()): அச்சிடு ('அடுக்கு காலியாக உள்ளது! ! ') வேறு: தரவு = சுய .__ கூறுகள் [சுய .__ மேல்] சுய .__ மேல்- = 1 திரும்ப தரவு டெஃப் காட்சி (சுய): if (self.is_empty ()): அச்சிடு (' அடுக்கு காலியாக உள்ளது ') வேறு: குறியீட்டு = சுய .__ மேலே இருக்கும்போது (குறியீட்டு> = 0): அச்சிடு (சுய .__ கூறுகள் [குறியீட்டு]) குறியீட்டு- = 1 டெஃப் get_max_size (சுய): சுயமாகத் திரும்புக .__ அதிகபட்சம்_அளவி # நீங்கள் கீழே உள்ள __str __ () ஐப் பயன்படுத்தலாம். டி.எஸ் பொருள் பிழைத்திருத்தும்போது __str __ (சுய): msg = [] குறியீட்டு = சுய .__ மேலே இருக்கும்போது (குறியீட்டு> = 0): msg.append ((str) (சுய .__ கூறுகள் [குறியீட்டு])) குறியீட்டு- = 1 msg = ' '. சேருங்கள் (msg) msg ​​=' தரவை அடுக்கி (மேலே இருந்து கீழே): '+ msg return ms g # செயல்படுத்துதல் அல்லது நீக்குதல் செயல்பாட்டை டெஃப் அகற்றுதல் (): உலகளாவிய கிளிப்போர்டு, செயல்தவிர்_ஸ்டாக் தரவு = கிளிப்போர்டு [லென் (கிளிப்போர்டு) -1] கிளிப்போர்டு.ரெமோவ் (தரவு) undo_stack.push (தரவு) அச்சு ('அகற்று:', கிளிப்போர்டு) செயல்தவிர் செயல்தவிர் செயல்தவிர் செயல்தவிர் (): உலகளாவிய கிளிப்போர்டு, செயல்தவிர்_அமைத்தல், மீண்டும் செய் என்றால் (undo_stack.is_empty ()): அச்சிடு ('செயல்தவிர்க்க தரவு இல்லை') வேறு: தரவு = undo_stack.pop () கிளிப்போர்டு தரவு) redo_stack.push (தரவு) அச்சு ('செயல்தவிர்:', கிளிப்போர்டு) # செயல்பாட்டை மீண்டும் செய்வதற்கான செயல்பாட்டை டெஃப் மீண்டும் செய் (): உலகளாவிய கிளிப்போர்டு, செயல்தவிர்_அமைத்தல், மீண்டும் செய் என்றால் (redo_stack.is_empty ()): அச்சிடு ('தரவு இல்லை மீண்டும் செய்ய ') else: data = redo_stack.pop () if (தரவு கிளிப்போர்டில் இல்லை): அச்சிடு (' மீண்டும் செய்வதற்கு தரவு இல்லை ') redo_stack.push (தரவு) வேறு: clipboard.remove (தரவு) undo_stack.push ( தரவு) அச்சு ('மீண்டும் செய்:', கிளிப்போர்டு) கிளிப்போர்டு = ['ஏ', 'பி', 'சி', 'டி', 'ஈ', 'எஃப்'] undo_stack = அடுக்கு (லென் (கிளிப்போர்டு)) redo_stack = அடுக்கு (லென் (கிளிப்போர்டு)) அகற்று () செயல்தவிர் () மீண்டும் செய் ()

வெளியீடு:

ஒரு vs ஒரு ஜாவா உள்ளது

அகற்று: [‘ஏ’, ‘பி’, ‘சி’, ‘டி’, ‘இ’]

செயல்தவிர்: [‘ஏ’, ‘பி’, ‘சி’, ‘டி’, ‘இ’, ‘எஃப்’]

மீண்டும் செய்: [‘ஏ’, ‘பி’, ‘சி’, ‘டி’, ‘இ’]

இதன் மூலம், பைதான் கட்டுரையில் இந்த அடுக்கு தரவு கட்டமைப்பின் முடிவுக்கு வருகிறோம். நீங்கள் குறியீடுகளை வெற்றிகரமாக புரிந்துகொண்டு இயக்கியிருந்தால், நீங்கள் இனி தரவு கட்டமைப்பிற்கு புதியவர் அல்ல.

எங்களுக்கு ஒரு கேள்வி கிடைத்ததா? இந்த கட்டுரையின் கருத்துகள் பிரிவில் இதைக் குறிப்பிடவும், விரைவில் நாங்கள் உங்களைத் தொடர்புகொள்வோம்.

பைத்தானின் பல்வேறு பயன்பாடுகளுடன் ஆழ்ந்த அறிவைப் பெற, நீங்கள் நேரலைக்கு பதிவு செய்யலாம் 24/7 ஆதரவு மற்றும் வாழ்நாள் அணுகலுடன்.