Queue (#70)

* Create RandomizedQuick_Sort.md

* Create Queues.md

* Update Queues.md

Author: deepshikha2708

Queues/Queues.md

@@ -0,0 +1,40 @@
+# What are queues?
+
+Queues are lists where insertion is done at the end while the deletion is done at the front end. It follows the first in first out order(FIFO).
+
+# Operations on queue
+
+1. Enqueue- Inserts the element at the rear end of the list. 
+2. Dequeue- Deletes an element from the beginning of the list. 
+
+# Priority Queue
+
+Priority Queue is a queue where the elements of it have an associated priority with it.
+Every item has a priority associated with it.
+An element with high priority is dequeued before an element with low priority.
+If two elements have the same priority, they are served according to their order in the queue.
+
+# Types of Priority Queue
+
+1. Ascending Queue- In ascending order priority queue, the element with a lower priority value is given a higher priority in the priority list.
+
+2. Descending Queue- The root node is the maximum element in a max heap, as you may know. It will also remove the element with the highest priority first. 
+
+# Operations in a Priority Queue
+
+1. Insertion- When the element is inserted in a Priority Queue it is checked if the element is in the correct order or not. If not, elements are swapped.
+2. Deletion- Maximum element from the Max Heap is deleted.
+3. Peek- Returns the maximum element from Max Heap or the minimum element from Min Heap.
+
+# Circular Queue
+
+Circular Queue is a special version of queue where the last element of the queue is connected to the first element of the queue forming a circle.
+
+# Operations on Circular Queue
+
+1. Front- Get the front item from queue.
+2. Rear- Get the last item from queue.
+3. Enqueue- This function is used to insert an element into the circular queue at rear position.
+4. Dequeue- This function is used to delete an element from the circular queue from fron position.
+
+Ref. Taken- GeeksForGeeks

Sorting/RandomizedQuick_Sort.md

@@ -0,0 +1,103 @@
+## Description 
+
+In QuickSort we first partition the array in place such that all elements to the left of the pivot element are smaller, while all elements to the right of the pivot are greater than the pivot. Then we recursively call the same procedure for left and right subarrays. Using a randomly generated pivot we can further improve the time complexity of QuickSort.
+
+# Code
+
+```cpp
+#include <cstdlib>
+#include <time.h>
+#include <iostream>
+using namespace std;
+
+int partition(int arr[], int low, int high)
+{
+	// pivot
+	int pivot = arr[high];
+	
+	// Index of smaller element
+	int i = (low - 1);
+
+	for (int j = low; j <= high - 1; j++)
+	{
+		// If current element is smaller
+		// than or equal to pivot
+		if (arr[j] <= pivot) {
+
+			// increment index of
+			// smaller element
+			i++;
+			swap(arr[i], arr[j]);
+		}
+	}
+	swap(arr[i + 1], arr[high]);
+	return (i + 1);
+}
+
+// Generates Random Pivot, swaps pivot with
+// end element and calls the partition function
+int partition_r(int arr[], int low, int high)
+{
+	// Generate a random number in between
+	// low .. high
+	srand(time(NULL));
+	int random = low + rand() % (high - low);
+
+	// Swap A[random] with A[high]
+	swap(arr[random], arr[high]);
+
+	return partition(arr, low, high);
+}
+
+/* The main function that implements
+QuickSort
+arr[] --> Array to be sorted,
+low --> Starting index,
+high --> Ending index */
+void quickSort(int arr[], int low, int high)
+{
+	if (low < high) {
+
+		/* pi is partitioning index,
+		arr[p] is now
+		at right place */
+		int pi = partition_r(arr, low, high);
+
+		// Separately sort elements before
+		// partition and after partition
+		quickSort(arr, low, pi - 1);
+		quickSort(arr, pi + 1, high);
+	}
+}
+
+/* Function to print an array */
+void printArray(int arr[], int size)
+{
+	int i;
+	for (i = 0; i < size; i++)
+		cout<<arr[i]<<" ";
+}
+
+// Driver Code
+int main()
+{
+	int arr[] = { 10, 7, 8, 9, 1, 5 };
+	int n = sizeof(arr) / sizeof(arr[0]);
+	
+	quickSort(arr, 0, n - 1);
+	printf("Sorted array: \n");
+	printArray(arr, n);
+	
+	return 0;
+}
+```
+
+## Run Code
+https://ide.geeksforgeeks.org/bd2d6f18-3d4a-4ca0-a0a8-492c16d40c7e
+
+## Complexities
+### Time complexity   : 
+Best Case  : O(nlogn)  
+Worst Case : O(n^2) 
+### Space complexity  : 
+O(N)