Hvad er kødatastruktur i Python?

Denne artikel vil give dig en detaljeret og omfattende viden om kødatastrukturer i Python med mange eksempler.

Som du allerede har studeret om vigtigheden af ​​datastrukturer i den foregående artikel, kan vi dykke lige i emnet for artiklen, dvs. kødatastruktur. Jeg diskuterer følgende emner:



Behov for kødatastruktur

Antag at du vil have en film en dag. I multiplexet blev billetterne udstedt på First-Come-First-Serve-basis, og folk stod bag hinanden og ventede på deres tur. Så hvad vil du gøre ?? Du skal være gået bagud og stå bag den sidste person, der ventede på billetten.



queue-data-structure

Her står folket bag hinanden, og de serviceres baseret på First-in-First-Out (FIFO) mekanisme. Et sådant arrangement er kendt som en Kø.



Daglige liv Eksempler på kø

Lad os overveje nogle eksempler, hvor vi ser køtype, der fungerer i det daglige liv:

  • Telefonsvarer- Den person, der først ringer til din gadget, deltager først.
  • Bagage kontrol maskine - Kontrollerer den bagage, der først er opbevaret på transportbåndet.
  • Køretøjer på vejafgiftsbroen - Køretøjerne, der ankommer tidligt, kører først.
  • Callcenter - telefonsystemer bruger køer til at holde folk, der ringer til dem, i orden, indtil en servicerepræsentant er gratis.

Alle disse eksempler følger Første-i-sidste-ud strategi.

Oprettelse af en kødatastruktur

Bortset fra de supplerende operationer kan jeg sige, at de vigtigste operationer, der er mulige i køen, er:



en. En kø eller tilføj et element i slutningen af ​​køen.

2. Fra kø eller fjern et element foran køen

Lad os nu starte med at oprette klassekø i Python:

klasse Kø: def __init __ (selv, max_size): selv .__ max_size = max_size selv .__ elementer = [Ingen] * selv .__ max_size selv .__ bag = -1 selv .__ front = 0
  • maks. størrelse er det maksimale antal elementer, der forventes i køen.
  • Elementer i køen gemmes i pythonlisten
  • bagtil angiver indekspositionen for det sidste element i køen.
  • Bagsiden anses oprindeligt for at være -1, fordi køen er tom
  • Front angiver placeringen af ​​det første element i køen.
  • Forsiden tages oprindeligt til 0, fordi den altid peger på det første element i køen

Enqueue

Når du nu prøver at indkassere elementer til køen, skal du huske følgende punkter:

  • Uanset om der er plads tilbage i køen eller ej, dvs. hvis bageste er lig med max_size -1
  • Bagsiden peger på det sidste element, der er indsat i køen.

Så hvad bliver 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 Ellers def is_full (self): return self .__ rear == self .__ max_size-1 # indsætter / indkoder data i køen, hvis den ikke er fuld def enqueue (selv, data): hvis (self.is_full ()): udskriver ('Kø er fuld. Ingen indkapsling mulig') ellers: selv .__ bag + = 1 selv. __elements [self .__ rear] = data #vis alt indholdet af kødef-displayet (selv): for i inden for rækkevidde (0, selv .__ bag + 1): udskriv (selv .__-elementer [i]) #Du kan bruge under __str __ () for at udskrive elementerne i DS-objektet under fejlfinding def __str __ (selv): 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 udfører følgende:

kø1 = Kø (5)

#Enqueue alle de krævede element (er).

kø1.enqueue (“A”)

kø1.enqueue (“B”)

kø1.enqueue (“C”)

kø1.enqueue (“D”)

kø1.enqueue (“E”)

kø1.display ()

kø1.enqueue (“F”)

udskrive (kø1)

Produktion:

TIL

B

C

D

ER

Køen er fuld. Ingen mulighed er mulig

Kødata (forreste til bageste): A B C D E

hvordan man opretter en logger-fil i java

De-kø

Når du nu har indsat / indkapslet elementerne i køen, vil du dequeue / slette dem forfra, så du skal passe på følgende:

  • Der er elementer i køen, dvs. bagpå skal ikke være lig med -1.
  • For det andet skal du huske, at når elementer slettes fra fronten, skal fronten efter sletning forøges for at pege på den næste front.
  • Fronten skal ikke pege mod slutningen af ​​køen, dvs. lig med max_size.

Så hvad bliver algoritmen ??

#funktion for at kontrollere, om køen er tom eller ikke def er_fordygtig (selv): hvis (selv .__ bag == - 1 eller selv .__ front == selv .__ max_størrelse): returner Sandt andet: returner Falsk # funktion for at deque et element og returnere det def dequeue (selv): hvis (self.is_empty ()): print ('køen er allerede tom') ellers: data = selv .__ elementer [selv .__ front] selv .__ front + = 1 returnere data # funktion til at vise elementer fra front til bag, hvis køen ikke er tom def display (selv): hvis (ikke self.is_empty ()): for jeg inden for rækkevidde (selv .__ front, selv .__ bag + 1): udskriv (selv .__ elementer [i]) ellers : print ('tom kø')

Nu når du udfører følgende:

kø1 = Kø (5)

#Enqueue alle de krævede element (er)

kø1.enqueue (“A”)

kø1.enqueue (“B”)

kø1.enqueue (“C”)

kø1.enqueue (“D”)

kø1.enqueue (“E”)

udskrive (kø1)

#Dequeue alle de krævede element (er)

print (“Dequeued:“, que1.dequeue ())

print (“Dequeued:“, que1.dequeue ())

print (“Dequeued:“, que1.dequeue ())

print (“Dequeued:“, que1.dequeue ())

print (“Dequeued:“, que1.dequeue ())

print (“Dequeued:“, que1.dequeue ())

#Vis alle elementerne i køen.

kø1.display ()

Produktion:

ved hjælp af namespace c ++

Kødata (forreste til bageste): A B C D E

Afskåret: A

Afskåret: B

Afskåret: C

Afskåret: D

Afskåret: E

køen er allerede tom

Afskåret: Ingen

tom kø

Anvendelser af kø

Fra nu af har du allerede forstået det grundlæggende i køen. For at dykke dybere vil vi se på nogle af dets applikationer.

  • Eksempel 1:

Udskriv kø i Windows bruger en kø til at gemme alle de aktive og afventende udskriftsjob. Når vi vil udskrive dokumenter, udsender vi udskriftskommandoer efter hinanden. Baseret på udskrivningskommandoer bliver dokumenterne foret op i udskriftskøen. Når printeren er klar, sendes dokumentet først i første rækkefølge for at få det udskrevet.

Antag at du har udstedt udskriftskommandoer til 3 dokumenter i ordren doc1 efterfulgt af doc2 og doc3.
Udskriftskøen udfyldes som vist nedenfor:

doc-n, hvor doc er det dokument, der sendes til udskrivning og n, er antallet af sider i dokumentet. For eksempel betyder doc2-10, at doc2 skal udskrives, og det har 10 sider. Her er en kode, der simulerer udskrivningskøfunktion. Gå gennem koden og observer, hvordan køen bruges i denne implementering.

klasse Kø: def __init __ (selv, maks_størrelse): selv .__ max_size = max_størrelse selv .__ elementer = [Ingen] * selv .__ max_størrelse selv .__ bag = -1 selv .__ front = 0 def er_full (selv): hvis (selv .__ bag = = self .__ max_size-1): returner True return False def is_empty (self): if (self .__ front> self .__ rear): return True return False def enqueue (self, data): if (self.is_full ()): print ('Kø er fuld !!!') ellers: selv .__ bag + = 1 selv .__ elementer [selv .__ bag] = data def dequeue (selv): hvis (self.is_empty ()): print ('Kø er tom! !! ') andet: data = selv .__ elementer [selv .__ front] selv .__ front + = 1 returnere data def display (selv): for indeks i rækkevidde (selv .__ front, selv .__ bag + 1): udskriv (selv .__ elementer [index]) def get_max_size (self): return self .__ max_size #Du kan bruge nedenstående __str __ () til at udskrive elementerne i DS-objektet, mens #debugging def __str __ (selv): msg = [] index = self .__ front mens (indeks<=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:

doc1-5 sendt til udskrivning

doc2-3 sendt til udskrivning

doc3-6 sendt til udskrivning

doc1-5 trykt

Resterende nr. sider i printeren: 7

doc2-3 udskrevet

Resterende nr. sider i printeren: 4

Kunne ikke udskrive doc3. Der er ikke nok sider i printeren

  • Eksempel 2:

Lad os prøve at forstå et andet eksempel, der bruger kødatastruktur. Kan du prøve at forstå koden og fortælle, hvad følgende funktion gør?

  1. def sjov (n):
  2. aqueue = Kø (100)
  3. for antal i rækkevidde (1, n + 1):
  4. enqueue (num)
  5. resultat = 1
  6. mens (ikke (aqueue.is_empty ())):
  7. num = AQUUE.DEQUEUE ()
  8. resultat * = antal
  9. print (resultat)

Når funktions sjov () påberåbes ved at passere n,

  • linje 2 til 4 sætter elementerne i kø fra 1 til n
  • linje 5 til 8 finder produktet af disse elementer ved at afkøle det en efter en

Med dette kommer vi til slutningen af ​​denne kødatastrukturartikel. Hvis du med succes har forstået og kørt koderne, er du ikke længere en nybegynder i kødatastruktur.

Har du et spørgsmål til os? Nævn det i kommentarfeltet i denne artikel, og vi vender tilbage til dig hurtigst muligt.

For at få dybtgående viden om Python sammen med dens forskellige applikationer kan du tilmelde dig live med 24/7 support og levetid adgang.