Initial Commit

Author: dev-sire

Algorithms/BubbleSort.py

@@ -0,0 +1,19 @@
+def bubble_sort(arr):
+    # Outer loop to iterate through the list n times
+    for n in range(len(arr) - 1, 0, -1):
+        # Inner loop to compare adjacent elements
+        for i in range(n):
+            if arr[i] > arr[i + 1]:
+                # Swap elements if they are in the wrong order
+                swapped = True
+                arr[i], arr[i + 1] = arr[i + 1], arr[i]
+
+# Sample list to be sorted
+arr = [39, 12, 18, 85, 72, 10, 2, 18]
+print("Unsorted list is:")
+print(arr)
+
+bubble_sort(arr)
+
+print("Sorted list is:")
+print(arr)

Algorithms/IterativeBinarySearch.py

@@ -0,0 +1,36 @@
+def binary_search(arr, x):
+	low = 0
+	high = len(arr) - 1
+	mid = 0
+
+	while low <= high:
+
+		mid = (high + low) // 2
+
+		# If x is greater, ignore left half
+		if arr[mid] < x:
+			low = mid + 1
+
+		# If x is smaller, ignore right half
+		elif arr[mid] > x:
+			high = mid - 1
+
+		# means x is present at mid
+		else:
+			return mid
+
+	# If we reach here, then the element was not present
+	return -1
+
+
+# Test array
+arr = [ 2, 3, 4, 10, 40 ]
+x = 10
+
+# Function call
+result = binary_search(arr, x)
+
+if result != -1:
+	print("Element is present at index", str(result))
+else:
+	print("Element is not present in array")

Algorithms/LinearSearchIterative.py

@@ -0,0 +1,20 @@
+def linear_search(arr, target):
+    # Traverse through all elements in the array
+    for index in range(len(arr)):
+        # If the element is found, return its index
+        if arr[index] == target:
+            return index
+    # If the element is not found, return -1
+    return -1
+
+# Example usage:
+arr = [10, 23, 45, 70, 11, 15]
+target = 70
+
+# Function call
+result = linear_search(arr, target)
+
+if result != -1:
+    print(f"Element found at index: {result}")
+else:
+    print("Element not found in the array")

Algorithms/LinearSearchRecursive.py

@@ -0,0 +1,22 @@
+def linear_search_recursive(arr, target, index=0):
+    # Base case: If index reaches the end of the list
+    if index == len(arr):
+        return -1  # Target not found
+    
+    # If the target is found at the current index
+    if arr[index] == target:
+        return index  # Return the index of the target
+    
+    # Recursive call to check the next element
+    return linear_search_recursive(arr, target, index + 1)
+
+# Example usage
+arr = [10, 20, 30, 40, 50]
+target = 30
+
+result = linear_search_recursive(arr, target)
+
+if result != -1:
+    print(f"Element {target} found at index {result}.")
+else:
+    print(f"Element {target} not found in the list.")

Algorithms/MergeSort.py

@@ -0,0 +1,68 @@
+def merge(arr, l, m, r):
+    n1 = m - l + 1
+    n2 = r - m
+ 
+    # create temp arrays
+    L = [0] * (n1)
+    R = [0] * (n2)
+ 
+    # Copy data to temp arrays L[] and R[]
+    for i in range(0, n1):
+        L[i] = arr[l + i]
+ 
+    for j in range(0, n2):
+        R[j] = arr[m + 1 + j]
+ 
+    # Merge the temp arrays back into arr[l..r]
+    i = 0     # Initial index of first subarray
+    j = 0     # Initial index of second subarray
+    k = l     # Initial index of merged subarray
+ 
+    while i < n1 and j < n2:
+        if L[i] <= R[j]:
+            arr[k] = L[i]
+            i += 1
+        else:
+            arr[k] = R[j]
+            j += 1
+        k += 1
+ 
+    # Copy the remaining elements of L[], if there are any
+    while i < n1:
+        arr[k] = L[i]
+        i += 1
+        k += 1
+ 
+    # Copy the remaining elements of R[], if there are any
+    while j < n2:
+        arr[k] = R[j]
+        j += 1
+        k += 1
+
+# l is for left index and r is right index of the
+# sub-array of arr to be sorted
+ 
+def mergeSort(arr, l, r):
+    if l < r:
+ 
+        # Same as (l+r)//2, but avoids overflow for
+        # large l and h
+        m = l+(r-l)//2
+ 
+        # Sort first and second halves
+        mergeSort(arr, l, m)
+        mergeSort(arr, m+1, r)
+        merge(arr, l, m, r)
+ 
+ 
+# Driver code to test above
+arr = [12, 11, 13, 5, 6, 7]
+n = len(arr)
+print("Given array is")
+for i in range(n):
+    print("%d" % arr[i],end=" ")
+ 
+mergeSort(arr, 0, n-1)
+print("\n\nSorted array is")
+for i in range(n):
+    print("%d" % arr[i],end=" ")

Algorithms/QuickSort.py

@@ -0,0 +1,44 @@
+def partition(array, low, high):
+    # choose the rightmost element as pivot
+    pivot = array[high]
+
+    # pointer for greater element
+    i = low - 1
+
+    # traverse through all elements compare each element with pivot
+    for j in range(low, high):
+        if array[j] <= pivot:
+
+            # If element smaller than pivot is found swap it with the greater element pointed by i
+            i = i + 1
+
+            # Swapping element at i with element at j
+            (array[i], array[j]) = (array[j], array[i])
+
+    # Swap the pivot element with the greater element specified by i
+    (array[i + 1], array[high]) = (array[high], array[i + 1])
+
+    # Return the position from where partition is done
+    return i + 1
+
+def quickSort(array, low, high):
+    if low < high:
+        # Find pivot element such that element smaller than pivot are on the left element greater than pivot are on the right
+        pi = partition(array, low, high)
+
+        # Recursive call on the left of pivot
+        quickSort(array, low, pi - 1)
+
+        # Recursive call on the right of pivot
+        quickSort(array, pi + 1, high)
+
+data = [1, 7, 4, 1, 10, 9, -2]
+print("Unsorted Array")
+print(data)
+
+size = len(data)
+
+quickSort(data, 0, size - 1)
+
+print('Sorted Array in Ascending Order:')
+print(data)

Algorithms/RecursiveBinarySearch.py

@@ -0,0 +1,34 @@
+def binary_search(arr, low, high, x):
+	# Check base case
+	if high >= low:
+
+		mid = (high + low) // 2
+
+		# If element is present at the middle itself
+		if arr[mid] == x:
+			return mid
+
+		# If element is smaller than mid, then it can only
+		# be present in left subarray
+		elif arr[mid] > x:
+			return binary_search(arr, low, mid - 1, x)
+
+		# Else the element can only be present in right subarray
+		else:
+			return binary_search(arr, mid + 1, high, x)
+
+	else:
+		# Element is not present in the array
+		return -1
+
+# Test array
+arr = [ 2, 3, 4, 10, 40 ]
+x = 10
+
+# Function call
+result = binary_search(arr, 0, len(arr)-1, x)
+
+if result != -1:
+	print("Element is present at index", str(result))
+else:
+	print("Element is not present in array")

Algorithms/SelectionSort.py

@@ -0,0 +1,16 @@
+def selectionSort(array, size):
+	for ind in range(size):
+		min_index = ind
+
+		for j in range(ind + 1, size):
+			# select the minimum element in every iteration
+			if array[j] < array[min_index]:
+				min_index = j
+		# swapping the elements to sort the array
+		(array[ind], array[min_index]) = (array[min_index], array[ind])
+
+arr = [-2, 45, 0, 11, -9,88,-97,-202,747]
+size = len(arr)
+selectionSort(arr, size)
+print('The array after sorting in Ascending Order by selection sort is:')
+print(arr)

Data Structures/BinarySearchTree.py

@@ -0,0 +1,106 @@
+class Tree:
+    def __init__(self, val=None) -> None:
+        self.value = val
+
+        if self.value:
+            self.left = Tree()
+            self.right = Tree()
+        else:
+            self.left = None
+            self.right = None
+    
+    def isEmpty(self):
+        return (self.value == None)
+
+    def isleaf(self):
+        # Check if the tree node is a leaf node (both left and right children are None)
+        if self.left.left == None and self.right.right == None:
+            return True
+        else:
+            return False
+    
+    def insert(self, data):
+        if self.isempty():
+            # If the current node is empty, insert the data as its value
+            self.value = data
+            # Create empty left and right children
+            self.left = Tree()
+            self.right = Tree()
+        elif self.value == data:
+            # If the data already exists in the tree, return
+            return
+        elif data < self.value:
+            # If the data is less than the current node's value, insert it into the left subtree
+            self.left.insert(data)
+            return
+        elif data > self.value:
+            # If the data is greater than the current node's value, insert it into the right subtree
+            self.right.insert(data)
+            return
+        
+    def find(self, v):
+        if self.isEmpty():
+            print("{} is not found".format(v))
+            return False
+        if self.value == v:
+            print("{} is found".format(v))
+            return True
+        if v < self.value:
+            return self.left.find(v)
+        else:
+            return self.right.find(v)
+        
+    def inorder(self):
+        if self.isempty():
+            # If the tree is empty, return an empty list
+            return []
+        else:
+            # Return the inorder traversal of the tree (left subtree, root, right subtree)
+            return self.left.inorder() + [self.value] + self.right.inorder()
+        
+    def maxval(self):
+        # Find the maximum value in the Tree
+        if self.right.right == None:
+            return (self.value)
+        else:
+            return (self.right.maxval())
+    
+    def delete(self, v):
+    # Delete a value from the Tree
+        if self.isempty():
+            return
+        if v < self.value:
+            self.left.delete(v)
+            return
+        if v > self.value:
+            self.right.delete(v)
+            return
+        if v == self.value:
+            if self.isleaf():
+                self.value = None
+                self.left = None
+                self.right = None
+                return
+            elif self.left.isempty():
+                self.value = self.right.value
+                self.left = self.right.left
+                self.right = self.right.right
+                return
+            else:
+                self.value = self.left.maxval()
+                self.left.delete(self.left.maxval())
+                return
+            
+# Test the Tree class
+t = Tree(15)
+t.insert(10)
+t.insert(18)
+t.insert(4)
+t.insert(11)
+t.insert(16)
+t.insert(20)
+print("Before deleting 4: ")
+print(t.inorder())
+t.delete(4)
+print("After deleting 4: ")
+print(t.inorder())