From f3ebf4cf59a5236db24de46c119b8d7d29ab3e83 Mon Sep 17 00:00:00 2001 From: Ashley Jeji George <40469421+Ashley-J-George@users.noreply.github.com> Date: Tue, 15 Sep 2020 00:16:39 +0530 Subject: [PATCH 01/10] Create priority_queue.py Implementation of Priority Queue using lists --- data_structures/queue/priority_queue.py | 249 ++++++++++++++++++++++++ 1 file changed, 249 insertions(+) create mode 100644 data_structures/queue/priority_queue.py diff --git a/data_structures/queue/priority_queue.py b/data_structures/queue/priority_queue.py new file mode 100644 index 000000000000..dbc7354cb37f --- /dev/null +++ b/data_structures/queue/priority_queue.py @@ -0,0 +1,249 @@ +""" +Pure Python implementation of Priority Queue using lists +""" + + +class FixedPriorityQueue: + """ + In a Priority Queue the elements are entred as an when the come + But while removing or deleting an element the highest priority element is deleted in FIFO fasion + Here the lowest integer has the highest priority. + Example: + priority(0) > priority(5) + priority(16) > priority(32) + Here as an example I have taken only 3 priorities viz. 0, 1, 2 + 0 Being the highest priority and 2 being the lowest + You can change the priorities as per your need + + Examples + >>>FPQ = FixedPriorityQueue() + >>>FPQ.enqueue(0, 10) + >>>FPQ.enqueue(1, 70) + >>>FPQ.enqueue(0, 100) + >>>FPQ.enqueue(2, 1) + >>>FPQ.enqueue(2, 5) + >>>FPQ.enqueue(1, 7) + >>>FPQ.enqueue(2, 4) + >>>FPQ.enqueue(1, 64) + >>>FPQ.enqueue(0, 128) + >>>FPQ.print_queue() + Priority 0: [10, 100, 128] + Priority 1: [70, 7, 64] + Priority 2: [1, 5, 4] + >>>print(FPQ.dequeue()) + 10 + >>>print(FPQ.dequeue()) + 100 + >>>print(FPQ.dequeue()) + 128 + >>>print(FPQ.dequeue()) + 70 + >>>print(FPQ.dequeue()) + 7 + >>>FPQ.print_queue() + Priority 0: [] + Priority 1: [64] + Priority 2: [1, 5, 4] + >>>print(FPQ.dequeue()) + 64 + >>>print(FPQ.dequeue()) + 1 + >>>print(FPQ.dequeue()) + 5 + >>>print(FPQ.dequeue()) + 4 + >>>print(FPQ.dequeue()) + Traceback (most recent call last): + File "Sample.py", line 117, in + print(FPQ.dequeue()) + File "Sample.py", line 58, in dequeue + raise Exception("Under Flow!") + Exception: Under Flow! + """ + + def __init__(self) -> None: + self.queue = [ + [], + [], + [], + ] + + def enqueue(self, priority: int, data: int) -> None: + """ + This function enters the element into the FixedPriorityQueue based on its priority + If the priority is invalid an Exception is raised saying Invalid Priority! + If the FixedPriorityQueue is full an Exception is raised saying Over Flow! + """ + if priority > 2: + raise Exception("Invalid Priority!") + elif len(self.queue[priority]) == 100: + raise Exception("Over Flow!") + else: + self.queue[priority].append(data) + + def dequeue(self) -> int: + """ + This function returns the highest priority element from the FixedPriorityQueue in FIFO fasion + If the FixedPriorityQueue is empty and this function is called then an exception is raised saying Under Flow! + """ + if ( + len(self.queue[0]) == 0 + and len(self.queue[1]) == 0 + and len(self.queue[2]) == 0 + ): + raise Exception("Under Flow!") + + if len(self.queue[0]) != 0: + return self.queue[0].pop(0) + elif len(self.queue[1]) != 0: + return self.queue[1].pop(0) + else: + return self.queue[2].pop(0) + + def print_queue(self) -> None: + """ + Prints each priority queue within the FixedPriorityQueue + """ + print("Priority 0:", self.queue[0]) + print("Priority 1:", self.queue[1]) + print("Priority 2:", self.queue[2]) + + +class ElementPriorityQueue: + """ + Element Priority Queue is the same as Fixed Priority Queue + The only difference being the value of the element itself is the priority + The rule for priorities are the same + The lowest integer has the highest priority. + Example: + priority(0) > priority(5) + priority(16) > priority(32) + You can change the priorities as per your need + + >>>EPQ = ElementPriorityQueue() + >>>EPQ.enqueue(10) + >>>EPQ.enqueue(70) + >>>EPQ.enqueue(100) + >>>EPQ.enqueue(1) + >>>EPQ.enqueue(5) + >>>EPQ.enqueue(7) + >>>EPQ.enqueue(4) + >>>EPQ.enqueue(64) + >>>EPQ.enqueue(128) + >>>EPQ.print_queue() + [10, 70, 100, 1, 5, 7, 4, 64, 128] + >>>print(EPQ.dequeue()) + 1 + >>>print(EPQ.dequeue()) + 4 + >>>print(EPQ.dequeue()) + 5 + >>>print(EPQ.dequeue()) + 7 + >>>print(EPQ.dequeue()) + 10 + >>>EPQ.print_queue() + [70, 100, 64, 128] + >>>print(EPQ.dequeue()) + 64 + >>>print(EPQ.dequeue()) + 70 + >>>print(EPQ.dequeue()) + 100 + >>>print(EPQ.dequeue()) + 128 + >>>print(EPQ.dequeue()) + Traceback (most recent call last): + File "Sample.py", line 132, in + print(EPQ.dequeue()) + File "Sample.py", line 100, in dequeue + raise Exception("Under Flow!") + Exception: Under Flow! + """ + + def __init__(self) -> None: + self.queue = [] + + def enqueue(self, data: int) -> None: + ''' + This function enters the element into the ElementPriorityQueue based on its value + If the ElementPriorityQueue is full an Exception is raised saying Over Flow! + ''' + if len(self.queue) == 100: + raise Exception("Over Flow!") + else: + self.queue.append(data) + + def dequeue(self) -> int: + ''' + This function returns the highest priority element from the ElementPriorityQueue in FIFO fasion. + If the ElementPriorityQueue is empty and this function is called then an exception is raised saying Under Flow! + ''' + if len(self.queue) == 0: + raise Exception("Under Flow!") + else: + data = min(self.queue) + self.queue.remove(data) + return data + + def print_queue(self) -> None: + ''' + Prints all the elements within the Element Priority Queue + ''' + print(self.queue) + + +def fixed_priority_queue() -> None: + FPQ = FixedPriorityQueue() + FPQ.enqueue(0, 10) + FPQ.enqueue(1, 70) + FPQ.enqueue(0, 100) + FPQ.enqueue(2, 1) + FPQ.enqueue(2, 5) + FPQ.enqueue(1, 7) + FPQ.enqueue(2, 4) + FPQ.enqueue(1, 64) + FPQ.enqueue(0, 128) + FPQ.print_queue() + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + FPQ.print_queue() + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + + +def element_priority_queue() -> None: + EPQ = ElementPriorityQueue() + EPQ.enqueue(10) + EPQ.enqueue(70) + EPQ.enqueue(100) + EPQ.enqueue(1) + EPQ.enqueue(5) + EPQ.enqueue(7) + EPQ.enqueue(4) + EPQ.enqueue(64) + EPQ.enqueue(128) + EPQ.print_queue() + print(EPQ.dequeue()) + print(EPQ.dequeue()) + print(EPQ.dequeue()) + print(EPQ.dequeue()) + print(EPQ.dequeue()) + EPQ.print_queue() + print(EPQ.dequeue()) + print(EPQ.dequeue()) + print(EPQ.dequeue()) + print(EPQ.dequeue()) + print(EPQ.dequeue()) + + + +if __name__ == "__main__": + fixed_priority_queue() + element_priority_queue() From 3617e19b13d1335407ccf8d1627f694ec6ac3df9 Mon Sep 17 00:00:00 2001 From: Ashley Jeji George <40469421+Ashley-J-George@users.noreply.github.com> Date: Tue, 15 Sep 2020 00:22:10 +0530 Subject: [PATCH 02/10] Update priority_queue.py Corrected the spelling mistake of fashion --- data_structures/queue/priority_queue.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/data_structures/queue/priority_queue.py b/data_structures/queue/priority_queue.py index dbc7354cb37f..1fa99f9f85b3 100644 --- a/data_structures/queue/priority_queue.py +++ b/data_structures/queue/priority_queue.py @@ -6,7 +6,7 @@ class FixedPriorityQueue: """ In a Priority Queue the elements are entred as an when the come - But while removing or deleting an element the highest priority element is deleted in FIFO fasion + But while removing or deleting an element the highest priority element is deleted in FIFO fashion Here the lowest integer has the highest priority. Example: priority(0) > priority(5) @@ -83,7 +83,7 @@ def enqueue(self, priority: int, data: int) -> None: def dequeue(self) -> int: """ - This function returns the highest priority element from the FixedPriorityQueue in FIFO fasion + This function returns the highest priority element from the FixedPriorityQueue in FIFO fashion If the FixedPriorityQueue is empty and this function is called then an exception is raised saying Under Flow! """ if ( From 3529a687cec50876c2e10fa651f906de765ea926 Mon Sep 17 00:00:00 2001 From: Ashley Jeji George <40469421+Ashley-J-George@users.noreply.github.com> Date: Tue, 15 Sep 2020 00:25:47 +0530 Subject: [PATCH 03/10] Update priority_queue.py --- data_structures/queue/priority_queue.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/data_structures/queue/priority_queue.py b/data_structures/queue/priority_queue.py index 1fa99f9f85b3..61e14f10c87c 100644 --- a/data_structures/queue/priority_queue.py +++ b/data_structures/queue/priority_queue.py @@ -176,7 +176,7 @@ def enqueue(self, data: int) -> None: def dequeue(self) -> int: ''' - This function returns the highest priority element from the ElementPriorityQueue in FIFO fasion. + This function returns the highest priority element from the ElementPriorityQueue in FIFO fashion. If the ElementPriorityQueue is empty and this function is called then an exception is raised saying Under Flow! ''' if len(self.queue) == 0: From 3cdfb546273b42133fd85326461a3c936af2821f Mon Sep 17 00:00:00 2001 From: Ashley Jeji George <40469421+Ashley-J-George@users.noreply.github.com> Date: Tue, 15 Sep 2020 00:33:16 +0530 Subject: [PATCH 04/10] Update priority_queue.py --- data_structures/queue/priority_queue.py | 471 ++++++++++++------------ 1 file changed, 235 insertions(+), 236 deletions(-) diff --git a/data_structures/queue/priority_queue.py b/data_structures/queue/priority_queue.py index 61e14f10c87c..117ef2508a3f 100644 --- a/data_structures/queue/priority_queue.py +++ b/data_structures/queue/priority_queue.py @@ -4,246 +4,245 @@ class FixedPriorityQueue: - """ - In a Priority Queue the elements are entred as an when the come - But while removing or deleting an element the highest priority element is deleted in FIFO fashion - Here the lowest integer has the highest priority. - Example: - priority(0) > priority(5) - priority(16) > priority(32) - Here as an example I have taken only 3 priorities viz. 0, 1, 2 - 0 Being the highest priority and 2 being the lowest - You can change the priorities as per your need - - Examples - >>>FPQ = FixedPriorityQueue() - >>>FPQ.enqueue(0, 10) - >>>FPQ.enqueue(1, 70) - >>>FPQ.enqueue(0, 100) - >>>FPQ.enqueue(2, 1) - >>>FPQ.enqueue(2, 5) - >>>FPQ.enqueue(1, 7) - >>>FPQ.enqueue(2, 4) - >>>FPQ.enqueue(1, 64) - >>>FPQ.enqueue(0, 128) - >>>FPQ.print_queue() - Priority 0: [10, 100, 128] - Priority 1: [70, 7, 64] - Priority 2: [1, 5, 4] - >>>print(FPQ.dequeue()) - 10 - >>>print(FPQ.dequeue()) - 100 - >>>print(FPQ.dequeue()) - 128 - >>>print(FPQ.dequeue()) - 70 - >>>print(FPQ.dequeue()) - 7 - >>>FPQ.print_queue() - Priority 0: [] - Priority 1: [64] - Priority 2: [1, 5, 4] - >>>print(FPQ.dequeue()) - 64 - >>>print(FPQ.dequeue()) - 1 - >>>print(FPQ.dequeue()) - 5 - >>>print(FPQ.dequeue()) - 4 - >>>print(FPQ.dequeue()) - Traceback (most recent call last): - File "Sample.py", line 117, in - print(FPQ.dequeue()) - File "Sample.py", line 58, in dequeue - raise Exception("Under Flow!") - Exception: Under Flow! - """ - - def __init__(self) -> None: - self.queue = [ - [], - [], - [], - ] - - def enqueue(self, priority: int, data: int) -> None: - """ - This function enters the element into the FixedPriorityQueue based on its priority - If the priority is invalid an Exception is raised saying Invalid Priority! - If the FixedPriorityQueue is full an Exception is raised saying Over Flow! - """ - if priority > 2: - raise Exception("Invalid Priority!") - elif len(self.queue[priority]) == 100: - raise Exception("Over Flow!") - else: - self.queue[priority].append(data) - - def dequeue(self) -> int: - """ - This function returns the highest priority element from the FixedPriorityQueue in FIFO fashion - If the FixedPriorityQueue is empty and this function is called then an exception is raised saying Under Flow! - """ - if ( - len(self.queue[0]) == 0 - and len(self.queue[1]) == 0 - and len(self.queue[2]) == 0 - ): - raise Exception("Under Flow!") - - if len(self.queue[0]) != 0: - return self.queue[0].pop(0) - elif len(self.queue[1]) != 0: - return self.queue[1].pop(0) - else: - return self.queue[2].pop(0) - - def print_queue(self) -> None: - """ - Prints each priority queue within the FixedPriorityQueue - """ - print("Priority 0:", self.queue[0]) - print("Priority 1:", self.queue[1]) - print("Priority 2:", self.queue[2]) + """ + In a Priority Queue the elements are entred as an when the come + But while removing or deleting an element the highest priority element is deleted in FIFO fashion + Here the lowest integer has the highest priority. + Example: + priority(0) > priority(5) + priority(16) > priority(32) + Here as an example I have taken only 3 priorities viz. 0, 1, 2 + 0 Being the highest priority and 2 being the lowest + You can change the priorities as per your need + + Examples + >>>FPQ = FixedPriorityQueue() + >>>FPQ.enqueue(0, 10) + >>>FPQ.enqueue(1, 70) + >>>FPQ.enqueue(0, 100) + >>>FPQ.enqueue(2, 1) + >>>FPQ.enqueue(2, 5) + >>>FPQ.enqueue(1, 7) + >>>FPQ.enqueue(2, 4) + >>>FPQ.enqueue(1, 64) + >>>FPQ.enqueue(0, 128) + >>>FPQ.print_queue() + Priority 0: [10, 100, 128] + Priority 1: [70, 7, 64] + Priority 2: [1, 5, 4] + >>>print(FPQ.dequeue()) + 10 + >>>print(FPQ.dequeue()) + 100 + >>>print(FPQ.dequeue()) + 128 + >>>print(FPQ.dequeue()) + 70 + >>>print(FPQ.dequeue()) + 7 + >>>FPQ.print_queue() + Priority 0: [] + Priority 1: [64] + Priority 2: [1, 5, 4] + >>>print(FPQ.dequeue()) + 64 + >>>print(FPQ.dequeue()) + 1 + >>>print(FPQ.dequeue()) + 5 + >>>print(FPQ.dequeue()) + 4 + >>>print(FPQ.dequeue()) + Traceback (most recent call last): + File "Sample.py", line 117, in + print(FPQ.dequeue()) + File "Sample.py", line 58, in dequeue + raise Exception("Under Flow!") + Exception: Under Flow! + """ + + def __init__(self): + self.queue = [ + [], + [], + [], + ] + + def enqueue(self, priority, data): + """ + This function enters the element into the FixedPriorityQueue based on its priority + If the priority is invalid an Exception is raised saying Invalid Priority! + If the FixedPriorityQueue is full an Exception is raised saying Over Flow! + """ + if priority > 2: + raise Exception("Invalid Priority!") + elif len(self.queue[priority]) == 100: + raise Exception("Over Flow!") + else: + self.queue[priority].append(data) + + def dequeue(self): + """ + This function returns the highest priority element from the FixedPriorityQueue in FIFO fashion + If the FixedPriorityQueue is empty and this function is called then an exception is raised saying Under Flow! + """ + if ( + len(self.queue[0]) == 0 + and len(self.queue[1]) == 0 + and len(self.queue[2]) == 0 + ): + raise Exception("Under Flow!") + + if len(self.queue[0]) != 0: + return self.queue[0].pop(0) + elif len(self.queue[1]) != 0: + return self.queue[1].pop(0) + else: + return self.queue[2].pop(0) + + def print_queue(self): + """ + Prints each priority queue within the FixedPriorityQueue + """ + print("Priority 0:", self.queue[0]) + print("Priority 1:", self.queue[1]) + print("Priority 2:", self.queue[2]) class ElementPriorityQueue: - """ - Element Priority Queue is the same as Fixed Priority Queue - The only difference being the value of the element itself is the priority - The rule for priorities are the same - The lowest integer has the highest priority. - Example: - priority(0) > priority(5) - priority(16) > priority(32) - You can change the priorities as per your need - - >>>EPQ = ElementPriorityQueue() - >>>EPQ.enqueue(10) - >>>EPQ.enqueue(70) - >>>EPQ.enqueue(100) - >>>EPQ.enqueue(1) - >>>EPQ.enqueue(5) - >>>EPQ.enqueue(7) - >>>EPQ.enqueue(4) - >>>EPQ.enqueue(64) - >>>EPQ.enqueue(128) - >>>EPQ.print_queue() - [10, 70, 100, 1, 5, 7, 4, 64, 128] - >>>print(EPQ.dequeue()) - 1 - >>>print(EPQ.dequeue()) - 4 - >>>print(EPQ.dequeue()) - 5 - >>>print(EPQ.dequeue()) - 7 - >>>print(EPQ.dequeue()) - 10 - >>>EPQ.print_queue() - [70, 100, 64, 128] - >>>print(EPQ.dequeue()) - 64 - >>>print(EPQ.dequeue()) - 70 - >>>print(EPQ.dequeue()) - 100 - >>>print(EPQ.dequeue()) - 128 - >>>print(EPQ.dequeue()) - Traceback (most recent call last): - File "Sample.py", line 132, in + """ + Element Priority Queue is the same as Fixed Priority Queue + The only difference being the value of the element itself is the priority + The rule for priorities are the same + The lowest integer has the highest priority. + Example: + priority(0) > priority(5) + priority(16) > priority(32) + You can change the priorities as per your need + + >>>EPQ = ElementPriorityQueue() + >>>EPQ.enqueue(10) + >>>EPQ.enqueue(70) + >>>EPQ.enqueue(100) + >>>EPQ.enqueue(1) + >>>EPQ.enqueue(5) + >>>EPQ.enqueue(7) + >>>EPQ.enqueue(4) + >>>EPQ.enqueue(64) + >>>EPQ.enqueue(128) + >>>EPQ.print_queue() + [10, 70, 100, 1, 5, 7, 4, 64, 128] + >>>print(EPQ.dequeue()) + 1 + >>>print(EPQ.dequeue()) + 4 + >>>print(EPQ.dequeue()) + 5 + >>>print(EPQ.dequeue()) + 7 + >>>print(EPQ.dequeue()) + 10 + >>>EPQ.print_queue() + [70, 100, 64, 128] + >>>print(EPQ.dequeue()) + 64 + >>>print(EPQ.dequeue()) + 70 + >>>print(EPQ.dequeue()) + 100 + >>>print(EPQ.dequeue()) + 128 + >>>print(EPQ.dequeue()) + Traceback (most recent call last): + File "Sample.py", line 132, in + print(EPQ.dequeue()) + File "Sample.py", line 100, in dequeue + raise Exception("Under Flow!") + Exception: Under Flow! + """ + + def __init__(self): + self.queue = [] + + def enqueue(self, data): + """ + This function enters the element into the ElementPriorityQueue based on its value + If the ElementPriorityQueue is full an Exception is raised saying Over Flow! + """ + if len(self.queue) == 100: + raise Exception("Over Flow!") + else: + self.queue.append(data) + + def dequeue(self): + """ + This function returns the highest priority element from the ElementPriorityQueue in FIFO fashion. + If the ElementPriorityQueue is empty and this function is called then an exception is raised saying Under Flow! + """ + if len(self.queue) == 0: + raise Exception("Under Flow!") + else: + data = min(self.queue) + self.queue.remove(data) + return data + + def print_queue(self): + """ + Prints all the elements within the Element Priority Queue + """ + print(self.queue) + + +def fixed_priority_queue(): + FPQ = FixedPriorityQueue() + FPQ.enqueue(0, 10) + FPQ.enqueue(1, 70) + FPQ.enqueue(0, 100) + FPQ.enqueue(2, 1) + FPQ.enqueue(2, 5) + FPQ.enqueue(1, 7) + FPQ.enqueue(2, 4) + FPQ.enqueue(1, 64) + FPQ.enqueue(0, 128) + FPQ.print_queue() + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + FPQ.print_queue() + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + + +def element_priority_queue(): + EPQ = ElementPriorityQueue() + EPQ.enqueue(10) + EPQ.enqueue(70) + EPQ.enqueue(100) + EPQ.enqueue(1) + EPQ.enqueue(5) + EPQ.enqueue(7) + EPQ.enqueue(4) + EPQ.enqueue(64) + EPQ.enqueue(128) + EPQ.print_queue() + print(EPQ.dequeue()) + print(EPQ.dequeue()) + print(EPQ.dequeue()) + print(EPQ.dequeue()) + print(EPQ.dequeue()) + EPQ.print_queue() + print(EPQ.dequeue()) + print(EPQ.dequeue()) + print(EPQ.dequeue()) + print(EPQ.dequeue()) print(EPQ.dequeue()) - File "Sample.py", line 100, in dequeue - raise Exception("Under Flow!") - Exception: Under Flow! - """ - - def __init__(self) -> None: - self.queue = [] - - def enqueue(self, data: int) -> None: - ''' - This function enters the element into the ElementPriorityQueue based on its value - If the ElementPriorityQueue is full an Exception is raised saying Over Flow! - ''' - if len(self.queue) == 100: - raise Exception("Over Flow!") - else: - self.queue.append(data) - - def dequeue(self) -> int: - ''' - This function returns the highest priority element from the ElementPriorityQueue in FIFO fashion. - If the ElementPriorityQueue is empty and this function is called then an exception is raised saying Under Flow! - ''' - if len(self.queue) == 0: - raise Exception("Under Flow!") - else: - data = min(self.queue) - self.queue.remove(data) - return data - - def print_queue(self) -> None: - ''' - Prints all the elements within the Element Priority Queue - ''' - print(self.queue) - - -def fixed_priority_queue() -> None: - FPQ = FixedPriorityQueue() - FPQ.enqueue(0, 10) - FPQ.enqueue(1, 70) - FPQ.enqueue(0, 100) - FPQ.enqueue(2, 1) - FPQ.enqueue(2, 5) - FPQ.enqueue(1, 7) - FPQ.enqueue(2, 4) - FPQ.enqueue(1, 64) - FPQ.enqueue(0, 128) - FPQ.print_queue() - print(FPQ.dequeue()) - print(FPQ.dequeue()) - print(FPQ.dequeue()) - print(FPQ.dequeue()) - print(FPQ.dequeue()) - FPQ.print_queue() - print(FPQ.dequeue()) - print(FPQ.dequeue()) - print(FPQ.dequeue()) - print(FPQ.dequeue()) - print(FPQ.dequeue()) - - -def element_priority_queue() -> None: - EPQ = ElementPriorityQueue() - EPQ.enqueue(10) - EPQ.enqueue(70) - EPQ.enqueue(100) - EPQ.enqueue(1) - EPQ.enqueue(5) - EPQ.enqueue(7) - EPQ.enqueue(4) - EPQ.enqueue(64) - EPQ.enqueue(128) - EPQ.print_queue() - print(EPQ.dequeue()) - print(EPQ.dequeue()) - print(EPQ.dequeue()) - print(EPQ.dequeue()) - print(EPQ.dequeue()) - EPQ.print_queue() - print(EPQ.dequeue()) - print(EPQ.dequeue()) - print(EPQ.dequeue()) - print(EPQ.dequeue()) - print(EPQ.dequeue()) - if __name__ == "__main__": - fixed_priority_queue() - element_priority_queue() + fixed_priority_queue() + element_priority_queue() From 9c17c2cef7977b8ca5dab85d5da7714cf5a5f286 Mon Sep 17 00:00:00 2001 From: Ashley Jeji George <40469421+Ashley-J-George@users.noreply.github.com> Date: Tue, 15 Sep 2020 13:23:02 +0530 Subject: [PATCH 05/10] Update priority_queue.py Removed unwanted white spaces Kept the max char in a line under 88 char Added the suggested if condition for underflow Added the ellipse(...) instead of the entire traceback --- data_structures/queue/priority_queue.py | 125 +++++++++++------------- 1 file changed, 59 insertions(+), 66 deletions(-) diff --git a/data_structures/queue/priority_queue.py b/data_structures/queue/priority_queue.py index 117ef2508a3f..16c56efe2cee 100644 --- a/data_structures/queue/priority_queue.py +++ b/data_structures/queue/priority_queue.py @@ -6,7 +6,8 @@ class FixedPriorityQueue: """ In a Priority Queue the elements are entred as an when the come - But while removing or deleting an element the highest priority element is deleted in FIFO fashion + But while removing or deleting an element the highest priority element is deleted + in FIFO fashion. Here the lowest integer has the highest priority. Example: priority(0) > priority(5) @@ -16,49 +17,45 @@ class FixedPriorityQueue: You can change the priorities as per your need Examples - >>>FPQ = FixedPriorityQueue() - >>>FPQ.enqueue(0, 10) - >>>FPQ.enqueue(1, 70) - >>>FPQ.enqueue(0, 100) - >>>FPQ.enqueue(2, 1) - >>>FPQ.enqueue(2, 5) - >>>FPQ.enqueue(1, 7) - >>>FPQ.enqueue(2, 4) - >>>FPQ.enqueue(1, 64) - >>>FPQ.enqueue(0, 128) - >>>FPQ.print_queue() + >>> FPQ = FixedPriorityQueue() + >>> FPQ.enqueue(0, 10) + >>> FPQ.enqueue(1, 70) + >>> FPQ.enqueue(0, 100) + >>> FPQ.enqueue(2, 1) + >>> FPQ.enqueue(2, 5) + >>> FPQ.enqueue(1, 7) + >>> FPQ.enqueue(2, 4) + >>> FPQ.enqueue(1, 64) + >>> FPQ.enqueue(0, 128) + >>> FPQ.print_queue() Priority 0: [10, 100, 128] - Priority 1: [70, 7, 64] - Priority 2: [1, 5, 4] - >>>print(FPQ.dequeue()) + Priority 1: [70, 7, 64] + Priority 2: [1, 5, 4] + >>> FPQ.dequeue() 10 - >>>print(FPQ.dequeue()) - 100 - >>>print(FPQ.dequeue()) + >>> FPQ.dequeue() + 100 + >>> FPQ.dequeue() 128 - >>>print(FPQ.dequeue()) + >>> FPQ.dequeue() 70 - >>>print(FPQ.dequeue()) + >>> FPQ.dequeue() 7 - >>>FPQ.print_queue() + >>> FPQ.print_queue() Priority 0: [] Priority 1: [64] Priority 2: [1, 5, 4] - >>>print(FPQ.dequeue()) + >>> FPQ.dequeue() 64 - >>>print(FPQ.dequeue()) + >>> FPQ.dequeue() 1 - >>>print(FPQ.dequeue()) + >>> FPQ.dequeue() 5 - >>>print(FPQ.dequeue()) + >>> FPQ.dequeue() 4 - >>>print(FPQ.dequeue()) + >>> print(FPQ.dequeue()) Traceback (most recent call last): - File "Sample.py", line 117, in - print(FPQ.dequeue()) - File "Sample.py", line 58, in dequeue - raise Exception("Under Flow!") - Exception: Under Flow! + ... """ def __init__(self): @@ -83,14 +80,12 @@ def enqueue(self, priority, data): def dequeue(self): """ - This function returns the highest priority element from the FixedPriorityQueue in FIFO fashion - If the FixedPriorityQueue is empty and this function is called then an exception is raised saying Under Flow! + This function returns the highest priority element from the FixedPriorityQueue + in FIFO fashion + If the FixedPriorityQueue is empty and this function is called then an + exception is raised saying Under Flow! """ - if ( - len(self.queue[0]) == 0 - and len(self.queue[1]) == 0 - and len(self.queue[2]) == 0 - ): + if not self.queue[0] and not self.queue[1] and not self.queue[2]: raise Exception("Under Flow!") if len(self.queue[0]) != 0: @@ -120,45 +115,41 @@ class ElementPriorityQueue: priority(16) > priority(32) You can change the priorities as per your need - >>>EPQ = ElementPriorityQueue() - >>>EPQ.enqueue(10) - >>>EPQ.enqueue(70) - >>>EPQ.enqueue(100) - >>>EPQ.enqueue(1) - >>>EPQ.enqueue(5) - >>>EPQ.enqueue(7) - >>>EPQ.enqueue(4) - >>>EPQ.enqueue(64) - >>>EPQ.enqueue(128) - >>>EPQ.print_queue() + >>> EPQ = ElementPriorityQueue() + >>> EPQ.enqueue(10) + >>> EPQ.enqueue(70) + >>> EPQ.enqueue(100) + >>> EPQ.enqueue(1) + >>> EPQ.enqueue(5) + >>> EPQ.enqueue(7) + >>> EPQ.enqueue(4) + >>> EPQ.enqueue(64) + >>> EPQ.enqueue(128) + >>> EPQ.print_queue() [10, 70, 100, 1, 5, 7, 4, 64, 128] - >>>print(EPQ.dequeue()) + >>> EPQ.dequeue() 1 - >>>print(EPQ.dequeue()) + >>> EPQ.dequeue() 4 - >>>print(EPQ.dequeue()) + >>> EPQ.dequeue() 5 - >>>print(EPQ.dequeue()) + >>> EPQ.dequeue() 7 - >>>print(EPQ.dequeue()) + >>> EPQ.dequeue() 10 - >>>EPQ.print_queue() + >>> EPQ.print_queue() [70, 100, 64, 128] - >>>print(EPQ.dequeue()) + >>> EPQ.dequeue() 64 - >>>print(EPQ.dequeue()) + >>> EPQ.dequeue() 70 - >>>print(EPQ.dequeue()) + >>> EPQ.dequeue() 100 - >>>print(EPQ.dequeue()) + >>> EPQ.dequeue() 128 >>>print(EPQ.dequeue()) Traceback (most recent call last): - File "Sample.py", line 132, in - print(EPQ.dequeue()) - File "Sample.py", line 100, in dequeue - raise Exception("Under Flow!") - Exception: Under Flow! + ... """ def __init__(self): @@ -176,8 +167,10 @@ def enqueue(self, data): def dequeue(self): """ - This function returns the highest priority element from the ElementPriorityQueue in FIFO fashion. - If the ElementPriorityQueue is empty and this function is called then an exception is raised saying Under Flow! + This function returns the highest priority element from the ElementPriorityQueue + in FIFO fashion. + If the ElementPriorityQueue is empty and this function is called then an + exception is raised saying Under Flow! """ if len(self.queue) == 0: raise Exception("Under Flow!") From 738feefb3212bd83304c99be5cbc866ea4242ef2 Mon Sep 17 00:00:00 2001 From: Ashley Jeji George <40469421+Ashley-J-George@users.noreply.github.com> Date: Tue, 15 Sep 2020 16:33:13 +0530 Subject: [PATCH 06/10] Update priority_queue.py Added the proposed changes --- data_structures/queue/priority_queue.py | 470 ++++++++++++------------ 1 file changed, 241 insertions(+), 229 deletions(-) diff --git a/data_structures/queue/priority_queue.py b/data_structures/queue/priority_queue.py index 16c56efe2cee..d95c9136bd3f 100644 --- a/data_structures/queue/priority_queue.py +++ b/data_structures/queue/priority_queue.py @@ -3,239 +3,251 @@ """ +class Error(Exception): + """Base class for exceptions in this module.""" + pass + + +class OverFlow(Error): + def __init__(self, msg) -> None: + self.msg = msg + + +class UnderFlow(Error): + def __init__(self, msg) -> None: + self.msg = msg + + class FixedPriorityQueue: - """ - In a Priority Queue the elements are entred as an when the come - But while removing or deleting an element the highest priority element is deleted - in FIFO fashion. - Here the lowest integer has the highest priority. - Example: - priority(0) > priority(5) - priority(16) > priority(32) - Here as an example I have taken only 3 priorities viz. 0, 1, 2 - 0 Being the highest priority and 2 being the lowest - You can change the priorities as per your need - - Examples - >>> FPQ = FixedPriorityQueue() - >>> FPQ.enqueue(0, 10) - >>> FPQ.enqueue(1, 70) - >>> FPQ.enqueue(0, 100) - >>> FPQ.enqueue(2, 1) - >>> FPQ.enqueue(2, 5) - >>> FPQ.enqueue(1, 7) - >>> FPQ.enqueue(2, 4) - >>> FPQ.enqueue(1, 64) - >>> FPQ.enqueue(0, 128) - >>> FPQ.print_queue() - Priority 0: [10, 100, 128] - Priority 1: [70, 7, 64] - Priority 2: [1, 5, 4] - >>> FPQ.dequeue() - 10 - >>> FPQ.dequeue() - 100 - >>> FPQ.dequeue() - 128 - >>> FPQ.dequeue() - 70 - >>> FPQ.dequeue() - 7 - >>> FPQ.print_queue() - Priority 0: [] - Priority 1: [64] - Priority 2: [1, 5, 4] - >>> FPQ.dequeue() - 64 - >>> FPQ.dequeue() - 1 - >>> FPQ.dequeue() - 5 - >>> FPQ.dequeue() - 4 - >>> print(FPQ.dequeue()) - Traceback (most recent call last): - ... - """ - - def __init__(self): - self.queue = [ - [], - [], - [], - ] - - def enqueue(self, priority, data): - """ - This function enters the element into the FixedPriorityQueue based on its priority - If the priority is invalid an Exception is raised saying Invalid Priority! - If the FixedPriorityQueue is full an Exception is raised saying Over Flow! - """ - if priority > 2: - raise Exception("Invalid Priority!") - elif len(self.queue[priority]) == 100: - raise Exception("Over Flow!") - else: - self.queue[priority].append(data) - - def dequeue(self): - """ - This function returns the highest priority element from the FixedPriorityQueue - in FIFO fashion - If the FixedPriorityQueue is empty and this function is called then an - exception is raised saying Under Flow! - """ - if not self.queue[0] and not self.queue[1] and not self.queue[2]: - raise Exception("Under Flow!") - - if len(self.queue[0]) != 0: - return self.queue[0].pop(0) - elif len(self.queue[1]) != 0: - return self.queue[1].pop(0) - else: - return self.queue[2].pop(0) - - def print_queue(self): - """ - Prints each priority queue within the FixedPriorityQueue - """ - print("Priority 0:", self.queue[0]) - print("Priority 1:", self.queue[1]) - print("Priority 2:", self.queue[2]) + """ + In a Priority Queue the elements are entred as an when the come + But while removing or deleting an element the highest priority element is deleted + in FIFO fashion. + Here the lowest integer has the highest priority. + Example: + priority(0) > priority(5) + priority(16) > priority(32) + Here as an example I have taken only 3 priorities viz. 0, 1, 2 + 0 Being the highest priority and 2 being the lowest + You can change the priorities as per your need + + >>> FPQ = FixedPriorityQueue() + >>> FPQ.enqueue(0, 10) + >>> FPQ.enqueue(1, 70) + >>> FPQ.enqueue(0, 100) + >>> FPQ.enqueue(2, 1) + >>> FPQ.enqueue(2, 5) + >>> FPQ.enqueue(1, 7) + >>> FPQ.enqueue(2, 4) + >>> FPQ.enqueue(1, 64) + >>> FPQ.enqueue(0, 128) + >>> FPQ.print_queue() + Priority 0: [10, 100, 128] + Priority 1: [70, 7, 64] + Priority 2: [1, 5, 4] + >>> FPQ.dequeue() + 10 + >>> FPQ.dequeue() + 100 + >>> FPQ.dequeue() + 128 + >>> FPQ.dequeue() + 70 + >>> FPQ.dequeue() + 7 + >>> FPQ.print_queue() + Priority 0: [] + Priority 1: [64] + Priority 2: [1, 5, 4] + >>> FPQ.dequeue() + 64 + >>> FPQ.dequeue() + 1 + >>> FPQ.dequeue() + 5 + >>> FPQ.dequeue() + 4 + >>> FPQ.dequeue() + Traceback (most recent call last): + ... + Exception: Under Flow! + """ + + def __init__(self) -> None: + self.queue = [ + [], + [], + [], + ] + + def enqueue(self, priority: int, data: int) -> None: + """ + This function enters the element into the queue based on its priority + If the priority is invalid an Exception is raised saying Invalid Priority! + If the queue is full an Exception is raised saying Over Flow! + """ + if priority > 2: + raise Exception("Invalid Priority!") + elif len(self.queue[priority]) == 100: + raise OverFlow("Over Flow!") + else: + self.queue[priority].append(data) + + def dequeue(self) -> int: + """ + Return the highest priority element in FIFO order. + If the queue is empty then an under flow exception is raised. + """ + if not self.queue[0] and not self.queue[1] and not self.queue[2]: + raise UnderFlow("Under Flow!") + + if len(self.queue[0]) != 0: + return self.queue[0].pop(0) + elif len(self.queue[1]) != 0: + return self.queue[1].pop(0) + else: + return self.queue[2].pop(0) + + def print_queue(self) -> None: + """ + Prints each priority queue within the FixedPriorityQueue + """ + print("Priority 0:", self.queue[0]) + print("Priority 1:", self.queue[1]) + print("Priority 2:", self.queue[2]) class ElementPriorityQueue: - """ - Element Priority Queue is the same as Fixed Priority Queue - The only difference being the value of the element itself is the priority - The rule for priorities are the same - The lowest integer has the highest priority. - Example: - priority(0) > priority(5) - priority(16) > priority(32) - You can change the priorities as per your need - - >>> EPQ = ElementPriorityQueue() - >>> EPQ.enqueue(10) - >>> EPQ.enqueue(70) - >>> EPQ.enqueue(100) - >>> EPQ.enqueue(1) - >>> EPQ.enqueue(5) - >>> EPQ.enqueue(7) - >>> EPQ.enqueue(4) - >>> EPQ.enqueue(64) - >>> EPQ.enqueue(128) - >>> EPQ.print_queue() - [10, 70, 100, 1, 5, 7, 4, 64, 128] - >>> EPQ.dequeue() - 1 - >>> EPQ.dequeue() - 4 - >>> EPQ.dequeue() - 5 - >>> EPQ.dequeue() - 7 - >>> EPQ.dequeue() - 10 - >>> EPQ.print_queue() - [70, 100, 64, 128] - >>> EPQ.dequeue() - 64 - >>> EPQ.dequeue() - 70 - >>> EPQ.dequeue() - 100 - >>> EPQ.dequeue() - 128 - >>>print(EPQ.dequeue()) - Traceback (most recent call last): - ... - """ - - def __init__(self): - self.queue = [] - - def enqueue(self, data): - """ - This function enters the element into the ElementPriorityQueue based on its value - If the ElementPriorityQueue is full an Exception is raised saying Over Flow! - """ - if len(self.queue) == 100: - raise Exception("Over Flow!") - else: - self.queue.append(data) - - def dequeue(self): - """ - This function returns the highest priority element from the ElementPriorityQueue - in FIFO fashion. - If the ElementPriorityQueue is empty and this function is called then an - exception is raised saying Under Flow! - """ - if len(self.queue) == 0: - raise Exception("Under Flow!") - else: - data = min(self.queue) - self.queue.remove(data) - return data - - def print_queue(self): - """ - Prints all the elements within the Element Priority Queue - """ - print(self.queue) - - -def fixed_priority_queue(): - FPQ = FixedPriorityQueue() - FPQ.enqueue(0, 10) - FPQ.enqueue(1, 70) - FPQ.enqueue(0, 100) - FPQ.enqueue(2, 1) - FPQ.enqueue(2, 5) - FPQ.enqueue(1, 7) - FPQ.enqueue(2, 4) - FPQ.enqueue(1, 64) - FPQ.enqueue(0, 128) - FPQ.print_queue() - print(FPQ.dequeue()) - print(FPQ.dequeue()) - print(FPQ.dequeue()) - print(FPQ.dequeue()) - print(FPQ.dequeue()) - FPQ.print_queue() - print(FPQ.dequeue()) - print(FPQ.dequeue()) - print(FPQ.dequeue()) - print(FPQ.dequeue()) - print(FPQ.dequeue()) - - -def element_priority_queue(): - EPQ = ElementPriorityQueue() - EPQ.enqueue(10) - EPQ.enqueue(70) - EPQ.enqueue(100) - EPQ.enqueue(1) - EPQ.enqueue(5) - EPQ.enqueue(7) - EPQ.enqueue(4) - EPQ.enqueue(64) - EPQ.enqueue(128) - EPQ.print_queue() - print(EPQ.dequeue()) - print(EPQ.dequeue()) - print(EPQ.dequeue()) - print(EPQ.dequeue()) - print(EPQ.dequeue()) - EPQ.print_queue() - print(EPQ.dequeue()) - print(EPQ.dequeue()) - print(EPQ.dequeue()) - print(EPQ.dequeue()) - print(EPQ.dequeue()) + """ + Element Priority Queue is the same as Fixed Priority Queue + The only difference being the value of the element itself is the priority + The rule for priorities are the same + The lowest integer has the highest priority. + Example: + priority(0) > priority(5) + priority(16) > priority(32) + You can change the priorities as per your need + + >>> EPQ = ElementPriorityQueue() + >>> EPQ.enqueue(10) + >>> EPQ.enqueue(70) + >>> EPQ.enqueue(100) + >>> EPQ.enqueue(1) + >>> EPQ.enqueue(5) + >>> EPQ.enqueue(7) + >>> EPQ.enqueue(4) + >>> EPQ.enqueue(64) + >>> EPQ.enqueue(128) + >>> EPQ.print_queue() + [10, 70, 100, 1, 5, 7, 4, 64, 128] + >>> EPQ.dequeue() + 1 + >>> EPQ.dequeue() + 4 + >>> EPQ.dequeue() + 5 + >>> EPQ.dequeue() + 7 + >>> EPQ.dequeue() + 10 + >>> EPQ.print_queue() + [70, 100, 64, 128] + >>> EPQ.dequeue() + 64 + >>> EPQ.dequeue() + 70 + >>> EPQ.dequeue() + 100 + >>> EPQ.dequeue() + 128 + >>> EPQ.dequeue() + Traceback (most recent call last): + ... + Exception: Under Flow! + """ + + def __init__(self) -> None: + self.queue = [] + + def enqueue(self, data) -> None: + """ + This function enters the element into the queue + If the queue is full an Exception is raised saying Over Flow! + """ + if len(self.queue) == 100: + raise OverFlow("Over Flow!") + else: + self.queue.append(data) + + def dequeue(self) -> int: + """ + Return the highest priority element in FIFO order. + If the queue is empty then an under flow exception is raised. + """ + if len(self.queue) == 0: + raise UnderFlow("Under Flow!") + else: + data = min(self.queue) + self.queue.remove(data) + return data + + def print_queue(self) -> None: + """ + Prints all the elements within the Element Priority Queue + """ + print(self.queue) + + +def fixed_priority_queue() -> None: + FPQ = FixedPriorityQueue() + FPQ.enqueue(0, 10) + FPQ.enqueue(1, 70) + FPQ.enqueue(0, 100) + FPQ.enqueue(2, 1) + FPQ.enqueue(2, 5) + FPQ.enqueue(1, 7) + FPQ.enqueue(2, 4) + FPQ.enqueue(1, 64) + FPQ.enqueue(0, 128) + FPQ.print_queue() + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + FPQ.print_queue() + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + + +def element_priority_queue() -> None: + EPQ = ElementPriorityQueue() + EPQ.enqueue(10) + EPQ.enqueue(70) + EPQ.enqueue(100) + EPQ.enqueue(1) + EPQ.enqueue(5) + EPQ.enqueue(7) + EPQ.enqueue(4) + EPQ.enqueue(64) + EPQ.enqueue(128) + EPQ.print_queue() + print(EPQ.dequeue()) + print(EPQ.dequeue()) + print(EPQ.dequeue()) + print(EPQ.dequeue()) + print(EPQ.dequeue()) + EPQ.print_queue() + print(EPQ.dequeue()) + print(EPQ.dequeue()) + print(EPQ.dequeue()) + print(EPQ.dequeue()) + print(EPQ.dequeue()) if __name__ == "__main__": - fixed_priority_queue() - element_priority_queue() + fixed_priority_queue() + element_priority_queue() From 735390b5270a6015e12a4fdcc3c39d30adc6f8f8 Mon Sep 17 00:00:00 2001 From: Ashley Jeji George <40469421+Ashley-J-George@users.noreply.github.com> Date: Tue, 15 Sep 2020 18:23:28 +0530 Subject: [PATCH 07/10] Update priority_queue.py All indentation are spaces --- data_structures/queue/priority_queue.py | 476 ++++++++++++------------ 1 file changed, 244 insertions(+), 232 deletions(-) diff --git a/data_structures/queue/priority_queue.py b/data_structures/queue/priority_queue.py index d95c9136bd3f..0f8b005a086c 100644 --- a/data_structures/queue/priority_queue.py +++ b/data_structures/queue/priority_queue.py @@ -4,250 +4,262 @@ class Error(Exception): - """Base class for exceptions in this module.""" - pass + """Base class for exceptions in this module.""" + + pass class OverFlow(Error): - def __init__(self, msg) -> None: - self.msg = msg + def __init__(self, msg): + self.msg = msg class UnderFlow(Error): - def __init__(self, msg) -> None: - self.msg = msg + def __init__(self, msg): + self.msg = msg class FixedPriorityQueue: - """ - In a Priority Queue the elements are entred as an when the come - But while removing or deleting an element the highest priority element is deleted - in FIFO fashion. - Here the lowest integer has the highest priority. - Example: - priority(0) > priority(5) - priority(16) > priority(32) - Here as an example I have taken only 3 priorities viz. 0, 1, 2 - 0 Being the highest priority and 2 being the lowest - You can change the priorities as per your need - - >>> FPQ = FixedPriorityQueue() - >>> FPQ.enqueue(0, 10) - >>> FPQ.enqueue(1, 70) - >>> FPQ.enqueue(0, 100) - >>> FPQ.enqueue(2, 1) - >>> FPQ.enqueue(2, 5) - >>> FPQ.enqueue(1, 7) - >>> FPQ.enqueue(2, 4) - >>> FPQ.enqueue(1, 64) - >>> FPQ.enqueue(0, 128) - >>> FPQ.print_queue() - Priority 0: [10, 100, 128] - Priority 1: [70, 7, 64] - Priority 2: [1, 5, 4] - >>> FPQ.dequeue() - 10 - >>> FPQ.dequeue() - 100 - >>> FPQ.dequeue() - 128 - >>> FPQ.dequeue() - 70 - >>> FPQ.dequeue() - 7 - >>> FPQ.print_queue() - Priority 0: [] - Priority 1: [64] - Priority 2: [1, 5, 4] - >>> FPQ.dequeue() - 64 - >>> FPQ.dequeue() - 1 - >>> FPQ.dequeue() - 5 - >>> FPQ.dequeue() - 4 - >>> FPQ.dequeue() - Traceback (most recent call last): - ... - Exception: Under Flow! - """ - - def __init__(self) -> None: - self.queue = [ - [], - [], - [], - ] - - def enqueue(self, priority: int, data: int) -> None: - """ - This function enters the element into the queue based on its priority - If the priority is invalid an Exception is raised saying Invalid Priority! - If the queue is full an Exception is raised saying Over Flow! - """ - if priority > 2: - raise Exception("Invalid Priority!") - elif len(self.queue[priority]) == 100: - raise OverFlow("Over Flow!") - else: - self.queue[priority].append(data) - - def dequeue(self) -> int: - """ - Return the highest priority element in FIFO order. - If the queue is empty then an under flow exception is raised. - """ - if not self.queue[0] and not self.queue[1] and not self.queue[2]: - raise UnderFlow("Under Flow!") - - if len(self.queue[0]) != 0: - return self.queue[0].pop(0) - elif len(self.queue[1]) != 0: - return self.queue[1].pop(0) - else: - return self.queue[2].pop(0) - - def print_queue(self) -> None: - """ - Prints each priority queue within the FixedPriorityQueue - """ - print("Priority 0:", self.queue[0]) - print("Priority 1:", self.queue[1]) - print("Priority 2:", self.queue[2]) + """ + In a Priority Queue the elements are entred as an when the come + But while removing or deleting an element the highest priority element is deleted + in FIFO fashion. + Here the lowest integer has the highest priority. + Example: + priority(0) > priority(5) + priority(16) > priority(32) + Here as an example I have taken only 3 priorities viz. 0, 1, 2 + 0 Being the highest priority and 2 being the lowest + You can change the priorities as per your need + + Examples + >>> FPQ = FixedPriorityQueue() + >>> FPQ.enqueue(0, 10) + >>> FPQ.enqueue(1, 70) + >>> FPQ.enqueue(0, 100) + >>> FPQ.enqueue(2, 1) + >>> FPQ.enqueue(2, 5) + >>> FPQ.enqueue(1, 7) + >>> FPQ.enqueue(2, 4) + >>> FPQ.enqueue(1, 64) + >>> FPQ.enqueue(0, 128) + >>> FPQ.print_queue() + Priority 0: [10, 100, 128] + Priority 1: [70, 7, 64] + Priority 2: [1, 5, 4] + >>> FPQ.dequeue() + 10 + >>> FPQ.dequeue() + 100 + >>> FPQ.dequeue() + 128 + >>> FPQ.dequeue() + 70 + >>> FPQ.dequeue() + 7 + >>> FPQ.print_queue() + Priority 0: [] + Priority 1: [64] + Priority 2: [1, 5, 4] + >>> FPQ.dequeue() + 64 + >>> FPQ.dequeue() + 1 + >>> FPQ.dequeue() + 5 + >>> FPQ.dequeue() + 4 + >>> FPQ.dequeue() + Traceback (most recent call last): + ... + Exception: Under Flow! + """ + + def __init__(self): + self.queue = [ + [], + [], + [], + ] + + def enqueue(self, priority, data): + """ + This function enters the element into the queue based on its priority + If the priority is invalid an Exception is raised saying Invalid Priority! + If the queue is full an Exception is raised saying Over Flow! + """ + if priority > 2: + raise Exception("Invalid Priority!") + elif len(self.queue[priority]) == 100: + raise OverFlow("Over Flow!") + else: + self.queue[priority].append(data) + + def dequeue(self): + """ + Return the highest priority element in FIFO order. + If the queue is empty then an under flow exception is raised. + """ + if not self.queue[0] and not self.queue[1] and not self.queue[2]: + raise UnderFlow("Under Flow!") + + if len(self.queue[0]) != 0: + return self.queue[0].pop(0) + elif len(self.queue[1]) != 0: + return self.queue[1].pop(0) + else: + return self.queue[2].pop(0) + + def __str__(self): + """ + Prints each priority queue within the FixedPriorityQueue + """ + s = "" + for i in range(len(self.queue)): + for j in self.queue[i]: + s += "Priority " + str(i) + ": " + s += str(i) + " " + s += "\n" + print(s) + return s class ElementPriorityQueue: - """ - Element Priority Queue is the same as Fixed Priority Queue - The only difference being the value of the element itself is the priority - The rule for priorities are the same - The lowest integer has the highest priority. - Example: - priority(0) > priority(5) - priority(16) > priority(32) - You can change the priorities as per your need - - >>> EPQ = ElementPriorityQueue() - >>> EPQ.enqueue(10) - >>> EPQ.enqueue(70) - >>> EPQ.enqueue(100) - >>> EPQ.enqueue(1) - >>> EPQ.enqueue(5) - >>> EPQ.enqueue(7) - >>> EPQ.enqueue(4) - >>> EPQ.enqueue(64) - >>> EPQ.enqueue(128) - >>> EPQ.print_queue() - [10, 70, 100, 1, 5, 7, 4, 64, 128] - >>> EPQ.dequeue() - 1 - >>> EPQ.dequeue() - 4 - >>> EPQ.dequeue() - 5 - >>> EPQ.dequeue() - 7 - >>> EPQ.dequeue() - 10 - >>> EPQ.print_queue() - [70, 100, 64, 128] - >>> EPQ.dequeue() - 64 - >>> EPQ.dequeue() - 70 - >>> EPQ.dequeue() - 100 - >>> EPQ.dequeue() - 128 - >>> EPQ.dequeue() - Traceback (most recent call last): - ... - Exception: Under Flow! - """ - - def __init__(self) -> None: - self.queue = [] - - def enqueue(self, data) -> None: - """ - This function enters the element into the queue - If the queue is full an Exception is raised saying Over Flow! - """ - if len(self.queue) == 100: - raise OverFlow("Over Flow!") - else: - self.queue.append(data) - - def dequeue(self) -> int: - """ - Return the highest priority element in FIFO order. - If the queue is empty then an under flow exception is raised. - """ - if len(self.queue) == 0: - raise UnderFlow("Under Flow!") - else: - data = min(self.queue) - self.queue.remove(data) - return data - - def print_queue(self) -> None: - """ - Prints all the elements within the Element Priority Queue - """ - print(self.queue) - - -def fixed_priority_queue() -> None: - FPQ = FixedPriorityQueue() - FPQ.enqueue(0, 10) - FPQ.enqueue(1, 70) - FPQ.enqueue(0, 100) - FPQ.enqueue(2, 1) - FPQ.enqueue(2, 5) - FPQ.enqueue(1, 7) - FPQ.enqueue(2, 4) - FPQ.enqueue(1, 64) - FPQ.enqueue(0, 128) - FPQ.print_queue() - print(FPQ.dequeue()) - print(FPQ.dequeue()) - print(FPQ.dequeue()) - print(FPQ.dequeue()) - print(FPQ.dequeue()) - FPQ.print_queue() - print(FPQ.dequeue()) - print(FPQ.dequeue()) - print(FPQ.dequeue()) - print(FPQ.dequeue()) - print(FPQ.dequeue()) - - -def element_priority_queue() -> None: - EPQ = ElementPriorityQueue() - EPQ.enqueue(10) - EPQ.enqueue(70) - EPQ.enqueue(100) - EPQ.enqueue(1) - EPQ.enqueue(5) - EPQ.enqueue(7) - EPQ.enqueue(4) - EPQ.enqueue(64) - EPQ.enqueue(128) - EPQ.print_queue() - print(EPQ.dequeue()) - print(EPQ.dequeue()) - print(EPQ.dequeue()) - print(EPQ.dequeue()) - print(EPQ.dequeue()) - EPQ.print_queue() - print(EPQ.dequeue()) - print(EPQ.dequeue()) - print(EPQ.dequeue()) - print(EPQ.dequeue()) - print(EPQ.dequeue()) + """ + Element Priority Queue is the same as Fixed Priority Queue + The only difference being the value of the element itself is the priority + The rule for priorities are the same + The lowest integer has the highest priority. + Example: + priority(0) > priority(5) + priority(16) > priority(32) + You can change the priorities as per your need + + >>> EPQ = ElementPriorityQueue() + >>> EPQ.enqueue(10) + >>> EPQ.enqueue(70) + >>> EPQ.enqueue(100) + >>> EPQ.enqueue(1) + >>> EPQ.enqueue(5) + >>> EPQ.enqueue(7) + >>> EPQ.enqueue(4) + >>> EPQ.enqueue(64) + >>> EPQ.enqueue(128) + >>> EPQ.print_queue() + [10, 70, 100, 1, 5, 7, 4, 64, 128] + >>> EPQ.dequeue() + 1 + >>> EPQ.dequeue() + 4 + >>> EPQ.dequeue() + 5 + >>> EPQ.dequeue() + 7 + >>> EPQ.dequeue() + 10 + >>> EPQ.print_queue() + [70, 100, 64, 128] + >>> EPQ.dequeue() + 64 + >>> EPQ.dequeue() + 70 + >>> EPQ.dequeue() + 100 + >>> EPQ.dequeue() + 128 + >>> EPQ.dequeue() + Traceback (most recent call last): + ... + Exception: Under Flow! + """ + + def __init__(self): + self.queue = [] + + def enqueue(self, data): + """ + This function enters the element into the queue + If the queue is full an Exception is raised saying Over Flow! + """ + if len(self.queue) == 100: + raise OverFlow("Over Flow!") + else: + self.queue.append(data) + + def dequeue(self): + """ + Return the highest priority element in FIFO order. + If the queue is empty then an under flow exception is raised. + """ + if len(self.queue) == 0: + raise UnderFlow("Under Flow!") + else: + data = min(self.queue) + self.queue.remove(data) + return data + + def __str__(self): + """ + Prints all the elements within the Element Priority Queue + """ + s = "" + for i in self.queue: + s += str(i) + " " + return s + + +def fixed_priority_queue(): + FPQ = FixedPriorityQueue() + FPQ.enqueue(0, 10) + FPQ.enqueue(1, 70) + FPQ.enqueue(0, 100) + FPQ.enqueue(2, 1) + FPQ.enqueue(2, 5) + FPQ.enqueue(1, 7) + FPQ.enqueue(2, 4) + FPQ.enqueue(1, 64) + FPQ.enqueue(0, 128) + str(FPQ) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + str(FPQ) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + print(FPQ.dequeue()) + + +def element_priority_queue(): + EPQ = ElementPriorityQueue() + EPQ.enqueue(10) + EPQ.enqueue(70) + EPQ.enqueue(100) + EPQ.enqueue(1) + EPQ.enqueue(5) + EPQ.enqueue(7) + EPQ.enqueue(4) + EPQ.enqueue(64) + EPQ.enqueue(128) + str(EPQ) + print(EPQ) + print(EPQ.dequeue()) + print(EPQ.dequeue()) + print(EPQ.dequeue()) + print(EPQ.dequeue()) + print(EPQ.dequeue()) + str(EPQ) + print(EPQ) + print(EPQ.dequeue()) + print(EPQ.dequeue()) + print(EPQ.dequeue()) + print(EPQ.dequeue()) + print(EPQ.dequeue()) if __name__ == "__main__": - fixed_priority_queue() - element_priority_queue() + fixed_priority_queue() + element_priority_queue() From 670887ecf293e40aa47b48e528e6372b377281b8 Mon Sep 17 00:00:00 2001 From: Ashley Jeji George <40469421+Ashley-J-George@users.noreply.github.com> Date: Tue, 15 Sep 2020 20:02:22 +0530 Subject: [PATCH 08/10] Update priority_queue.py --- data_structures/queue/priority_queue.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/data_structures/queue/priority_queue.py b/data_structures/queue/priority_queue.py index 0f8b005a086c..806ade8fe9d5 100644 --- a/data_structures/queue/priority_queue.py +++ b/data_structures/queue/priority_queue.py @@ -110,6 +110,11 @@ def dequeue(self): else: return self.queue[2].pop(0) + def print_queue(self): + print("Priority 0:", self.queue[0]) + print("Priority 1:", self.queue[1]) + print("Priority 2:", self.queue[2]) + def __str__(self): """ Prints each priority queue within the FixedPriorityQueue @@ -198,6 +203,9 @@ def dequeue(self): self.queue.remove(data) return data + def print_queue(self): + print(self.queue) + def __str__(self): """ Prints all the elements within the Element Priority Queue From a5a13d27f909d669dbdf8c31ebf7c796182430b8 Mon Sep 17 00:00:00 2001 From: Ashley Jeji George <40469421+Ashley-J-George@users.noreply.github.com> Date: Tue, 15 Sep 2020 20:14:49 +0530 Subject: [PATCH 09/10] Update priority_queue.py --- data_structures/queue/priority_queue.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/data_structures/queue/priority_queue.py b/data_structures/queue/priority_queue.py index 806ade8fe9d5..646c9cc6ecf3 100644 --- a/data_structures/queue/priority_queue.py +++ b/data_structures/queue/priority_queue.py @@ -72,7 +72,7 @@ class FixedPriorityQueue: >>> FPQ.dequeue() Traceback (most recent call last): ... - Exception: Under Flow! + priority_queue.UnderFlow: Under Flow! """ def __init__(self): @@ -175,7 +175,7 @@ class ElementPriorityQueue: >>> EPQ.dequeue() Traceback (most recent call last): ... - Exception: Under Flow! + priority_queue.UnderFlow: Under Flow! """ def __init__(self): From 8726046d2f2f83928a97a1ecea0909b607de4fd7 Mon Sep 17 00:00:00 2001 From: Ashley Jeji George <40469421+Ashley-J-George@users.noreply.github.com> Date: Tue, 15 Sep 2020 20:23:29 +0530 Subject: [PATCH 10/10] Update priority_queue.py --- data_structures/queue/priority_queue.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/data_structures/queue/priority_queue.py b/data_structures/queue/priority_queue.py index 646c9cc6ecf3..f548867195d8 100644 --- a/data_structures/queue/priority_queue.py +++ b/data_structures/queue/priority_queue.py @@ -71,7 +71,7 @@ class FixedPriorityQueue: 4 >>> FPQ.dequeue() Traceback (most recent call last): - ... + ... priority_queue.UnderFlow: Under Flow! """ @@ -174,7 +174,7 @@ class ElementPriorityQueue: 128 >>> EPQ.dequeue() Traceback (most recent call last): - ... + ... priority_queue.UnderFlow: Under Flow! """