Sync Fork

Sync Fork

Author: ashwek

Arrays-Sorting/src/Bucket_Sort/Bucket_Sort.py

@@ -0,0 +1,38 @@
+"""
+Bucket sort, or bin sort, is a sorting algorithm that works by distributing
+the elements of an array into a number of buckets. Each bucket is then sorted
+individually, either using a different sorting algorithm, or by recursively
+applying the bucket sorting algorithm.
+
+https://en.wikipedia.org/wiki/Bucket_sort
+
+"""
+
+from random import randint
+
+def Bucket_Sort(A, Digit):
+	B = [[] for x in range(10)]   #Creating 10 Buckets [10 different lists at every position]
+	
+	#Storing elements in Bucket according to their first digit
+	for each in A: 
+		B[int(str(each).rjust(Digit, '0')[0])].append(each)
+	
+	#Sorting Buckets
+	for each in range(10):B[each].sort()
+	
+	A=[]
+	
+	#Assembling elements from all the buckets
+	for bucket in B:
+		for each in bucket:
+			A.append(each)
+	
+	return A
+	
+A = [randint(0,99) for x in range(15)] #Generate a random list 
+
+print("Orignal Array = ", A)
+
+A = Bucket_Sort(A, 2)
+
+print(" Sorted Array = ", A)

Arrays-searching/src/binary_search/binary_search.py

@@ -19,7 +19,7 @@ def binary_search(sorted_array, search_key):
         last_index = len(sorted_array) - 1
         found = False
         while first_index <= last_index and not found:
-            mid = (first_index + last_index) / 2
+            mid = (first_index + last_index) // 2
             if sorted_array[mid] == search_key:
                 found = True
                 break

Data_Structure/src/Queue.py

@@ -0,0 +1,66 @@
+class Queue:
+
+    def __init__(self, Size = 10):
+        self.__size = Size                #Store the size of the queue
+        self.__queue = [None]*Size        #generate a List of length "Size" containing None (initial value)
+        self.__head = self.__tail = 0     #Initial value of head & tail = 0
+        self.__i = -1                     # i is used as index in __next__ method to iterate through the Queue object
+
+    def isEmpty(self):
+        return self.__head == self.__tail    #If head == tail, Queue is empty
+
+    def isFull(self):
+        return self.__tail == self.__size    #if tail == size of queue, queue is full
+
+    def EnQueue(self, value):
+        if(self.isFull()): raise IndexError("Overflow Error - Queue is Full")
+        self.__queue[self.__tail] = value    #insert "value" at tail
+        self.__tail += 1                     #increment tail
+
+    def DeQueue(self):
+        if(self.isEmpty()): raise IndexError("Unerflow Error - Queue is Empty")
+        self.__head += 1                      #Increment head
+        return self.__queue[self.__head-1]    #Return value at head-1 (previous head = value to be deleted)
+
+    def __len__(self):
+        return self.__tail - self.__head    #return number of elements in the queue
+
+    def __getitem__(self, index):                                    # __getitem__ method is used to get element stored at a particular index
+        if(self.__head <= (index + self.__head) < self.__tail):      #if the index is valid (between head & tail)
+            return self.__queue[index + self.__head]                 #return the value
+        else: raise IndexError("Index out of range")                 #else raise error
+
+    # __next__ and __iter__ methods are used to iterate through the object (used internally at Line 58 in for loop to print all element)
+
+    # __next__ is used to get the next element in the iterable object
+    def __next__(self):
+        self.__i += 1        # i is the index of the element to return
+        if(self.__i < len(self)): return self.__getitem__(self.__i)    #use __getitem__ to get the value at index i
+        else: raise StopIteration()        # if i is larger than len, all the elements have been traversed, raise StopIteration to stop iteration
+
+    # __iter__ returns an iterable object (self) & sets i = -1, to iterate through 0 to end
+    def __iter__(self):
+        self.__i = -1
+        return self
+
+
+if __name__ == '__main__':
+
+    print("\nCreated Queue of size 5")
+    Q1 = Queue(5)
+
+    print("\nEnQueue (Insert) 5")
+    Q1.EnQueue(5)
+    print("EnQueue (Insert) 15")
+    Q1.EnQueue(15)
+
+    print("\nPrint Queue")
+    for i in Q1:
+        print(i, end=", ")
+
+    print("\n\nDeQueue (Delete), Deleted element = ", Q1.DeQueue())
+    print("DeQueue (Delete), Deleted element = ", Q1.DeQueue())
+
+    print("\nQueue empty\n")
+
+    print("\n\nDeQueue / Delete, Deleted element = ", Q1.DeQueue())		#This line raises error as the Queue is empty & cannot delete any element

Data_Structure/src/Queue_Circular.py

@@ -0,0 +1,72 @@
+class Queue_Circular:
+
+    def __init__(self, Size=10):
+        self.__size = Size+1              #Store Size+1 in size
+        self.__queue = [None]*(Size+1)    #generate a List of length "size" containing None (initial value)
+        self.__head = self.__tail = 0     #Initial value of head & tail = 0
+        self.__i = -1                     # i is used as index in __next__ method to iterate through the Queue object
+
+    def isEmpty(self):
+        return self.__head == self.__tail        #If head == tail, Queue is empty
+    def isFull(self):
+        return (self.__tail+1)%self.__size == self.__head    #if next tail (circular increment) == head, queue is full
+
+    def EnQueue(self, value):
+        if(self.isFull()): raise IndexError("Overflow Error - Queue is Full")
+        self.__queue[self.__tail] = value                #store "value" at tail
+        self.__tail = (self.__tail+1)%self.__size        #increment tail by 1 & mod size (circular increment)
+
+    def DeQueue(self):
+        if(self.isEmpty()): raise IndexError("Unerflow Error - Queue is Empty")
+        self.__head = (self.__head+1)%self.__size            # increment head (circular increment)
+        return self.__queue[(self.__head-1)%self.__size]     # Return value at head-1 (circular decrement) (previous head = value to be deleted)
+
+    #if tail > head, return tail - head
+    #else, return size - head + tail
+    def __len__(self):
+        return self.__tail-self.__head if(self.__tail>=self.__head) else self.__size-self.__head+self.__tail
+
+    # __getitem__ is used to get value at a particular index
+    def __getitem__(self, index):
+        if(0 <= index < len(self)):                                 #if index is between 0 & len of queue
+            return self.__queue[(index+self.__head)%self.__size]    #return the value at index
+        else: raise IndexError("Index out of range")                #else, raise exception
+
+    # __next__ and __iter__ methods are used to iterate through the object (used internally at Line 56 & 69 in for loop to print all element)
+
+    # __next__ is used to get the next element in the iterable object
+    def __next__(self):
+        self.__i += 1        # i is the index of the element to return
+        if(self.__i < len(self)): return self.__getitem__(self.__i)    #use __getitem__ to get the value at index i
+        else: raise StopIteration()        # if i is larger than len, all the elements have been traversed, raise StopIteration to stop iteration
+
+    # __iter__ returns an iterable object (self) & sets i = -1, to iterate through 0 to end
+    def __iter__(self):
+        self.__i = -1
+        return self
+
+if __name__ == '__main__':
+    print("\nCreate Circular Queue of size 5\n")
+    Q1 = Queue_Circular(5)
+
+    #insert 5, 10, 15, 20, 25 in Queue Q1
+    for i in range(5, 30, 5):
+        print("EnQueue (Insert) ", i)
+        Q1.EnQueue(i)
+
+    print("\nPrint Queue")
+    for i in Q1:
+        print(i, end=", ")
+
+    print("\n\nEnQueue (Insert) 30")
+    try: Q1.EnQueue(30)         #This raises error because the Queue is full
+    except IndexError: print("Queue is Full")
+
+    print("\nDeQueue (Delete), Deleted value = ", Q1.DeQueue())
+
+    print("\nEnQueue (Insert) 30")
+    Q1.EnQueue(30)
+
+    print("\nPrint Queue")
+    for i in Q1:
+        print(i, end=", ")

Data_Structure/src/Stack.py

@@ -0,0 +1,51 @@
+class Stack:
+	
+	def __init__(self, Size=10):
+		self.__size = Size
+		self.__stack=[]
+		self.__i=-1
+	
+	def isEmpty(self):
+		return len(self.__stack) == 0
+	def isFull(self):
+		return len(self.__stack) == self.__size
+	
+	def push(self, value):
+		if(self.isFull()): raise IndexError("Overflow Error - Stack is Full")
+		else: self.__stack.append(value)
+	
+	def pop(self):
+		if(self.isEmpty()): raise IndexError("Unerflow Error - Stack is Empty")
+		return self.__stack.pop()
+		
+	def __len__(self):
+		return len(self.__stack)
+			
+	def __next__(self):
+		self.__i+=1 
+		if(self.__i < len(self)): return self.__stack[self.__i]
+		else: raise StopIteration()
+		
+	def __iter__(self):
+		self.__i=-1
+		return self
+		
+if __name__ == '__main__':
+	print("Create stack of size 10")
+	S1 = Stack(10)
+	
+	print("\nPush 10 to stack")
+	S1.push(10)
+	print("Push 100 to stack")
+	S1.push(100)
+	
+	print("\nPrint stack")
+	for i in S1:
+		print(i, end=", ")
+	
+	print("\n\nPop Stack, Popped value = ", S1.pop())
+	print("Pop Stack, Popped value = ", S1.pop())
+	
+	print("\nStack is empty\n")
+	
+	print("\nPop Stack, Popped value = ", S1.pop())

Graph_Algorithms/src/Breadth_First_Traversal/BFS_Algo.py

@@ -0,0 +1,61 @@
+from collections import defaultdict
+
+# This class represents a directed graph
+# using adjacency list representation
+class Graph:
+
+	# Constructor
+	def __init__(self):
+
+		# default dictionary to store graph
+		self.graph = defaultdict(list)
+
+	# function to add an edge to graph
+	def addEdge(self,u,v):
+		self.graph[u].append(v)
+
+	# Function to print a BFS of graph
+	def BFS(self, s):
+
+		# Mark all the vertices as not visited
+		visited = [False] * (len(self.graph))
+
+		# Create a queue for BFS
+		queue = []
+
+		# Mark the source node as
+		# visited and enqueue it
+		queue.append(s)
+		visited[s] = True
+
+		while queue:
+
+			# Dequeue a vertex from
+			# queue and print it
+			s = queue.pop(0)
+			print (s, end = " ")
+
+			# Get all adjacent vertices of the
+			# dequeued vertex s. If a adjacent
+			# has not been visited, then mark it
+			# visited and enqueue it
+			for i in self.graph[s]:
+				if visited[i] == False:
+					queue.append(i)
+					visited[i] = True
+
+# Driver code
+
+# Create a graph given in
+# the above diagram
+g = Graph()
+g.addEdge(0, 1)
+g.addEdge(0, 2)
+g.addEdge(1, 2)
+g.addEdge(2, 0)
+g.addEdge(2, 3)
+g.addEdge(3, 3)
+
+print ("Following is Breadth First Traversal"
+				" (starting from vertex 2)")
+g.BFS(2)