Какво представлява структурата на данните за опашката в Python?

Както вече сте проучили значението на структурите на данни в предишната статия, нека се потопим точно в темата на статията, т.е. Ще обсъждам следните теми:

• Необходимост от структура на данните за опашката
• Примери за ежедневието на опашката
• Създаване на структура на данните за опашката
• Опашка на опашка
• Де-опашка
• Приложения на опашката

Необходимост от структура на данните за опашката

Да предположим, че искате някой ден за филм. В мултиплекса билетите се издаваха на принципа „Първият дойде-първи обслужи“ и хората стояха един зад друг в очакване на своя ред. И така, какво ще правиш ?? Сигурно сте отишли ​​отзад и сте застанали зад последния човек, който чака билета.

Тук хората стоят един зад друг и те се обслужват въз основа на Първо в първото излизане (FIFO) механизъм. Такова подреждане е известно като a Опашка.

Примери за ежедневието на опашката

Нека да разгледаме някои примери, в които ние виждаме опашки, работещи в ежедневието:

• Система за телефонен секретар - Човекът, който се обади пръв на вашата притурка, получава първо присъствие.
• Машина за проверка на багажа - Проверява багажа, който е държан първо на конвейерната лента.
• Превозни средства по моста за данъчни такси - Превозните средства, които пристигат рано, тръгват първи.
• Кол център - телефонните системи ще използват Опашки, за да задържат хората, които им се обаждат, докато представителят на услугата не бъде освободен.

Всички тези примери следват Първо в последното излизане стратегия.

Създаване на структура на данните за опашката

Освен допълнителните операции, мога да кажа, че основните операции, които са възможни на опашката, са:

един. Опашка на опашка или добавете елемент в края на опашката.

2. Де-опашка или премахнете елемент от предната страна на опашката

Сега, нека започнем чрез създаване на Queue на класа в Python:

class Queue: def __init __ (self, max_size): self .__ max_size = max_size self .__ elements = [None] * self .__ max_size self .__ back = -1 self .__ front = 0

• max_size е максималният брой елементи, които се очакват в опашката.
• Елементите на опашката се съхраняват в списъка на python
• отзад показва позицията на индекса на последния елемент в опашката.
• Първоначално се приема, че задната е -1, тъй като опашката е празна
• Front показва позицията на първия елемент в опашката.
• Първоначално се приема, че фронтът е 0, защото винаги ще сочи към първия елемент на опашката

Опашка

Сега, когато се опитвате да изпратите елементи в опашката в опашката, трябва да запомните следните точки:

• Независимо дали има място в опашката или не, т.е.ако задната част е равна на max_size -1
• Задната част ще сочи към последния елемент, вмъкнат в опашката.

И така, какъв ще бъде алгоритъмът ??

#returns max_size на опашката def get_max_size (self): върне self .__ max_size #returns bool стойност дали опашката е пълна или не, True ако е пълна и False в противен случай def is_full (self): return self .__ back == self .__ max_size-1 # вмъква / поставя данни в опашката, ако не е пълна def enqueue (self, data): if (self.is_full ()): print ('Опашката е пълна. Няма възможност за опашка') else: self .__ задна + = 1 самостоятелна. __elements [самостоятелно .__ задно] = данни # покажете цялото съдържание на дисплея на опашката def (self): за i в обхват (0, self .__ задна + 1): print (self .__ elements [i]) # Можете да използвате отдолу __str __ () за отпечатване на елементите на DS обекта при отстраняване на грешки 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

Сега, когато изпълните следното:

опашка1 = Опашка (5)

# Изпратете всички необходими елементи.

queue1.enqueue („A“)

queue1.enqueue („B“)

можете ли да разширите и внедрите в java

queue1.enqueue („C“)

queue1.enqueue („D“)

queue1.enqueue („E“)

queue1.display ()

queue1.enqueue („F“)

печат (опашка1)

Изход:

ДА СЕ

Б.

° С

д

Е

Опашката е пълна. Не е възможно опашка

Данни за опашката (отпред отзад): A B C D E

Де-опашка

Сега, след като сте вмъкнали / поставили в опашка елементите в опашката, искате да ги премахнете / изтриете отпред, така че трябва да се погрижите за следното:

• В опашката има елементи, т.е.зад не трябва да бъде равен на -1.
• На второ място, трябва да запомните, че тъй като елементите се изтриват отпред, така че след изтриване фронтът трябва да бъде увеличен до точка следващ фронт.
• Предната част не трябва да сочи края на опашката, т.е. равна на max_size.

И така, какъв ще бъде алгоритъмът ??

# функция за проверка дали опашката е празна или не def is_empty (самостоятелно): if (самостоятелно .__ задно == - 1 или самостоятелно .__ отпред == самостоятелно .__ max_size): return True else: return False # function за деактивиране на елемент и връщане def defueque (self): if (self.is_empty ()): print ('опашката вече е празна') else: data = self .__ elements [self .__ front] self .__ front + = 1 return data # function to display elements from отпред назад, ако опашката не е празна def display (self): if (not self.is_empty ()): за i в обхват (self .__ front, self .__ задна + 1): print (self .__ elements [i]) else : print ('празна опашка')

Сега, когато изпълнявате следното:

опашка1 = Опашка (5)

# Изпратете всички необходими елементи

queue1.enqueue („A“)

queue1.enqueue („B“)

queue1.enqueue („C“)

queue1.enqueue („D“)

queue1.enqueue („E“)

печат (опашка1)

# Деактивиране на всички необходими елементи

print („Dequeued:“, queue1.dequeue ())

print („Dequeued:“, queue1.dequeue ())

print („Dequeued:“, queue1.dequeue ())

print („Dequeued:“, queue1.dequeue ())

print („Dequeued:“, queue1.dequeue ())

print („Dequeued:“, queue1.dequeue ())

# Показване на всички елементи в опашката.

queue1.display ()

Изход:

Данни за опашката (отпред отзад): A B C D E

Отнема: A

Отхвърлено: B

Отнема: C

Отнема: D

Отхвърлено: E

опашката вече е празна

Отхвърлено: Няма

празна опашка

Приложения на опашката

Към момента вече сте разбрали основите на опашката. Сега, за да се потопим по-дълбоко, ще разгледаме някои от неговите приложения.

• Пример 1:

Опашка за печат в Windows използва опашка за съхраняване на всички активни и чакащи задания за печат. Когато искаме да отпечатаме документи, ние издаваме команди за печат една след друга. Въз основа на командите за печат, документите ще бъдат подредени в опашката за печат. Когато принтерът е готов, документът ще бъде изпратен първи в първи ред, за да се отпечата.

Да предположим, че сте издали команди за печат за 3 документа в реда на doc1, последвани от doc2 и doc3.
Опашката за печат ще се попълни, както е показано по-долу:

doc-n, където doc е документът, изпратен за печат и n, е броят на страниците в документа. Например, doc2-10 означава, че doc2 трябва да бъде отпечатан и има 10 страници. Ето код, който симулира работата на опашката за печат. Прегледайте кода и наблюдавайте как опашката се използва в това изпълнение.

class Queue: def __init __ (self, max_size): self .__ max_size = max_size self .__ elements = [None] * self .__ max_size self .__ back = -1 self .__ front = 0 def is_full (self): if (self .__ rear = = self .__ max_size-1): return True return False def is_empty (self): if (self .__ front> self .__ back): return True return False def enqueue (self, data): if (self.is_full ()): print ('Queue is full !!!') else: self .__ rear + = 1 self .__ elements [self .__ rear] = data def dequeue (self): if (self.is_empty ()): print ('Queue is empty! !! ') else: data = self .__ elements [self .__ front] self .__ front + = 1 return data def display (self): за индекс в обхват (self .__ front, self .__ rear + 1): print (self .__ elements [index]) def get_max_size (self): return self .__ max_size # Можете да използвате __str __ () по-долу, за да отпечатате елементите на DS обекта, докато #debugging def __str __ (self): msg = [] index = self .__ front while (индекс<=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. def fun (n):
2. aqueue = Опашка (100)
3. за число в обхват (1, n + 1):
4. опашка (брой)
5. резултат = 1
6. while (не (aqueue.is_empty ())):
7. num = AQUUE.DEQUEUE ()
8. резултат * = брой
9. печат (резултат)

Когато функцията fun () се извиква чрез предаване на n,

• редове 2 до 4 изпращат на опашка елементите от 1 до n
• редове 5 до 8 намира произведението на тези елементи, като го деактивира един по един

С това стигнахме до края на тази статия за структурата на данните за опашката. Ако успешно сте разбрали и стартирали кодовете сами, вече не сте начинаещ в структурата на данните за опашката.

Имате въпрос към нас? Моля, споменете го в раздела за коментари на тази статия и ние ще се свържем с вас възможно най-скоро.

За да получите задълбочени познания за Python заедно с различните му приложения, можете да се регистрирате за живо с 24/7 поддръжка и доживотен достъп.