పైథాన్‌లో క్యూ డేటా స్ట్రక్చర్ అంటే ఏమిటి?

మునుపటి వ్యాసంలో డేటా స్ట్రక్చర్స్ యొక్క ప్రాముఖ్యత గురించి మీరు ఇప్పటికే అధ్యయనం చేసినట్లుగా, వ్యాసం యొక్క అంశంలో కుడివైపు డైవ్ చేద్దాం, అంటే క్యూ డేటా స్ట్రక్చర్. నేను ఈ క్రింది విషయాలను చర్చిస్తాను:

• క్యూ డేటా స్ట్రక్చర్ అవసరం
• క్యూ యొక్క డైలీ లైఫ్ ఉదాహరణలు
• క్యూ డేటా నిర్మాణాన్ని సృష్టిస్తోంది
• ఎన్-క్యూ
• డి-క్యూ
• క్యూ యొక్క అనువర్తనాలు

క్యూ డేటా స్ట్రక్చర్ అవసరం

మీరు ఒక రోజు సినిమా కావాలని అనుకుందాం. మల్టీప్లెక్స్‌లో, ఫస్ట్-కమ్-ఫస్ట్-సర్వ్ ప్రాతిపదికన టిక్కెట్లు జారీ చేయబడ్డాయి మరియు ప్రజలు తమ వంతు కోసం ఎదురు చూస్తున్నారు. కాబట్టి, మీరు ఏమి చేస్తారు ?? మీరు వెనుకకు వెళ్లి టికెట్ కోసం ఎదురుచూస్తున్న చివరి వ్యక్తి వెనుక నిలబడి ఉండాలి.

ఇక్కడ, ప్రజలు ఒకదాని వెనుక మరొకటి నిలబడి ఉన్నారు మరియు వారు దాని ఆధారంగా సేవలను అందిస్తారు ఫస్ట్-ఇన్-ఫస్ట్-అవుట్ (FIFO) విధానం. ఇటువంటి అమరికను అంటారు క్యూ.

క్యూ యొక్క డైలీ లైఫ్ ఉదాహరణలు

మేము రోజువారీ జీవితంలో క్యూ రకం పనిచేసే కొన్ని ఉదాహరణలను పరిశీలిద్దాం:

• ఫోన్ ఆన్సరింగ్ సిస్టమ్- మీ గాడ్జెట్‌లో మొదట కాల్ చేసే వ్యక్తి మొదట హాజరవుతారు.
• సామాను తనిఖీ చేసే యంత్రం - కన్వేయర్ బెల్ట్‌లో మొదట ఉంచిన సామాను తనిఖీ చేస్తుంది.
• టోల్ టాక్స్ వంతెనపై వాహనాలు - ముందుగా వచ్చే వాహనాలు మొదట బయలుదేరుతాయి.
• కాల్ సెంటర్ - సేవా ప్రతినిధి ఉచితం అయ్యే వరకు ఫోన్ వ్యవస్థలు క్యూలను ఉపయోగిస్తాయి.

ఈ ఉదాహరణలన్నీ అనుసరిస్తాయి ఫస్ట్-ఇన్-లాస్ట్-అవుట్ వ్యూహం.

క్యూ డేటా నిర్మాణాన్ని సృష్టిస్తోంది

పరిపూరకరమైన కార్యకలాపాలు కాకుండా, క్యూలో సాధ్యమయ్యే ప్రధాన కార్యకలాపాలు:

ఒకటి. ఎన్-క్యూ లేదా క్యూ చివరికి ఒక మూలకాన్ని జోడించండి.

2. డి-క్యూ లేదా క్యూ ముందు నుండి ఒక మూలకాన్ని తొలగించండి

ఇప్పుడు, పైథాన్‌లో తరగతి క్యూను సృష్టించడం ద్వారా ప్రారంభిద్దాం:

తరగతి క్యూ: def __init __ (self, max_size): self .__ max_size = max_size self .__ element = [none] * self .__ max_size self .__ వెనుక = -1 నేనే .__ ముందు = 0

• గరిష్ట_ పరిమాణం క్యూలో అంచనా వేసిన మూలకాల గరిష్ట సంఖ్య.
• క్యూ యొక్క అంశాలు పైథాన్ జాబితాలో నిల్వ చేయబడతాయి
• వెనుక వరుసలోని చివరి మూలకం యొక్క సూచిక స్థానాన్ని సూచిస్తుంది.
• క్యూ ఖాళీగా ఉన్నందున వెనుకభాగం మొదట్లో -1 గా తీసుకోబడుతుంది
• ఫ్రంట్ క్యూలోని మొదటి మూలకం యొక్క స్థానాన్ని సూచిస్తుంది.
• ముందు భాగం మొదట్లో 0 గా తీసుకోబడుతుంది ఎందుకంటే ఇది ఎల్లప్పుడూ క్యూ యొక్క మొదటి మూలకాన్ని సూచిస్తుంది

ఎన్క్యూ

ఇప్పుడు, మీరు క్యూకు అంశాలను లెక్కించడానికి ప్రయత్నిస్తున్నప్పుడు, మీరు ఈ క్రింది అంశాలను గుర్తుంచుకోవాలి:

• క్యూలో స్థలం మిగిలి ఉందో లేదో, అనగా వెనుకభాగం max_size -1 కు సమానం అయితే
• వెనుక భాగంలో క్యూలో చేర్చబడిన చివరి మూలకాన్ని సూచిస్తుంది.

కాబట్టి, అల్గోరిథం ఎలా ఉంటుంది ??

# క్యూ యొక్క గరిష్ట_ పరిమాణాన్ని తిరిగి ఇస్తుంది: స్వయం తిరిగి .__ max_size # క్యూ నిండి ఉందో లేదో బూల్ విలువను అందిస్తుంది, పూర్తి అయితే తప్పు మరియు తప్పు లేకపోతే డెఫ్ is_full (స్వయం): స్వయంగా తిరిగి .__ వెనుక == స్వీయ .__ గరిష్ట_ పరిమాణం -1 డేటాను పూర్తి డెఫ్ ఎన్క్యూ (సెల్ఫ్, డేటా) కాకపోతే క్యూలో ఇన్సర్ట్ / ఎన్క్యూ: ఒకవేళ (self.is_full ()): ప్రింట్ ('క్యూ నిండింది. ఎన్క్యూ సాధ్యం కాదు') వేరే: స్వీయ .__ వెనుక + = 1 స్వీయ. __ ఎలిమెంట్స్ [సెల్ఫ్ .__ వెనుక] = డేటా # క్యూ డెఫ్ డిస్ప్లే (సెల్ఫ్) లోని మొత్తం కంటెంట్‌ను ప్రదర్శించండి: నేను పరిధిలో (0, సెల్ఫ్ .__ వెనుక + 1): ప్రింట్ (సెల్ఫ్ .__ ఎలిమెంట్స్ [i]) # మీరు వీటిని ఉపయోగించవచ్చు డీఫ్ __str __ (స్వయం) డీబగ్ చేసేటప్పుడు 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 (“B”)

queue1.enqueue (“C”)

queue1.enqueue (“D”)

queue1.enqueue (“E”)

queue1.display ()

queue1.enqueue (“F”)

ముద్రణ (క్యూ 1)

aws cli ఎలా ప్రారంభించాలి

అవుట్పుట్:

TO

బి

సి

డి

IS

క్యూ నిండింది. ఎన్క్యూ సాధ్యం కాదు

క్యూ డేటా (ఫ్రంట్ టు రియర్): A B C D E.

డి-క్యూ

ఇప్పుడు, మీరు క్యూలో మూలకాలను చొప్పించిన / ఎన్‌క్యూడ్ చేసినందున, మీరు వాటిని ముందు నుండి డీక్యూ / డిలీట్ చేయాలనుకుంటున్నారు, కాబట్టి మీరు ఈ క్రింది వాటి గురించి జాగ్రత్త వహించాలి:

• క్యూలో అంశాలు ఉన్నాయి, అంటే వెనుక -1 కు సమానంగా ఉండకూడదు.
• రెండవది, మీరు ఎలిమెంట్స్ ఫ్రంట్ నుండి తొలగించబడినందున, ఫ్రంట్ తొలగించిన తరువాత నెక్స్ట్ ఫ్రంట్ ను సూచించడానికి పెంచాలి.
• ముందు భాగం క్యూ ముగింపును సూచించకూడదు, అంటే గరిష్ట_ పరిమాణానికి సమానం.

కాబట్టి, అల్గోరిథం ఎలా ఉంటుంది ??

క్యూ ఖాళీగా ఉందో లేదో తనిఖీ చేయడానికి # ఫంక్షన్ డెఫ్ is_empty (self): if (self .__ వెనుక == - 1 లేదా స్వయం .__ ముందు == స్వయం .__ గరిష్ట_ పరిమాణం): మరెన్నో నిజం ఇవ్వండి: ఒక మూలకాన్ని డీక్ చేసి తిరిగి రావడానికి తప్పుడు # ఫంక్షన్ it def dequeue (self): if (self.is_empty ()): print ('క్యూ ఇప్పటికే ఖాళీగా ఉంది') else: data = self .__ ఎలిమెంట్స్ [సెల్ఫ్ .__ ఫ్రంట్] సెల్ఫ్ .__ ఫ్రంట్ + = 1 రిటర్న్ డేటా # ఫంక్షన్ నుండి మూలకాలను ప్రదర్శించడానికి క్యూ ఖాళీగా లేకుంటే ముందు నుండి వెనుకకు డెఫ్ డిస్ప్లే (సెల్ఫ్): if (self.is_empty ()): నేను పరిధిలో ఉంటే (సెల్ఫ్ .__ ఫ్రంట్, సెల్ఫ్ .__ వెనుక + 1): ప్రింట్ (సెల్ఫ్ .__ ఎలిమెంట్స్ [i]) వేరే : ముద్రణ ('ఖాళీ క్యూ')

ఇప్పుడు మీరు ఈ క్రింది వాటిని అమలు చేసినప్పుడు:

queue1 = క్యూ (5)

# అవసరమైన అన్ని మూలకాలను (ల) ఎన్‌క్యూ చేయండి

queue1.enqueue (“A”)

queue1.enqueue (“B”)

queue1.enqueue (“C”)

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.

డీక్యూడ్: ఎ

డీక్యూడ్: బి

డీక్యూడ్: సి

డీక్యూడ్: డి

డీక్యూడ్: ఇ

క్యూ ఇప్పటికే ఖాళీగా ఉంది

డీక్యూడ్: ఏదీ లేదు

ఖాళీ క్యూ

క్యూ యొక్క అనువర్తనాలు

ప్రస్తుతానికి, మీరు ఇప్పటికే క్యూ యొక్క ప్రాథమికాలను అర్థం చేసుకున్నారు. ఇప్పుడు లోతుగా డైవ్ చేయడానికి మేము దాని యొక్క కొన్ని అనువర్తనాలను పరిశీలిస్తాము.

• ఉదాహరణ 1:

విండోస్‌లో ప్రింట్ క్యూ అన్ని క్రియాశీల మరియు పెండింగ్ ప్రింట్ ఉద్యోగాలను నిల్వ చేయడానికి క్యూను ఉపయోగిస్తుంది. మేము పత్రాలను ముద్రించాలనుకున్నప్పుడు, మేము ఒకదాని తరువాత ఒకటి ముద్రణ ఆదేశాలను జారీ చేస్తాము. ముద్రణ ఆదేశాల ఆధారంగా, పత్రాలు ముద్రణ క్యూలో వరుసలో ఉంటాయి. ప్రింటర్ సిద్ధంగా ఉన్నప్పుడు, పత్రం మొదట ముద్రించబడటానికి మొదట పంపబడుతుంది.

మీరు doc1 క్రమంలో 3 పత్రాల కోసం ముద్రణ ఆదేశాలను జారీ చేశారని అనుకుందాం, తరువాత doc2 మరియు doc3.
క్రింద చూపిన విధంగా ముద్రణ క్యూ జనాభా ఉంటుంది:

doc-n, ఇక్కడ doc అనేది ప్రింటింగ్ కోసం పంపిన పత్రం మరియు n, పత్రంలోని పేజీల సంఖ్య. ఉదాహరణకు, doc2-10 అంటే doc2 ముద్రించబడాలి మరియు దీనికి 10 పేజీలు ఉన్నాయి. ప్రింట్ క్యూ ఆపరేషన్‌ను అనుకరించే కోడ్ ఇక్కడ ఉంది. కోడ్ ద్వారా వెళ్లి ఈ అమలులో క్యూ ఎలా ఉపయోగించబడుతుందో గమనించండి.

తరగతి క్యూ: def __init __ (self, max_size): self .__ max_size = max_size self .__ element = [none] * self .__ max_size self .__ వెనుక = -1 నేనే. = self .__ max_size-1): రిటర్న్ ట్రూ రిటర్న్ ఫాల్స్ డెఫ్ is_empty (self): if (self .__ front> self .__ వెనుక): రిటర్న్ ట్రూ రిటర్న్ ఫాల్స్ డెఫ్ ఎన్క్యూ (సెల్ఫ్, డేటా): if (self.is_full ()): print ('క్యూ నిండింది !!!') else: self .__ వెనుక + = 1 స్వీయ .__ అంశాలు [స్వయం .__ వెనుక] = డేటా డెఫ్ డీక్యూ (స్వయం): if (self.is_empty ()): if (self.is_empty ()): print ('క్యూ ఖాళీగా ఉంది! !! ') else: data = self .__ ఎలిమెంట్స్ [సెల్ఫ్ .__ ఫ్రంట్] సెల్ఫ్ .__ ఫ్రంట్ + = 1 రిటర్న్ డేటా డెఫ్ డిస్ప్లే (సెల్ఫ్): ఇండెక్స్ ఇన్ రేంజ్ (సెల్ఫ్ .__ ఫ్రంట్, సెల్ఫ్ .__ రియర్ + 1): ప్రింట్ (సెల్ఫ్ .__ ఎలిమెంట్స్) [ఇండెక్స్]) def get_max_size (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

Doc3 ను ముద్రించలేకపోయాము. ప్రింటర్‌లో తగినంత పేజీలు లేవు

• ఉదాహరణ 2:

క్యూ డేటా నిర్మాణాన్ని ఉపయోగించే మరొక ఉదాహరణను అర్థం చేసుకోవడానికి ప్రయత్నిద్దాం. మీరు కోడ్‌ను అర్థం చేసుకోవడానికి ప్రయత్నించవచ్చు మరియు కింది ఫంక్షన్ ఏమి చేస్తుందో చెప్పగలరా?

1. డెఫ్ ఫన్ (ఎన్):
2. aqueue = క్యూ (100)
3. పరిధిలోని సంఖ్య కోసం (1, n + 1):
4. ఎన్క్యూ (సంఖ్య)
5. ఫలితం = 1
6. అయితే (కాదు (aqueue.is_empty ())):
7. num = AQUUE.DEQUEUE ()
8. ఫలితం * = సంఖ్య
9. ముద్రణ (ఫలితం)

N ను దాటడం ద్వారా ఫంక్షన్ ఫన్ () ను ప్రారంభించినప్పుడు,

• 2 నుండి 4 పంక్తులు 1 నుండి n వరకు మూలకాలను ఎన్-క్యూ చేస్తుంది
• 5 నుండి 8 పంక్తులు ఆ మూలకాల ఉత్పత్తిని ఒక్కొక్కటిగా క్యూ-క్యూ చేయడం ద్వారా కనుగొంటాయి

దీనితో, మేము ఈ క్యూ డేటా స్ట్రక్చర్ వ్యాసం ముగింపుకు వచ్చాము. మీరు మీరే కోడ్‌లను విజయవంతంగా అర్థం చేసుకుని, అమలు చేస్తే, మీరు ఇకపై క్యూ డేటా స్ట్రక్చర్‌కు క్రొత్తవారు కాదు.

మాకు ప్రశ్న ఉందా? దయచేసి ఈ వ్యాసం యొక్క వ్యాఖ్యల విభాగంలో దీనిని ప్రస్తావించండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.

పైథాన్‌తో పాటు దాని వివిధ అనువర్తనాలతో లోతైన జ్ఞానం పొందడానికి, మీరు ప్రత్యక్ష ప్రసారం కోసం నమోదు చేసుకోవచ్చు 24/7 మద్దతు మరియు జీవితకాల ప్రాప్యతతో.