Added queue using LL and radix sort programs.

Queue.py

@@ -0,0 +1,24 @@
+class Queue:
+    arr = []
+    def enqueue(self,item):
+        self.arr.append(item)
+
+    def dequeue(self):
+        if len(self.arr) > 0:
+            ditem = self.arr[0] 
+            del self.arr[0]
+            return ditem
+        else:
+            return #queue is empty
+
+    def dispaly(self):
+        print(self.arr)
+
+x = Queue() # Creating object of queue class
+x.enqueue(1) 
+x.enqueue(2) 
+x.dispaly() # arr = [1,2]
+x.dequeue() # Deleting the first element of the queue.
+x.dispaly() # arr = [2]
+print(x.dequeue()) # 2
+print(x.dequeue()) # None(because queue is already empty)

Queue_using_LL.py

@@ -0,0 +1,39 @@
+class Node:
+    def __init__(self, data = None):
+        self.data = data
+        self.next = None
+
+class Queue:
+    def __init__(self):
+        self.head = None
+        self.last = None
+
+    def enqueue(self, data):
+        if not self.last:
+            self.head = Node(data)
+            self.last = self.head
+        else:
+            self.last.next = Node(data)
+            self.last = self.last.next
+
+    def dequeue(self):
+        if not self.head:
+            return None
+        val = self.head.data
+        self.head = self.head.next
+        return val
+
+    def display(self):
+        temp = self.head
+        while temp != None:
+            print(temp.data)
+            temp = temp.next
+
+x = Queue() # Creating object of queue class
+x.enqueue(1) # Add 1 to the queue
+x.enqueue(2)# Add 2 to the queue
+x.display() # 1 => 2
+print(x.dequeue()) # Deleting the first element of the queue.
+x.display() # 2
+print(x.dequeue()) # 2
+print(x.dequeue()) # None(because queue is already empty)

Radix_sort.py

@@ -0,0 +1,43 @@
+# Radix sort in Python
+# Using counting sort to sort the elements in the basis of significant places
+def countingSort(array, place):
+    size = len(array)
+    output = [0] * size
+    count = [0] * 10
+
+    # Calculate count of elements
+    for i in range(0, size):
+        index = array[i] // place
+        count[index % 10] += 1
+
+    # Calculate cumulative count
+    for i in range(1, 10):
+        count[i] += count[i - 1]
+
+    # Place the elements in sorted order
+    i = size - 1
+    while i >= 0:
+        index = array[i] // place
+        output[count[index % 10] - 1] = array[i]
+        count[index % 10] -= 1
+        i -= 1
+
+    for i in range(0, size):
+        array[i] = output[i]
+
+
+# Main function to implement radix sort
+def radixSort(array):
+    # Get maximum element
+    max_element = max(array)
+
+    # Apply counting sort to sort elements based on place value.
+    place = 1
+    while max_element // place > 0:
+        countingSort(array, place)
+        place *= 10
+
+
+data = [121, 432, 564, 23, 1, 45, 788]
+radixSort(data)
+print(data)