pandusha 0.2.0__py3-none-any.whl

pandusha/__init__.py

@@ -0,0 +1,60 @@
+"""Pandusha - educational data structures and algorithms library."""
+
+from .avl_tree import AVLTree
+from .binary_search_tree import BinarySearchTree
+from .disjoint_set import DisjointSet
+from .doubly_linked_list import DoublyLinkedList
+from .dynamic_programming import (
+    climbing_stairs,
+    coin_change_min,
+    fibonacci_memo,
+    fibonacci_tabulation,
+)
+from .graph import Graph
+from .hash_table import HashTable
+from .heap import MaxHeap, MinHeap, PriorityQueue
+from .linked_list import LinkedList
+from .queue import Queue
+from .searching import binary_search, jump_search, linear_search
+from .sorting import (
+    bubble_sort,
+    heap_sort,
+    insertion_sort,
+    merge_sort,
+    quick_sort,
+    selection_sort,
+)
+from .stack import Stack
+from .trie import Trie
+
+__version__ = "0.2.0"
+__author__ = "Cem Berk Çakır, Yasemin Serdengeçti"
+
+__all__ = [
+    "AVLTree",
+    "BinarySearchTree",
+    "DisjointSet",
+    "DoublyLinkedList",
+    "Graph",
+    "HashTable",
+    "LinkedList",
+    "MaxHeap",
+    "MinHeap",
+    "PriorityQueue",
+    "Queue",
+    "Stack",
+    "Trie",
+    "binary_search",
+    "bubble_sort",
+    "climbing_stairs",
+    "coin_change_min",
+    "fibonacci_memo",
+    "fibonacci_tabulation",
+    "heap_sort",
+    "insertion_sort",
+    "jump_search",
+    "linear_search",
+    "merge_sort",
+    "quick_sort",
+    "selection_sort",
+]

pandusha/avl_tree.py

@@ -0,0 +1,111 @@
+"""AVL tree implementation."""
+
+
+class AVLNode:
+    def __init__(self, value):
+        self.value = value
+        self.left = None
+        self.right = None
+        self.height = 1
+
+
+class AVLTree:
+    def __init__(self):
+        self.root = None
+        self.length = 0
+
+    def __iter__(self):
+        return iter(self.in_order())
+
+    def __len__(self):
+        return self.length
+
+    def __repr__(self):
+        return f"AVLTree({self.in_order()!r})"
+
+    def is_empty(self):
+        return self.root is None
+
+    def insert(self, value):
+        if self.contains(value):
+            return False
+        self.root = self._insert(self.root, value)
+        self.length += 1
+        return True
+
+    def contains(self, value):
+        current = self.root
+        while current is not None:
+            if value == current.value:
+                return True
+            current = current.left if value < current.value else current.right
+        return False
+
+    def in_order(self):
+        values = []
+
+        def walk(node):
+            if node is None:
+                return
+            walk(node.left)
+            values.append(node.value)
+            walk(node.right)
+
+        walk(self.root)
+        return values
+
+    def to_list(self):
+        return self.in_order()
+
+    def height(self):
+        return self._height(self.root)
+
+    def _insert(self, node, value):
+        if node is None:
+            return AVLNode(value)
+        if value < node.value:
+            node.left = self._insert(node.left, value)
+        else:
+            node.right = self._insert(node.right, value)
+        return self._rebalance(node)
+
+    def _height(self, node):
+        return node.height if node is not None else 0
+
+    def _balance(self, node):
+        return self._height(node.left) - self._height(node.right) if node is not None else 0
+
+    def _update_height(self, node):
+        node.height = 1 + max(self._height(node.left), self._height(node.right))
+
+    def _rebalance(self, node):
+        self._update_height(node)
+        balance = self._balance(node)
+
+        if balance > 1:
+            if self._balance(node.left) < 0:
+                node.left = self._rotate_left(node.left)
+            return self._rotate_right(node)
+        if balance < -1:
+            if self._balance(node.right) > 0:
+                node.right = self._rotate_right(node.right)
+            return self._rotate_left(node)
+        return node
+
+    def _rotate_left(self, node):
+        new_root = node.right
+        moved_subtree = new_root.left
+        new_root.left = node
+        node.right = moved_subtree
+        self._update_height(node)
+        self._update_height(new_root)
+        return new_root
+
+    def _rotate_right(self, node):
+        new_root = node.left
+        moved_subtree = new_root.right
+        new_root.right = node
+        node.left = moved_subtree
+        self._update_height(node)
+        self._update_height(new_root)
+        return new_root

pandusha/binary_search_tree.py

@@ -0,0 +1,140 @@
+"""Binary search tree implementation."""
+
+from collections import deque
+
+
+class Node:
+    def __init__(self, value):
+        self.value = value
+        self.left = None
+        self.right = None
+
+
+class BinarySearchTree:
+    def __init__(self):
+        self.root = None
+        self.length = 0
+
+    def __iter__(self):
+        return iter(self.in_order())
+
+    def __len__(self):
+        return self.length
+
+    def __repr__(self):
+        return f"BinarySearchTree({self.to_list()!r})"
+
+    def is_empty(self):
+        return self.root is None
+
+    def to_list(self):
+        return self.in_order()
+
+    def insert(self, value):
+        new_node = Node(value)
+        if self.root is None:
+            self.root = new_node
+            self.length += 1
+            return True
+
+        current = self.root
+        while True:
+            if value == current.value:
+                return False
+            if value < current.value:
+                if current.left is None:
+                    current.left = new_node
+                    self.length += 1
+                    return True
+                current = current.left
+            else:
+                if current.right is None:
+                    current.right = new_node
+                    self.length += 1
+                    return True
+                current = current.right
+
+    def contains(self, value):
+        current = self.root
+        while current is not None:
+            if value == current.value:
+                return True
+            current = current.left if value < current.value else current.right
+        return False
+
+    def in_order(self):
+        values = []
+
+        def walk(node):
+            if node is None:
+                return
+            walk(node.left)
+            values.append(node.value)
+            walk(node.right)
+
+        walk(self.root)
+        return values
+
+    def pre_order(self):
+        values = []
+
+        def walk(node):
+            if node is None:
+                return
+            values.append(node.value)
+            walk(node.left)
+            walk(node.right)
+
+        walk(self.root)
+        return values
+
+    def post_order(self):
+        values = []
+
+        def walk(node):
+            if node is None:
+                return
+            walk(node.left)
+            walk(node.right)
+            values.append(node.value)
+
+        walk(self.root)
+        return values
+
+    def level_order(self):
+        if self.root is None:
+            return []
+        values = []
+        queue = deque([self.root])
+        while queue:
+            node = queue.popleft()
+            values.append(node.value)
+            if node.left is not None:
+                queue.append(node.left)
+            if node.right is not None:
+                queue.append(node.right)
+        return values
+
+    def min_value(self):
+        current = self.root
+        if current is None:
+            return None
+        while current.left is not None:
+            current = current.left
+        return current.value
+
+    def max_value(self):
+        current = self.root
+        if current is None:
+            return None
+        while current.right is not None:
+            current = current.right
+        return current.value
+
+    def height(self):
+        def walk(node):
+            if node is None:
+                return 0
+            return 1 + max(walk(node.left), walk(node.right))
+
+        return walk(self.root)

pandusha/disjoint_set.py

@@ -0,0 +1,44 @@
+"""Disjoint set / union-find implementation."""
+
+
+class DisjointSet:
+    def __init__(self):
+        self.parent = {}
+        self.rank = {}
+
+    def __len__(self):
+        return len(self.parent)
+
+    def make_set(self, item):
+        if item in self.parent:
+            return False
+        self.parent[item] = item
+        self.rank[item] = 0
+        return True
+
+    def find(self, item):
+        if item not in self.parent:
+            self.make_set(item)
+        if self.parent[item] != item:
+            self.parent[item] = self.find(self.parent[item])
+        return self.parent[item]
+
+    def union(self, first, second):
+        root_first = self.find(first)
+        root_second = self.find(second)
+        if root_first == root_second:
+            return False
+
+        if self.rank[root_first] < self.rank[root_second]:
+            self.parent[root_first] = root_second
+        elif self.rank[root_first] > self.rank[root_second]:
+            self.parent[root_second] = root_first
+        else:
+            self.parent[root_second] = root_first
+            self.rank[root_first] += 1
+        return True
+
+    def connected(self, first, second):
+        if first not in self.parent or second not in self.parent:
+            return False
+        return self.find(first) == self.find(second)

pandusha/doubly_linked_list.py

@@ -0,0 +1,232 @@
+"""Doubly linked list implementation."""
+
+
+_MISSING = object()
+
+
+class DoublyLinkedList:
+    class Node:
+        def __init__(self, value):
+            self.value = value
+            self.next = None
+            self.prev = None
+
+        def __repr__(self):
+            return f"Node({self.value!r})"
+
+    def __init__(self, value=_MISSING):
+        self.head = None
+        self.tail = None
+        self.length = 0
+        if value is not _MISSING:
+            self.append(value)
+
+    def __iter__(self):
+        current = self.head
+        while current is not None:
+            yield current.value
+            current = current.next
+
+    def __len__(self):
+        return self.length
+
+    def __repr__(self):
+        return f"DoublyLinkedList({self.to_list()!r})"
+
+    def get_head(self):
+        return self.head
+
+    def get_tail(self):
+        return self.tail
+
+    def get_length(self):
+        return self.length
+
+    def is_empty(self):
+        return self.length == 0
+
+    def to_list(self):
+        return list(self)
+
+    def print_list(self):
+        current = self.head
+        while current is not None:
+            print(current.value)
+            current = current.next
+
+    def print_all(self):
+        print("Head:", self.head.value if self.head else "Null")
+        print("Tail:", self.tail.value if self.tail else "Null")
+        print("Length:", self.length)
+        print("\nDoubly Linked List:")
+        if self.is_empty():
+            print("Empty")
+        else:
+            self.print_list()
+
+    def make_empty(self):
+        self.head = None
+        self.tail = None
+        self.length = 0
+
+    def clear(self):
+        self.make_empty()
+
+    def append(self, value):
+        new_node = self.Node(value)
+        if self.is_empty():
+            self.head = new_node
+            self.tail = new_node
+        else:
+            self.tail.next = new_node
+            new_node.prev = self.tail
+            self.tail = new_node
+        self.length += 1
+        return True
+
+    def remove_last(self):
+        if self.is_empty():
+            return None
+        temp = self.tail
+        if self.length == 1:
+            self.make_empty()
+            return temp
+        else:
+            self.tail = self.tail.prev
+            self.tail.next = None
+            temp.prev = None
+        self.length -= 1
+        return temp
+
+    def prepend(self, value):
+        new_node = self.Node(value)
+        if self.is_empty():
+            self.head = new_node
+            self.tail = new_node
+        else:
+            new_node.next = self.head
+            self.head.prev = new_node
+            self.head = new_node
+        self.length += 1
+        return True
+
+    def remove_first(self):
+        if self.is_empty():
+            return None
+        temp = self.head
+        if self.length == 1:
+            self.make_empty()
+        else:
+            self.head = self.head.next
+            self.head.prev = None
+            temp.next = None
+            self.length -= 1
+        return temp
+
+    def get(self, index):
+        if index < 0 or index >= self.length:
+            return None
+        if index < self.length / 2:
+            current = self.head
+            for _ in range(index):
+                current = current.next
+        else:
+            current = self.tail
+            for _ in range(self.length - 1, index, -1):
+                current = current.prev
+        return current
+
+    def set(self, index, value):
+        temp = self.get(index)
+        if temp is None:
+            return False
+        temp.value = value
+        return True
+
+    def set_value(self, index, value):
+        return self.set(index, value)
+
+    def insert(self, index, value):
+        if index < 0 or index > self.length:
+            return False
+        if index == 0:
+            return self.prepend(value)
+        if index == self.length:
+            return self.append(value)
+
+        new_node = self.Node(value)
+        before = self.get(index - 1)
+        after = before.next
+        new_node.prev = before
+        new_node.next = after
+        before.next = new_node
+        after.prev = new_node
+        self.length += 1
+        return True
+
+    def remove(self, index):
+        if index < 0 or index >= self.length:
+            return None
+        if index == 0:
+            return self.remove_first()
+        if index == self.length - 1:
+            return self.remove_last()
+
+        temp = self.get(index)
+        temp.prev.next = temp.next
+        temp.next.prev = temp.prev
+        temp.prev = None
+        temp.next = None
+        self.length -= 1
+        return temp
+
+    def is_palindrome(self):
+        left = self.head
+        right = self.tail
+        while left is not None and right is not None and left != right and left.prev != right:
+            if left.value != right.value:
+                return False
+            left = left.next
+            right = right.prev
+        return True
+
+    def reverse(self):
+        current = self.head
+        self.head, self.tail = self.tail, self.head
+        while current is not None:
+            current.prev, current.next = current.next, current.prev
+            current = current.prev
+
+    def partition_list(self, x):
+        less = []
+        greater_or_equal = []
+        current = self.head
+        while current is not None:
+            if current.value < x:
+                less.append(current.value)
+            else:
+                greater_or_equal.append(current.value)
+            current = current.next
+        self.make_empty()
+        for value in less + greater_or_equal:
+            self.append(value)
+
+    def reverse_between(self, start, end):
+        if self.head is None or start == end:
+            return
+        if start < 0 or end < start or end >= self.length:
+            return
+
+        values = self.to_list()
+        values[start : end + 1] = reversed(values[start : end + 1])
+        self.make_empty()
+        for value in values:
+            self.append(value)
+
+    def swap_pairs(self):
+        values = self.to_list()
+        for index in range(0, len(values) - 1, 2):
+            values[index], values[index + 1] = values[index + 1], values[index]
+        self.make_empty()
+        for value in values:
+            self.append(value)

pandusha/dynamic_programming.py

@@ -0,0 +1,49 @@
+"""Small dynamic programming examples."""
+
+
+def fibonacci_memo(n, memo=None):
+    if n < 0:
+        raise ValueError("n must be non-negative")
+    if memo is None:
+        memo = {}
+    if n in (0, 1):
+        return n
+    if n not in memo:
+        memo[n] = fibonacci_memo(n - 1, memo) + fibonacci_memo(n - 2, memo)
+    return memo[n]
+
+
+def fibonacci_tabulation(n):
+    if n < 0:
+        raise ValueError("n must be non-negative")
+    if n in (0, 1):
+        return n
+    table = [0] * (n + 1)
+    table[1] = 1
+    for index in range(2, n + 1):
+        table[index] = table[index - 1] + table[index - 2]
+    return table[n]
+
+
+def climbing_stairs(n):
+    if n < 0:
+        raise ValueError("n must be non-negative")
+    if n <= 1:
+        return 1
+    previous = 1
+    current = 1
+    for _ in range(2, n + 1):
+        previous, current = current, previous + current
+    return current
+
+
+def coin_change_min(coins, amount):
+    if amount < 0:
+        raise ValueError("amount must be non-negative")
+    dp = [float("inf")] * (amount + 1)
+    dp[0] = 0
+    for value in range(1, amount + 1):
+        for coin in coins:
+            if coin <= value:
+                dp[value] = min(dp[value], dp[value - coin] + 1)
+    return dp[amount] if dp[amount] != float("inf") else -1