பைத்தானில் வரிசை தரவு அமைப்பு என்றால் என்ன?



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

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

வரிசை தரவு கட்டமைப்பு தேவை

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





queue-data-structure

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



வரிசையின் தினசரி வாழ்க்கை எடுத்துக்காட்டுகள்

அன்றாட வாழ்க்கையில் வரிசை வகை வேலை செய்யும் சில எடுத்துக்காட்டுகளைக் கருத்தில் கொள்வோம்:

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

இந்த எடுத்துக்காட்டுகள் அனைத்தும் பின்பற்றப்படுகின்றன முதல்-கடைசி-அவுட் மூலோபாயம்.

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

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



ஒன்று. என்-வரிசை அல்லது வரிசையின் முடிவில் ஒரு உறுப்பைச் சேர்க்கவும்.

2. டி-வரிசை அல்லது வரிசையின் முன்னால் ஒரு உறுப்பை அகற்றவும்

இப்போது, ​​பைத்தானில் வகுப்பு வரிசையை உருவாக்குவதன் மூலம் ஆரம்பிக்கலாம்:

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

என்க்யூ

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

  • வரிசையில் இடம் இருக்கிறதா இல்லையா, அதாவது பின்புறம் அதிகபட்ச_அளவை -1 க்கு சமமாக இருந்தால்
  • பின்புறம் வரிசையில் செருகப்பட்ட கடைசி உறுப்பை சுட்டிக்காட்டும்.

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

# வரிசை டெஃப் get_max_size (self) இன் அதிகபட்ச_ அளவைத் தருகிறது: சுயமாகத் திரும்புக .__ max_size # வரிசை நிரம்பியிருந்தாலும் இல்லாவிட்டாலும் பூல் மதிப்பைத் தருகிறது, முழுதாக இருந்தால் உண்மை மற்றும் தவறானது இல்லையெனில் def is_full (self): சுயமாகத் திரும்புக .__ பின்புறம் == சுய முழு டெஃப் என்க்யூ (சுய, தரவு) இல்லையென்றால் வரிசையில் தரவைச் செருகவும் / இணைக்கவும்: if (self.is_full ()): அச்சு ('வரிசை நிரம்பியுள்ளது. எந்தக் குறியீடும் சாத்தியமில்லை') வேறு: சுய .__ பின்புறம் + = 1 சுய. __ கூறுகள் [சுய .__ பின்புறம்] = தரவு # வரிசை டெஃப் டிஸ்ப்ளே (சுய) இன் அனைத்து உள்ளடக்கத்தையும் காண்பி: நான் வரம்பில் (0, சுய .__ பின்புற + 1): அச்சு (சுய .__ கூறுகள் [i]) # நீங்கள் பயன்படுத்தலாம் def __str __ (self) ஐ பிழைதிருத்தம் செய்யும் போது DS பொருளின் கூறுகளை அச்சிட __str __ () கீழே: msg = [] index = self .__ முன் போது (குறியீட்டு<=self.__rear): msg.append((str)(self.__elements[index])) index+=1 msg=' '.join(msg) msg='Queue data(Front to Rear): '+msg return msg

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

queue1 = வரிசை (5)

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

queue1.enqueue (“A”)

queue1.enqueue (“பி”)

queue1.enqueue (“சி”)

queue1.enqueue (“D”)

queue1.enqueue (“E”)

queue1.display ()

queue1.enqueue (“F”)

அச்சு (வரிசை 1)

வெளியீடு:

TO

ஜாவாஸ்கிரிப்டில் வரிசை நீளத்தை எவ்வாறு கண்டுபிடிப்பது

பி

சி

டி

இருக்கிறது

வரிசை நிரம்பியுள்ளது. எந்த மதிப்பீடும் சாத்தியமில்லை

வரிசை தரவு (முன் முதல் பின்புறம்): A B C D E.

டி-வரிசை

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

  • வரிசையில் உறுப்புகள் உள்ளன, அதாவது பின்புறம் -1 க்கு சமமாக இருக்கக்கூடாது.
  • இரண்டாவதாக, முன்னால் இருந்து கூறுகள் நீக்கப்படுவதால், முன் பகுதியை நீக்கிய பின் அடுத்த முன் புள்ளியை அதிகரிக்க அதிகரிக்க வேண்டும் என்பதை நீங்கள் நினைவில் கொள்ள வேண்டும்.
  • முன் வரிசையின் முடிவை சுட்டிக்காட்டக்கூடாது, அதாவது அதிகபட்ச_அளவுக்கு சமம்.

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

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

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

queue1 = வரிசை (5)

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

queue1.enqueue (“A”)

queue1.enqueue (“பி”)

queue1.enqueue (“சி”)

queue1.enqueue (“D”)

queue1.enqueue (“E”)

அச்சு (வரிசை 1)

# தேவையான அனைத்து உறுப்புகளையும் (களை) விலக்குக

அச்சு (“Dequeued:“, queue1.dequeue ())

ஆரம்பநிலைகளுக்கான எனது சதுர பயிற்சி

அச்சு (“Dequeued:“, queue1.dequeue ())

அச்சு (“Dequeued:“, queue1.dequeue ())

அச்சு (“Dequeued:“, queue1.dequeue ())

அச்சு (“Dequeued:“, queue1.dequeue ())

அச்சு (“Dequeued:“, queue1.dequeue ())

# வரிசையில் உள்ள அனைத்து உறுப்புகளையும் காண்பி.

queue1.display ()

வெளியீடு:

வரிசை தரவு (முன் முதல் பின்புறம்): A B C D E.

Dequeued: அ

Dequeued: பி

Dequeued: சி

Dequeued: டி

Dequeued: இ

வரிசை ஏற்கனவே காலியாக உள்ளது

Dequeued: எதுவுமில்லை

வெற்று வரிசை

வரிசையின் பயன்பாடுகள்

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

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

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

Doc1 வரிசையில் 3 ஆவணங்களுக்கான அச்சு கட்டளைகளை நீங்கள் வெளியிட்டுள்ளீர்கள் என்று வைத்துக்கொள்வோம், அதைத் தொடர்ந்து doc2 மற்றும் doc3.
கீழே காட்டப்பட்டுள்ளபடி அச்சு வரிசை மக்கள்தொகை பெறும்:

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

வகுப்பு வரிசை: def __init __ (self, max_size): self .__ max_size = max_size self .__ உறுப்புகள் = [எதுவுமில்லை] * சுய .__ அதிகபட்சம்_அளவு சுய .__ பின்புறம் = -1 சுய .__ முன் = 0 டெஃப் is_full (சுய): என்றால் (சுய .__ பின்புறம் = = self .__ max_size-1): உண்மையான வருவாயைத் திருப்புதல் தவறான டெஃப் is_empty (self): if (self .__ front> self .__ பின்புறம்): திரும்பவும் உண்மையான வருவாய் தவறான def enqueue (self, data): if (self.is_full ()): print ('வரிசை நிரம்பியுள்ளது !!!') வேறு: சுய .__ பின்புறம் + = 1 சுய .__ கூறுகள் [சுய .__ பின்புறம்] = தரவு டெஃப் dequeue (சுய): if (self.is_empty ()): if (self.is_empty ()): print ('வரிசை காலியாக உள்ளது! !! ') வேறு: தரவு = சுய .__ கூறுகள் [சுய .__ முன்] சுய .__ முன் + = 1 திரும்ப தரவு டெஃப் காட்சி (சுய): வரம்பில் உள்ள குறியீட்டுக்கு (சுய .__ முன், சுய .__ பின்புற + 1): அச்சு (சுய .__ கூறுகள்) [index]) def get_max_size (self): self return .__ max_size # DS பொருளின் கூறுகளை அச்சிட கீழேயுள்ள __str __ () ஐப் பயன்படுத்தலாம், அதே நேரத்தில் # பிழைத்திருத்தம் __str __ (சுய): msg = [] index = self .__ முன் (குறியீட்டு<=self.__rear): msg.append((str)(self.__elements[index])) index+=1 msg=' '.join(msg) msg='Queue data(Front to Rear): '+msg return msg #function that enqueue are the documents to be printed in Queue named print_queue def send_for_print(doc): global print_queue if(print_queue.is_full()): print('Queue is full') else: print_queue.enqueue(doc) print(doc,'sent for printing') #function that prints the document if number of pages of document is less than #total number of pages in printer def start_printing(): global print_queue while(not print_queue.is_empty()): #here we dequeue the Queue and take the coument that was input first for printing. doc=print_queue.dequeue() global pages_in_printer #the aim of this for loop is to find number of pages of the of document which is doc name followed by “-“ for i in range(0,len(doc)): if(doc[i]=='-'): no_of_pages=int(doc[i+1:]) break if(no_of_pages<=pages_in_printer): print(doc,'printed') pages_in_printer-=no_of_pages print('Remaining no. of pages in printer:', pages_in_printer) else: print('Couldn't print',doc[:i],'. Not enough pages in the printer.') pages_in_printer=12 print_queue=Queue(10) send_for_print('doc1-5') send_for_print('doc2-3') send_for_print('doc3-6') start_printing()

வெளியீடு:

ஆரம்பகால வசந்த எம்விசி பயிற்சி

doc1-5 அச்சிட அனுப்பப்பட்டது

doc2-3 அச்சிட அனுப்பப்பட்டது

doc3-6 அச்சிட அனுப்பப்பட்டது

doc1-5 அச்சிடப்பட்டது

இல்லை. அச்சுப்பொறியில் உள்ள பக்கங்கள்: 7

doc2-3 அச்சிடப்பட்டது

இல்லை. அச்சுப்பொறியில் உள்ள பக்கங்கள்: 4

டாக் 3 ஐ அச்சிட முடியவில்லை. அச்சுப்பொறியில் போதுமான பக்கங்கள் இல்லை

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

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

  1. def fun (n):
  2. aqueue = வரிசை (100)
  3. வரம்பில் உள்ள எண்ணுக்கு (1, n + 1):
  4. enqueue (எண்)
  5. முடிவு = 1
  6. (இல்லை (aqueue.is_empty ())):
  7. num = AQUUE.DEQUEUE ()
  8. முடிவு * = எண்
  9. அச்சு (முடிவு)

N ஐ கடந்து செயல்பாட்டின் வேடிக்கை () செயல்படுத்தப்படும்போது,

  • 2 முதல் 4 வரிகள் 1 முதல் n வரையிலான கூறுகளை வரிசைப்படுத்துகின்றன
  • 5 முதல் 8 வரிகள் அந்த உறுப்புகளின் உற்பத்தியை ஒவ்வொன்றாக வரிசைப்படுத்துவதன் மூலம் கண்டுபிடிக்கின்றன

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

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

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