Vad är ködatastruktur i Python?

Som du redan har studerat om vikten av datastrukturer i föregående artikel, kan vi dyka rätt i artikelns ämne, dvs ködatastruktur. Jag kommer att diskutera följande ämnen:

• Behov av ködatastruktur
• Dagliga livsexempel på kö
• Skapa en ködatastruktur
• En-kö
• Stäng av kö
• Tillämpningar av kö

Behov av ködatastruktur

Anta att du vill ha en film en dag. I multiplexet utfärdades biljetterna på First-Come-First-Serve-basen och människor stod bakom varandra och väntade på sin tur. Så vad ska du göra?? Du måste ha gått bak och stått bakom den sista personen som väntade på biljetten.

Här står folket bakom varandra och de betjänas baserat på First-in-First-Out (FIFO) mekanism. Ett sådant arrangemang är känt som en Kö.

Dagliga livsexempel på kö

Låt oss överväga några exempel där vi köar typen som fungerar i det dagliga livet:

• Telefonsvar- Personen som ringer först på din gadget deltar först.
• Bagagekontrollmaskin - Kontrollerar bagaget som har hållits först på transportbandet.
• Fordon på avgiftsbryggan - Fordonen som anländer tidigt avgår först.
• Call Center - telefonsystem använder köer för att hålla folk i ordning tills en servicepersonal är gratis.

Alla dessa exempel följer Först-in-sista-ut strategi.

Skapa en ködatastruktur

Förutom de kompletterande operationerna kan jag säga att de viktigaste operationerna som är möjliga i kön är:

ett. En-kö eller lägg till ett element i slutet av kön.

2. Stäng av kö eller ta bort ett element från kön framför

Låt oss börja via att skapa klasskön i Python:

klasskö: def __init __ (själv, max_storlek): själv .__ max_size = max_storlek själv .__ element = [Ingen] * själv .__ max_storlek själv .__ bak = -1 själv .__ fram = 0

• max_storlek är det maximala antalet element som förväntas i kön.
• Element i kön lagras i pythonlistan
• bakre indikerar indexpositionen för det sista elementet i kön.
• Baksidan antas initialt vara -1 eftersom kön är tom
• Fram visar positionen för det första elementet i kön.
• Framsidan är initialt 0 eftersom den alltid pekar på det första elementet i kön

Enqueue

Nu när du försöker häva element till kön måste du komma ihåg följande punkter:

• Oavsett om det finns utrymme kvar i kön eller inte, dvs. om baksidan är lika med max_storlek -1
• Baksidan kommer att peka på det sista elementet i kön.

Så, vad blir algoritmen ??

#returns max_size of queue def get_max_size (self): return self .__ max_size #returns bool value whether queue is full or not, True if full and False else def is_full (self): return self .__ rear == self .__ max_size-1 # infogar / enqueue data till kön om den inte är full def enqueue (self, data): if (self.is_full ()): print ('Queue is full. No enqueue possible') annat: self .__ bakre + = 1 self. __elements [self .__ rear] = data #display all the content of the que def display (self): for i in range (0, self .__ rear + 1): print (self .__ elements [i]) #Du kan använda under __str __ () för att skriva ut elementen i DS-objektet medan du felsöker def __str __ (själv): msg = [] index = self .__ front while (index<=self.__rear): msg.append((str)(self.__elements[index])) index+=1 msg=' '.join(msg) msg='Queue data(Front to Rear): '+msg return msg

Nu när du kör följande:

kö1 = Kö (5)

#Enqueue alla nödvändiga element.

kö1.enqueue (“A”)

que1.enqueue (“B”)

que1.enqueue (“C”)

kö1.enqueue (“D”)

kö1.enqueue (“E”)

kö1.display ()

que1.enqueue (“F”)

skriva ut (kö1)

Produktion:

TILL

företag som använder r programmeringsspråk

B

C

D

ÄR

Kön är full. Ingen möjlighet möjlig

Ködata (fram till bak): A B C D E

De-kö

Nu när du har infogat / inslaget elementen i kön vill du dequeue / ta bort dem från framsidan, så du måste ta hand om följande:

• Det finns element i kön, dvs bak bör inte vara lika med -1.
• För det andra måste du komma ihåg att när element raderas från framsidan så bör fronten efter radering ökas för att peka på nästa front.
• Främre bör inte peka på slutet av kön, dvs lika med max_size.

Så, vad blir algoritmen ??

#funktion för att kontrollera om kön är tom eller inte def is_empty (self): if (self .__ rear == - 1 or self .__ front == self .__ max_size): return True else: return False #function to deque an element and return det def dequeue (själv): om (self.is_empty ()): skriva ut ('kön är redan tom') annat: data = själv .__ element [själv .__ front] själv .__ front + = 1 returnera data #funktion för att visa element från fram till bak om kön inte är tom def display (själv): om (inte själv. är_förlåt ()): för jag inom räckvidd (själv .__ fram, själv .__ bak + 1): skriv ut (själv .__ element [i]) annat : skriv ut ('tom kö')

Nu när du kör följande:

kö1 = Kö (5)

#Enqueue alla nödvändiga element

kö1.enqueue (“A”)

que1.enqueue (“B”)

que1.enqueue (“C”)

kö1.enqueue (“D”)

kö1.enqueue (“E”)

skriva ut (kö1)

#Dequeue alla nödvändiga elementen

skriva ut (“Dequeued:“, queue1.dequeue ())

min SQL-handledning för nybörjare

skriva ut (“Dequeued:“, queue1.dequeue ())

skriva ut (“Dequeued:“, queue1.dequeue ())

skriva ut (“Dequeued:“, queue1.dequeue ())

skriva ut (“Dequeued:“, queue1.dequeue ())

skriva ut (“Dequeued:“, queue1.dequeue ())

#Visa alla element i kön.

kö1.display ()

Produktion:

Ködata (fram till bak): A B C D E

Avskild: A

Avskild: B

Avskalad: C

Dequeued: D

Dequeued: E

kön är redan tom

Avskalad: Ingen

tom kö

Tillämpningar av kö

Från och med nu har du redan förstått grunderna i kö. För att dyka djupare kommer vi att undersöka några av dess applikationer.

• Exempel 1:

Skriv ut kö i Windows använder en kö för att lagra alla aktiva och väntande utskriftsjobb. När vi vill skriva ut dokument ger vi utskriftskommandon efter varandra. Baserat på utskriftskommandona kommer dokumenten att raderas i utskriftskön. När skrivaren är klar skickas dokumentet först in först för att trycka det.

Anta att du har utfärdat utskriftskommandon för tre dokument i ordern doc1, följt av doc2 och doc3.
Utskriftskön fylls i enligt nedan:

doc-n, där doc är det dokument som skickas för utskrift och n, är antalet sidor i dokumentet. Till exempel betyder doc2-10 att doc2 ska skrivas ut och det har 10 sidor. Här är en kod som simulerar utskriftskö. Gå igenom koden och observera hur kön används i denna implementering.

klasskö: def __init __ (själv, max_storlek): själv .__ max_size = max_storlek själv .__ element = [Ingen] * själv .__ max_storlek själv .__ bak = -1 själv .__ fram = 0 def är_full (själv): om (själv .__ bak = = self .__ max_size-1): returnera True return False def is_empty (self): if (self .__ front> self .__ rear): return True return False def enqueue (self, data): if (self.is_full ()): skriv ut ('Kön är full !!!') annat: själv .__ bak + = 1 själv .__ element [själv .__ bak] = data def dequeue (själv): om (self.is_empty ()): skriv ut ('Kön är tom! !! ') annat: data = self .__ element [self .__ front] self .__ front + = 1 return data def display (self): för index in range (self .__ front, self .__ rear + 1): print (self .__ elements [index]) def get_max_size (self): returnera själv .__ max_size # Du kan använda nedan __str __ () för att skriva ut elementen i DS-objektet medan #debugging def __str __ (self): msg = [] index = self .__ front while (index<=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()

Produktion:

vad är en instans av en klass i java

doc1-5 skickas för utskrift

doc2-3 skickas för utskrift

doc3-6 skickas för utskrift

doc1-5 tryckt

Återstående nr. av sidor i skrivaren: 7

doc2-3 tryckt

Återstående nr. sidor i skrivaren: 4

Det gick inte att skriva ut doc3. Det finns inte tillräckligt med sidor i skrivaren

• Exempel 2:

Låt oss försöka förstå ett annat exempel som använder ködatastrukturen. Kan du försöka förstå koden och berätta vad följande funktion gör?

1. def kul (n):
2. aqueue = kö (100)
3. för antal i intervall (1, n + 1):
4. enqueue (num)
5. resultat = 1
6. medan (inte (aqueue.is_empty ())):
7. num = AQUUE.DEQUEUE ()
8. resultat * = num
9. skriva ut (resultat)

När funktionsnöje () åberopas genom att passera n,

• raderna 2 till 4 köer elementen från 1 till n
• rad 5 till 8 hittar produkten från dessa element genom att avköpa den en efter en

Med detta kommer vi till ett slut på denna ködatastrukturartikel. Om du själv förstod och sprang koderna själv är du inte längre nybörjare i ködatastruktur.

Har du en fråga till oss? Vänligen nämna det i kommentarsektionen i den här artikeln så kommer vi tillbaka så snart som möjligt.

För att få fördjupad kunskap om Python tillsammans med dess olika applikationer kan du registrera dig för live med 24/7 support och livstidsåtkomst.