chore: move simple data-structures into data_structures.simple and remove ds_extra

Author: athikha

data_structures/__init__.py

@@ -0,0 +1,9 @@
+"""Top-level data_structures package.
+
+This file exposes a small `simple` collection of educational data structures
+under `data_structures.simple` and provides a few convenience imports.
+"""
+
+from . import simple
+
+__all__ = ["simple"]

data_structures/simple/__init__.py

@@ -0,0 +1,26 @@
+"""Simple implementations of common data structures.
+
+This subpackage contains small, educational implementations copied from the
+`ds_extra` package so they can be accessed via `data_structures.simple`.
+"""
+
+from .linked_list import LinkedList
+from .stack import ListStack, LinkedStack
+from .queue import Queue
+from .bst import BinarySearchTree
+from .graph import Graph
+from .trie import Trie
+from .union_find import UnionFind
+from .min_heap import MinHeap
+
+__all__ = [
+    "LinkedList",
+    "ListStack",
+    "LinkedStack",
+    "Queue",
+    "BinarySearchTree",
+    "Graph",
+    "Trie",
+    "UnionFind",
+    "MinHeap",
+]

data_structures/simple/bst.py

@@ -0,0 +1,46 @@
+from typing import Any, Optional, List
+
+
+class BSTNode:
+    def __init__(self, key: Any):
+        self.key = key
+        self.left: Optional[BSTNode] = None
+        self.right: Optional[BSTNode] = None
+
+
+class BinarySearchTree:
+    def __init__(self):
+        self.root: Optional[BSTNode] = None
+
+    def insert(self, key: Any) -> None:
+        def _insert(node: Optional[BSTNode], key: Any) -> BSTNode:
+            if not node:
+                return BSTNode(key)
+            if key < node.key:
+                node.left = _insert(node.left, key)
+            else:
+                node.right = _insert(node.right, key)
+            return node
+
+        self.root = _insert(self.root, key)
+
+    def search(self, key: Any) -> bool:
+        node = self.root
+        while node:
+            if key == node.key:
+                return True
+            node = node.left if key < node.key else node.right
+        return False
+
+    def inorder(self) -> List[Any]:
+        res: List[Any] = []
+
+        def _in(node: Optional[BSTNode]) -> None:
+            if not node:
+                return
+            _in(node.left)
+            res.append(node.key)
+            _in(node.right)
+
+        _in(self.root)
+        return res

data_structures/simple/graph.py

@@ -0,0 +1,41 @@
+from collections import defaultdict, deque
+from typing import Any, Dict, List
+
+
+class Graph:
+    def __init__(self, directed: bool = False):
+        self.adj: Dict[Any, List[Any]] = defaultdict(list)
+        self.directed = directed
+
+    def add_edge(self, u: Any, v: Any) -> None:
+        self.adj[u].append(v)
+        if not self.directed:
+            self.adj[v].append(u)
+
+    def bfs(self, start: Any) -> List[Any]:
+        visited = set()
+        order = []
+        q = deque([start])
+        visited.add(start)
+        while q:
+            u = q.popleft()
+            order.append(u)
+            for v in self.adj[u]:
+                if v not in visited:
+                    visited.add(v)
+                    q.append(v)
+        return order
+
+    def dfs(self, start: Any) -> List[Any]:
+        visited = set()
+        order = []
+
+        def _dfs(u: Any) -> None:
+            visited.add(u)
+            order.append(u)
+            for v in self.adj[u]:
+                if v not in visited:
+                    _dfs(v)
+
+        _dfs(start)
+        return order

data_structures/simple/linked_list.py

@@ -0,0 +1,56 @@
+from typing import Any, Optional
+
+
+class Node:
+    def __init__(self, value: Any):
+        self.value = value
+        self.next: Optional[Node] = None
+
+
+class LinkedList:
+    def __init__(self):
+        self.head: Optional[Node] = None
+
+    def append(self, value: Any) -> None:
+        node = Node(value)
+        if not self.head:
+            self.head = node
+            return
+        cur = self.head
+        while cur.next:
+            cur = cur.next
+        cur.next = node
+
+    def prepend(self, value: Any) -> None:
+        node = Node(value)
+        node.next = self.head
+        self.head = node
+
+    def find(self, value: Any) -> Optional[Node]:
+        cur = self.head
+        while cur:
+            if cur.value == value:
+                return cur
+            cur = cur.next
+        return None
+
+    def delete(self, value: Any) -> bool:
+        cur = self.head
+        prev = None
+        while cur:
+            if cur.value == value:
+                if prev:
+                    prev.next = cur.next
+                else:
+                    self.head = cur.next
+                return True
+            prev, cur = cur, cur.next
+        return False
+
+    def to_list(self) -> list:
+        out = []
+        cur = self.head
+        while cur:
+            out.append(cur.value)
+            cur = cur.next
+        return out

data_structures/simple/min_heap.py

@@ -0,0 +1,16 @@
+import heapq
+from typing import Any, List, Optional
+
+
+class MinHeap:
+    def __init__(self):
+        self._data: List[Any] = []
+
+    def push(self, v: Any) -> None:
+        heapq.heappush(self._data, v)
+
+    def pop(self) -> Any:
+        return heapq.heappop(self._data)
+
+    def peek(self) -> Optional[Any]:
+        return self._data[0] if self._data else None

data_structures/simple/queue.py

@@ -0,0 +1,16 @@
+from collections import deque
+from typing import Any, Optional
+
+
+class Queue:
+    def __init__(self):
+        self._dq = deque()
+
+    def enqueue(self, v: Any) -> None:
+        self._dq.append(v)
+
+    def dequeue(self) -> Any:
+        return self._dq.popleft()
+
+    def peek(self) -> Optional[Any]:
+        return self._dq[0] if self._dq else None

data_structures/simple/run_ds_tests.py

@@ -0,0 +1,119 @@
+"""Smoke test runner for the `data_structures.simple` package."""
+
+import sys
+
+from data_structures.simple.linked_list import LinkedList
+from data_structures.simple.stack import ListStack, LinkedStack
+from data_structures.simple.queue import Queue
+from data_structures.simple.bst import BinarySearchTree
+from data_structures.simple.graph import Graph
+from data_structures.simple.trie import Trie
+from data_structures.simple.union_find import UnionFind
+from data_structures.simple.min_heap import MinHeap
+
+
+def run() -> None:
+    failures = []
+
+    try:
+        ll = LinkedList()
+        ll.append(1)
+        ll.append(2)
+        ll.prepend(0)
+        assert ll.to_list() == [0, 1, 2]
+        assert ll.find(1) is not None
+        assert ll.delete(1) is True
+        assert ll.to_list() == [0, 2]
+        print("LinkedList: OK")
+    except Exception as e:
+        failures.append(('LinkedList', e))
+
+    try:
+        s = ListStack()
+        s.push(1)
+        s.push(2)
+        assert s.peek() == 2
+        assert s.pop() == 2
+
+        ls = LinkedStack()
+        ls.push('a')
+        ls.push('b')
+        assert ls.peek() == 'b'
+        assert ls.pop() == 'b'
+        print("Stacks: OK")
+    except Exception as e:
+        failures.append(('Stacks', e))
+
+    try:
+        q = Queue()
+        q.enqueue(1)
+        q.enqueue(2)
+        assert q.peek() == 1
+        assert q.dequeue() == 1
+        print("Queue: OK")
+    except Exception as e:
+        failures.append(('Queue', e))
+
+    try:
+        bst = BinarySearchTree()
+        for v in [3, 1, 4, 2]:
+            bst.insert(v)
+        assert bst.search(2)
+        assert bst.inorder() == [1, 2, 3, 4]
+        print("BST: OK")
+    except Exception as e:
+        failures.append(('BST', e))
+
+    try:
+        g = Graph()
+        g.add_edge(1, 2)
+        g.add_edge(1, 3)
+        order_bfs = g.bfs(1)
+        assert 1 in order_bfs
+        order_dfs = g.dfs(1)
+        assert 1 in order_dfs
+        print("Graph: OK")
+    except Exception as e:
+        failures.append(('Graph', e))
+
+    try:
+        t = Trie()
+        t.insert('hello')
+        assert t.search('hello')
+        assert t.starts_with('hel')
+        print("Trie: OK")
+    except Exception as e:
+        failures.append(('Trie', e))
+
+    try:
+        uf = UnionFind()
+        for x in [1, 2, 3]:
+            uf.make_set(x)
+        uf.union(1, 2)
+        assert uf.find(1) == uf.find(2)
+        print("UnionFind: OK")
+    except Exception as e:
+        failures.append(('UnionFind', e))
+
+    try:
+        h = MinHeap()
+        h.push(5)
+        h.push(1)
+        h.push(3)
+        assert h.peek() == 1
+        assert h.pop() == 1
+        print("MinHeap: OK")
+    except Exception as e:
+        failures.append(('MinHeap', e))
+
+    if failures:
+        print('\nFAILURES:')
+        for name, exc in failures:
+            print(f"- {name}: {exc}")
+        sys.exit(2)
+    else:
+        print('\nAll data_structures.simple smoke tests passed.')
+
+
+if __name__ == '__main__':
+    run()

data_structures/simple/stack.py

@@ -0,0 +1,34 @@
+from typing import Any, Optional
+from .linked_list import LinkedList
+
+
+class ListStack:
+    def __init__(self):
+        self._data = []
+
+    def push(self, v: Any) -> None:
+        self._data.append(v)
+
+    def pop(self) -> Any:
+        return self._data.pop()
+
+    def peek(self) -> Optional[Any]:
+        return self._data[-1] if self._data else None
+
+
+class LinkedStack:
+    def __init__(self):
+        self._list = LinkedList()
+
+    def push(self, v: Any) -> None:
+        self._list.prepend(v)
+
+    def pop(self) -> Any:
+        if not self._list.head:
+            raise IndexError("pop from empty stack")
+        val = self._list.head.value
+        self._list.head = self._list.head.next
+        return val
+
+    def peek(self) -> Optional[Any]:
+        return self._list.head.value if self._list.head else None