Merge pull request #222 from Iamtripathisatyam/main

Priority Queue

Author: prathimacode-hub

Graphs/Breadth First Search/README.md

@@ -2,7 +2,7 @@
 Two techniques are frequently used for graph traversal: These techniques are called depth-first search (DFS) and breadth-first search (BFS), although we will just talk about BFS. Breadth-first search (BFS) is used to solve many problems, including finding the shortest path in a graph or solving puzzle games such as Rubik’s Cubes.
 
 ## What is Breadth First Search in Python?
-Breadth-first search (BFS) is an algorithm for traversing graphs or trees. Breath-first search for trees and graphs are almost the same. BFS uses a queue data structure for finding the shortest path in a graph.
+Breadth-first search (BFS) is an algorithm for traversing graphs or trees. Breath-first search for trees and graphs are almost the same. BFS uses a queue data structure for finding the shortest path in a graph. We use queue to get the next vertex to start the search, and the visited array is used to mark all the nodes that have been visited, so when it appears again, we will perform BFS on that node.
 
 ## Algorithm of DFS in Python
 The algorithm works as follows:
@@ -18,6 +18,12 @@ The algorithm works as follows:
 * Time complexity is `O(V+E)`, where V denotes the number of vertices and E denotes the number of edges. 
 * Space complexity is `O(V)`.
 
+## Applications of Breadth First Search
+* Crawlers in Search Engines
+* Peer-to-Peer Networking
+* GPS Navigation Systems
+* Ford-Fulkerson algorithm
+
 ## Input & Output
 ### Input:
 

Queues/Priority Queue/Images/hey

@@ -0,0 +1 @@
+

Queues/Priority Queue/Images/priority.jpg

@@ -0,0 +1,36 @@
+<p align='center'>
+<img width=60% src="../Priority Queue/Images/priority.jpg">
+</p>
+
+## Overview:
+A unique kind of queue called a priority queue has elements that are each assigned a priority value. Additionally, components are treated according to their importance. In other words, more important factors come first.
+
+## What is Priority Queue?
+There must be a priority assigned to each item in the queue.
+Depending on the priority order chosen by the user—that is, whether the user considers a lower number to be higher priority or a higher number to be greater priority—higher or lower priority items must be dequeued before lower or higher priority elements, respectively.
+The first element that entered the priority queue first will be the first to be deleted if two items in the queue have the same priority value. This is known as the first in, first out, rule.
+
+## Types of Priority Queue
+#### Ascending Order Priority Queue:
+The items in the priority queue must be similar, which means they must be either less than, equal to, or higher than one another, as was previously stated. All the components are compared to one another in an ascending order priority queue according to the following rule. The priority is applied with a higher priority to smaller elements (or numbers).
+
+#### Descending Order Priority Queue:
+All the components are compared to one another in descending order priority queue according to the following rule. The priority increases with the size of the element (or number). Eaual to one another or larger than it. All the components are compared to one another in an ascending order priority queue according to the following rule. The priority is applied with a higher priority to smaller elements (or numbers).
+
+## Why are Heaps preferred over Binary Search Trees?
+While the Self Balancing BST requires O(nLogn) time, heap construction may be completed in O(N) time. Pointers are not used anymore since heaps are built via arrays.
+
+## Application of Priority Queue
+* Djikstra's Algorithm uses t to determine the shortest route between graph nodes.
+* In order to determine the Minimum Spanning Tree in a weighted undirected graph, it is employed in Prim's Algorithm.
+* Heap Sort uses it to order the heap data structure.
+* It is employed in the data compression algorithm Huffman Coding.
+
+## Complexity of Priority queue
+#### Time complexity:
+* Insertion : O(log n)O(logn)
+* Peek : O(1)O(1)
+* Deletion : O(log n)O(logn)
+
+## Read More
+To read more: [Click here](https://www.scaler.com/topics/data-structures/priority-queue-in-data-structure/)

Queues/Priority Queue/README.md

@@ -0,0 +1,60 @@
+# To heapify
+def heapify(array, num, x):
+    # Find the largest among root, left child and right child
+    max = x
+    left = 2 * x + 1
+    right = 2 * x + 2
+
+    if left < num and array[x] < array[left]:
+        max = left
+
+    if right < num and array[max] < array[right]:
+        max = right
+
+    # If root is not largest, swap and continue heapifying
+    if max != x:
+        array[x], array[max] = array[max], array[x]
+        heapify(array, num, max)
+
+
+# To insert an element
+def insert(nums, next):
+    s = len(nums)
+    if s == 0:
+        nums.append(next)
+    else:
+        nums.append(next)
+        for i in range((s // 2) - 1, -1, -1):
+            heapify(nums, s, i)
+
+
+# To delete an element
+def delete(nums, n):
+    s = len(nums)
+    i = 0
+    for i in range(0, s):
+        if n == nums[i]:
+            break
+
+    nums[i], nums[s - 1] = nums[s - 1], nums[i]
+
+    nums.remove(s - 1)
+
+    for i in range((len(nums) // 2) - 1, -1, -1):
+        heapify(nums, len(nums), i)
+
+
+array = []
+
+insert(array, 1)
+insert(array, 4)
+insert(array, 2)
+insert(array, 7)
+insert(array, 8)
+insert(array, 5)
+insert(array, 6)
+
+print("Max-Heap array: " + str(array))
+
+delete(array, 6)
+print("After deletion: " + str(array))