added different implementations of data structures and algorithms

Author: oyerohabib

Data Structures and Algorithms/README.md

@@ -0,0 +1,29 @@
+# Data Structures and Algorithm Examples and Samples in Python
+
+## This repository contains different data structure and algorithm types in python. Some of the examples below are:
+
+- Binary Search (for numbers)
+
+- Binary Search (for strings)
+
+- Bogo Sort
+
+- Linear search (for numbers)
+
+- Linear search (for strings)
+
+- Linked List
+
+- Linked List (Merge Sort)
+
+- Merge Sort
+
+- Quick Sort (for numbers)
+
+- Quick Sort (for strings)
+
+- Recursion
+
+- Recursive Binary Search
+
+- Selection Sort

Data Structures and Algorithms/binary_search.py

@@ -0,0 +1,30 @@
+# iterative implementation of binary search
+
+# python language prefers this method alot compared to the recursive method
+def binary_search(list, target):
+    first = 0
+    last = len(list) - 1
+
+    while first <= last:
+        midpoint = (first + last) // 2
+
+        if list[midpoint] == target:
+            return midpoint
+        elif list[midpoint] < target:
+            first = midpoint + 1
+        else:
+            last = midpoint - 1
+    return None
+
+
+def verify(index):
+    if index is not None:
+        print("Target found at index: ", index)
+    else:
+        print("Target not found in the list")
+
+
+numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+result = binary_search(numbers, 12)
+verify(result)

Data Structures and Algorithms/binary_search_strings.py

@@ -0,0 +1,27 @@
+import sys
+# from load import load_strings
+
+# names = load_strings(sys.argv[1])
+
+names = ["mata", "adam", "nasir", "bata", "habib", "amina", "maemuna"]
+search_names = ["mata", "adam", "nasir"]
+
+
+def binary_search(collection, target):
+    first = 0
+    last = len(collection) - 1
+
+    while first <= last:
+        midpoint = (first + last) // 2
+        if collection[midpoint] == target:
+            return midpoint
+        elif collection[midpoint] < target:
+            first = midpoint + 1
+        else:
+            last = midpoint - 1
+    return None
+
+
+for n in search_names:
+    index = binary_search(names, n)
+    print(index)

Data Structures and Algorithms/bogo_sort.py

@@ -0,0 +1,26 @@
+import random
+import sys
+# from load import load_numbers
+
+# number = load_numbers(sys.argv[1])
+# print(number)
+
+
+def is_sorted(values):
+    for index in range(len(values) - 1):
+        if values[index] > values[index + 1]:
+            return False
+    return True
+
+
+def bogo_sort(values):
+    attempts = 0
+
+    while not is_sorted(values):
+        print(attempts)
+        random.shuffle(values)
+        attempts += 1
+    return values
+
+
+print(bogo_sort([5, 8, 1, 4, 7, 9, 6, 3, 2]))

Data Structures and Algorithms/linear_search.py

@@ -0,0 +1,21 @@
+def linear_search(list, target):
+    """
+    returns the index position of the target element if found, otherwise returns none
+    """
+    for i in range(0, len(list)):
+        if list[i] == target:
+            return i
+    return None
+
+
+def verify(index):
+    if index is not None:
+        print("Target found at index: ", index)
+    else:
+        print("Target not found in the list")
+
+
+numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+result = linear_search(numbers, 9)
+verify(result)

Data Structures and Algorithms/linear_search_strings.py

@@ -0,0 +1,18 @@
+import sys
+# from load import load_strings
+
+# names = load_string[sys.argv[1]]
+
+search_names = ["habib", "adam", "nasir", "jelilat"]
+
+
+def index_of_item(collection, target):
+    for i in range(0, len(collection)):
+        if target == collection[i]:
+            return i
+    return None
+
+
+for n in search_names:
+    index = index_of_item(search_names, n)
+    print(index)

Data Structures and Algorithms/linked_list.py

@@ -0,0 +1,141 @@
+class Node:
+    """
+    An object for storing a single node of a linked list
+    model two attributes - data and the link to the next node in the list
+    """
+
+    data = None
+    next_node = None
+
+    def __init__(self, data):
+        self.data = data
+
+    def __repr__(self):
+        return "<Node data: %s>" % self.data
+
+
+class LinkedList:
+    """
+    singly linked list
+    """
+
+    def __init__(self):
+        self.head = None
+
+    def is_empty(self):
+        return self.head == None
+
+    def size(self):
+        """
+        returns the number of nodes in the list
+        takes 0(n) time
+        """
+        current = self.head
+        count = 0
+
+        while current:  # or while current!= None:
+            count += 1
+            current = current.next_node
+        return count
+
+    def add(self, data):
+        """
+        adds new node containing data at head of the list
+        takes 0(1) time
+        """
+        new_node = Node(data)
+        new_node.next_node = self.head
+        self.head = new_node
+
+    def search(self, key):
+        """
+        search for the first node containing data that matches the key
+        returns the node or "None" if not found
+        takes 0(n) time
+        """
+        current = self.head
+        while current:
+            if current.data == key:
+                return current
+            else:
+                current = current.next_node
+        return None
+
+    def insert(self, data, index):
+        """
+        insert a new node containing data at index position
+        insertion takes 0(1) time but finding the node at the
+        insertion point takes 0(n) time
+        takes overall 0(n) time
+        """
+        if index == 0:
+            self.add(data)
+        if index > 0:
+            new = Node(data)
+
+            position = index
+            current = self.head
+
+            while position > 1:
+                current = node.next_node
+                position -= 1
+
+            prev_node = current
+            next_node = current.next_node
+
+            prev_node.next_node = new
+            new.next_node = next_node
+
+    def remove(self, key):
+        """
+        removes nodes containing data that matches the key
+        returns the node or "none" if the key doesn't exist
+        takes 0(n) time
+        """
+        current = self.head
+        previous = None
+        found = False
+
+        while current and not found:
+            if current.data == key and current == self.head:  # or current is self.head
+                found = True
+                self.head = current.next_node
+            elif current.data == key:
+                found = True
+                previous.next_node = current.next_node
+            else:
+                previous = current
+                current = current.next_node
+
+            return current
+        
+    def node_at_index(self, index):
+        if index == 0:
+            return self.head
+        else:
+            current = self.head
+            position = 0
+            
+            while position < index:
+                current = current.next_node
+                position += 1
+            return current
+
+    def __repr__(self):
+        """
+        returns a string representation of the list
+        takes 0(n) time
+        """
+        nodes = []
+        current = self.head
+
+        while current:
+            if current is self.head:
+                nodes.append("[head: %s]" % current.data)
+            elif current.next_node is None:
+                nodes.append("[Tail: %s]" % current.data)
+            else:
+                nodes.append("[%s]" % current.data)
+
+            current = current.next_node
+        return "->".join(nodes)