toolkit-ds 0.1.0__py3-none-any.whl

ds_toolkit/__init__.py

@@ -0,0 +1,21 @@
+from .singly_linked_list import SinglyLinkedList
+from .doubly_linked_list import DoublyLinkedList
+from .stack import Stack, LinkedListStack
+from .queue import Queue, LinkedListQueue
+from .heap import BinaryMinHeap
+from .bst import BinarySearchTree
+from .avl import AVLTree
+from .union_find import UnionFind
+
+__all__ = [
+    "SinglyLinkedList",
+    "DoublyLinkedList",
+    "Stack",
+    "LinkedListStack",
+    "Queue",
+    "LinkedListQueue",
+    "BinaryMinHeap",
+    "BinarySearchTree",
+    "AVLTree",
+    "UnionFind",
+]

ds_toolkit/avl.py

@@ -0,0 +1,192 @@
+class AVLNode:
+    """Node class for AVL Tree."""
+    def __init__(self, value):
+        self.value = value
+        self.left = None
+        self.right = None
+        self.height = 1
+
+
+class AVLTree:
+    """AVL Tree implementation."""
+
+    def __init__(self):
+        self.root = None
+
+    def get_height(self, node):
+        """Get the height of a node."""
+        if not node:
+            return 0
+        return node.height
+
+    def get_balance(self, node):
+        """Get the balance factor of a node."""
+        if not node:
+            return 0
+        return self.get_height(node.left) - self.get_height(node.right)
+
+    def right_rotate(self, z):
+        """Perform a right rotation."""
+        y = z.left
+        T3 = y.right
+        y.right = z
+        z.left = T3
+
+        # Update heights
+        z.height = 1 + max(self.get_height(z.left), self.get_height(z.right))
+        y.height = 1 + max(self.get_height(y.left), self.get_height(y.right))
+
+        return y
+
+    def left_rotate(self, z):
+        """Perform a left rotation."""
+        y = z.right
+        T2 = y.left
+        y.left = z
+        z.right = T2
+
+        # Update heights
+        z.height = 1 + max(self.get_height(z.left), self.get_height(z.right))
+        y.height = 1 + max(self.get_height(y.left), self.get_height(y.right))
+
+        return y
+
+    def insert(self, value):
+        """Insert a value into the AVL tree."""
+        self.root = self._insert(self.root, value)
+
+    def _insert(self, node, value):
+        """Recursive function to insert a value."""
+        if not node:
+            return AVLNode(value)
+
+        if value < node.value:
+            node.left = self._insert(node.left, value)
+        else:
+            node.right = self._insert(node.right, value)
+
+        # Update the height of the node
+        node.height = 1 + max(self.get_height(node.left), self.get_height(node.right))
+
+        # Get the balance factor
+        balance = self.get_balance(node)
+
+        # Perform rotations to balance the tree
+        # Case 1: Left Left
+        if balance > 1 and value < node.left.value:
+            return self.right_rotate(node)
+        # Case 2: Right Right
+        if balance < -1 and value > node.right.value:
+            return self.left_rotate(node)
+        # Case 3: Left Right
+        if balance > 1 and value > node.left.value:
+            node.left = self.left_rotate(node.left)
+            return self.right_rotate(node)
+        # Case 4: Right Left
+        if balance < -1 and value < node.right.value:
+            node.right = self.right_rotate(node.right)
+            return self.left_rotate(node)
+
+        return node
+
+    def delete(self, value):
+        """Delete a value from the AVL tree."""
+        if self.is_empty():
+            raise Exception("Cannot delete from an empty tree")
+        self.root = self._delete(self.root, value)
+    
+    def is_empty(self):
+        return self.root is None
+
+
+    def _delete(self, node, value):
+        """Recursive function to delete a value."""
+        if not node:
+            return node
+
+        # Perform standard BST delete
+        if value < node.value:
+            node.left = self._delete(node.left, value)
+        elif value > node.value:
+            node.right = self._delete(node.right, value)
+        else:
+            # Node with only one child or no child
+            if not node.left:
+                return node.right
+            elif not node.right:
+                return node.left
+
+            # Node with two children: Get the inorder successor
+            temp = self._get_min_value_node(node.right)
+            node.value = temp.value
+            node.right = self._delete(node.right, temp.value)
+
+        # Update the height of the node
+        node.height = 1 + max(self.get_height(node.left), self.get_height(node.right))
+
+        # Get the balance factor
+        balance = self.get_balance(node)
+
+        # Perform rotations to balance the tree
+        # Case 1: Left Left
+        if balance > 1 and self.get_balance(node.left) >= 0:
+            return self.right_rotate(node)
+        # Case 2: Right Right
+        if balance < -1 and self.get_balance(node.right) <= 0:
+            return self.left_rotate(node)
+        # Case 3: Left Right
+        if balance > 1 and self.get_balance(node.left) < 0:
+            node.left = self.left_rotate(node.left)
+            return self.right_rotate(node)
+        # Case 4: Right Left
+        if balance < -1 and self.get_balance(node.right) > 0:
+            node.right = self.right_rotate(node.right)
+            return self.left_rotate(node)
+
+        return node
+
+    def _get_min_value_node(self, node):
+        """Get the node with the smallest value."""
+        current = node
+        while current.left:
+            current = current.left
+        return current
+
+    def inorder(self):
+        """Perform inorder traversal and return the result as a list."""
+        result = []
+        self._inorder(self.root, result)
+        return result
+
+    def _inorder(self, node, result):
+        if not node:
+            return
+        self._inorder(node.left, result)
+        result.append(node.value)
+        self._inorder(node.right, result)
+
+    def preorder(self):
+        """Perform preorder traversal and return the result as a list."""
+        result = []
+        self._preorder(self.root, result)
+        return result
+
+    def _preorder(self, node, result):
+        if not node:
+            return
+        result.append(node.value)
+        self._preorder(node.left, result)
+        self._preorder(node.right, result)
+
+    def postorder(self):
+        """Perform postorder traversal and return the result as a list."""
+        result = []
+        self._postorder(self.root, result)
+        return result
+
+    def _postorder(self, node, result):
+        if not node:
+            return
+        self._postorder(node.left, result)
+        self._postorder(node.right, result)
+        result.append(node.value)

ds_toolkit/bst.py

@@ -0,0 +1,117 @@
+class BSTNode:
+    """Node class for a Binary Search Tree."""
+    def __init__(self, value):
+        self.value = value
+        self.left = None
+        self.right = None
+
+
+class BinarySearchTree:
+    """Binary Search Tree implementation."""
+    def __init__(self):
+        self.root = None
+
+    def insert(self, value):
+        """Insert a value into the BST."""
+        if not self.root:
+            self.root = BSTNode(value)
+        else:
+            self._insert(self.root, value)
+
+    def _insert(self, node, value):
+        """Recursive insertion."""
+        if value < node.value:
+            if not node.left:
+                node.left = BSTNode(value)
+            else:
+                self._insert(node.left, value)
+        elif value > node.value:
+            if not node.right:
+                node.right = BSTNode(value)
+            else:
+                self._insert(node.right, value)
+
+    def find(self, value):
+        """Search for a value in the BST."""
+        return self._find(self.root, value)
+
+    def _find(self, node, value):
+        """Recursive search."""
+        if not node:
+            return False
+        if value == node.value:
+            return True
+        elif value < node.value:
+            return self._find(node.left, value)
+        else:
+            return self._find(node.right, value)
+
+    def delete(self, value):
+        """Delete a value from the BST."""
+        self.root = self._delete(self.root, value)
+
+    def _delete(self, node, value):
+        """Recursive deletion."""
+        if not node:
+            return node
+
+        if value < node.value:
+            node.left = self._delete(node.left, value)
+        elif value > node.value:
+            node.right = self._delete(node.right, value)
+        else:
+            # Node with only one child or no child
+            if not node.left:
+                return node.right
+            elif not node.right:
+                return node.left
+
+            # Node with two children: Get the inorder successor
+            temp = self._min_value_node(node.right)
+            node.value = temp.value
+            node.right = self._delete(node.right, temp.value)
+
+        return node
+
+    def _min_value_node(self, node):
+        """Get the node with the minimum value."""
+        current = node
+        while current.left:
+            current = current.left
+        return current
+
+    def inorder(self):
+        """Perform an inorder traversal."""
+        result = []
+        self._inorder(self.root, result)
+        return result
+
+    def _inorder(self, node, result):
+        if node:
+            self._inorder(node.left, result)
+            result.append(node.value)
+            self._inorder(node.right, result)
+
+    def preorder(self):
+        """Perform a preorder traversal."""
+        result = []
+        self._preorder(self.root, result)
+        return result
+
+    def _preorder(self, node, result):
+        if node:
+            result.append(node.value)
+            self._preorder(node.left, result)
+            self._preorder(node.right, result)
+
+    def postorder(self):
+        """Perform a postorder traversal."""
+        result = []
+        self._postorder(self.root, result)
+        return result
+
+    def _postorder(self, node, result):
+        if node:
+            self._postorder(node.left, result)
+            self._postorder(node.right, result)
+            result.append(node.value)

ds_toolkit/doubly_linked_list.py

@@ -0,0 +1,75 @@
+class DoublyLinkedListNode:
+    """Node class for a doubly linked list."""
+    def __init__(self, value):
+        self.value = value
+        self.prev = None
+        self.next = None
+
+
+class DoublyLinkedList:
+    """Doubly Linked List implementation."""
+    def __init__(self):
+        self.head = None
+        self.tail = None
+
+    def push_front(self, value):
+        """Insert a node at the front of the list."""
+        new_node = DoublyLinkedListNode(value)
+        if not self.head:
+            self.head = self.tail = new_node
+        else:
+            new_node.next = self.head
+            self.head.prev = new_node
+            self.head = new_node
+
+    def push_back(self, value):
+        """Insert a node at the end of the list."""
+        new_node = DoublyLinkedListNode(value)
+        if not self.tail:
+            self.head = self.tail = new_node
+        else:
+            new_node.prev = self.tail
+            self.tail.next = new_node
+            self.tail = new_node
+
+    def pop_front(self):
+        """Remove and return the node from the front of the list."""
+        if not self.head:
+            raise IndexError("Pop from empty list")
+        value = self.head.value
+        self.head = self.head.next
+        if self.head:
+            self.head.prev = None
+        else:
+            self.tail = None
+        return value
+
+    def pop_back(self):
+        """Remove and return the node from the end of the list."""
+        if not self.tail:
+            raise IndexError("Pop from empty list")
+        value = self.tail.value
+        self.tail = self.tail.prev
+        if self.tail:
+            self.tail.next = None
+        else:
+            self.head = None
+        return value
+
+    def find(self, value):
+        """Search for a node with the given value."""
+        current = self.head
+        while current:
+            if current.value == value:
+                return True
+            current = current.next
+        return False
+
+    def to_list(self):
+        """Convert the linked list to a Python list."""
+        result = []
+        current = self.head
+        while current:
+            result.append(current.value)
+            current = current.next
+        return result

ds_toolkit/heap.py

@@ -0,0 +1,73 @@
+class BinaryMinHeap:
+    """Binary Min Heap implementation."""
+
+    def __init__(self):
+        self._heap = []
+
+    def _parent(self, index):
+        return (index - 1) // 2
+
+    def _left_child(self, index):
+        return 2 * index + 1
+
+    def _right_child(self, index):
+        return 2 * index + 2
+
+    def _swap(self, i, j):
+        self._heap[i], self._heap[j] = self._heap[j], self._heap[i]
+
+    def insert(self, value):
+        """Insert a value into the heap."""
+        self._heap.append(value)
+        self._heapify_up(len(self._heap) - 1)
+
+    def _heapify_up(self, index):
+        """Ensure the heap property is maintained while inserting."""
+        while index > 0 and self._heap[index] < self._heap[self._parent(index)]:
+            self._swap(index, self._parent(index))
+            index = self._parent(index)
+
+    def extract_min(self):
+        """Remove and return the minimum value from the heap."""
+        if not self._heap:
+            raise IndexError("Extract from an empty heap")
+        if len(self._heap) == 1:
+            return self._heap.pop()
+
+        root = self._heap[0]
+        self._heap[0] = self._heap.pop()
+        self._heapify_down(0)
+        return root
+
+    def _heapify_down(self, index):
+        """Ensure the heap property is maintained while extracting."""
+        smallest = index
+        left = self._left_child(index)
+        right = self._right_child(index)
+
+        if left < len(self._heap) and self._heap[left] < self._heap[smallest]:
+            smallest = left
+        if right < len(self._heap) and self._heap[right] < self._heap[smallest]:
+            smallest = right
+
+        if smallest != index:
+            self._swap(index, smallest)
+            self._heapify_down(smallest)
+
+    def get_min(self):
+        """Return the minimum value without removing it."""
+        if not self._heap:
+            raise IndexError("Get from an empty heap")
+        return self._heap[0]
+
+    def size(self):
+        """Return the size of the heap."""
+        return len(self._heap)
+
+    def is_empty(self):
+        """Check if the heap is empty."""
+        return len(self._heap) == 0
+
+    def to_list(self):
+        """Return the heap as a list."""
+        return self._heap[:]

ds_toolkit/queue.py

@@ -0,0 +1,91 @@
+class Queue:
+    """Queue implementation using a list."""
+    
+    def __init__(self):
+        self._queue = []
+
+    def enqueue(self, value):
+        """Add an element to the end of the queue."""
+        self._queue.append(value)
+
+    def dequeue(self):
+        """Remove and return the element from the front of the queue."""
+        if self.is_empty():
+            raise IndexError("Dequeue from an empty queue")
+        return self._queue.pop(0)
+
+    def front(self):
+        """Return the element at the front of the queue without removing it."""
+        if self.is_empty():
+            raise IndexError("Front from an empty queue")
+        return self._queue[0]
+
+    def is_empty(self):
+        """Check if the queue is empty."""
+        return len(self._queue) == 0
+
+    def size(self):
+        """Return the size of the queue."""
+        return len(self._queue)
+
+    def to_list(self):
+        """Return the queue as a list."""
+        return self._queue[:]
+
+class LinkedListQueue:
+    """Queue implementation using a singly linked list."""
+
+    class Node:
+        """Node class for the linked list."""
+        def __init__(self, data):
+            self.data = data
+            self.next = None
+
+    def __init__(self):
+        self.front = None
+        self.rear = None
+        self.size = 0
+
+    def is_empty(self):
+        """Check if the queue is empty."""
+        return self.size == 0
+
+    def enqueue(self, value):
+        """Add an element to the queue."""
+        new_node = self.Node(value)
+        if self.rear:
+            self.rear.next = new_node
+        self.rear = new_node
+        if self.front is None:
+            self.front = new_node
+        self.size += 1
+
+    def dequeue(self):
+        """Remove and return the front element of the queue."""
+        if self.is_empty():
+            raise IndexError("Dequeue from empty queue")
+        value = self.front.data
+        self.front = self.front.next
+        if self.front is None:
+            self.rear = None
+        self.size -= 1
+        return value
+
+    def peek(self):
+        """Return the front element without removing it."""
+        if self.is_empty():
+            raise IndexError("Peek from empty queue")
+        return self.front.data
+
+    def size(self):
+        """Return the size of the queue."""
+        return self.size
+
+    def to_list(self):
+        """Return the queue as a list."""
+        result = []
+        current = self.front
+        while current:
+            result.append(current.data)
+            current = current.next
+        return result

ds_toolkit/singly_linked_list.py

@@ -0,0 +1,63 @@
+class SinglyLinkedListNode:
+    """Node class for a singly linked list."""
+    def __init__(self, value):
+        self.value = value
+        self.next = None
+
+
+class SinglyLinkedList:
+    """Singly Linked List implementation."""
+    def __init__(self):
+        self.head = None
+
+    def push_front(self, value):
+        """Insert a node at the front of the list."""
+        new_node = SinglyLinkedListNode(value)
+        new_node.next = self.head
+        self.head = new_node
+
+    def push_back(self, value):
+        """Insert a node at the end of the list."""
+        new_node = SinglyLinkedListNode(value)
+        if not self.head:
+            self.head = new_node
+        else:
+            current = self.head
+            while current.next:
+                current = current.next
+            current.next = new_node
+
+    def pop_front(self):
+        """Remove and return the node from the front of the list."""
+        if not self.head:
+            raise IndexError("Pop from empty list")
+        value = self.head.value
+        self.head = self.head.next
+        return value
+
+    def find(self, value):
+        """Search for a node with the given value."""
+        current = self.head
+        while current:
+            if current.value == value:
+                return True
+            current = current.next
+        return False
+
+    def to_list(self):
+        """Convert the linked list to a Python list."""
+        result = []
+        current = self.head
+        while current:
+            result.append(current.value)
+            current = current.next
+        return result
+
+    def size(self):
+        """Return the size of the list."""
+        count = 0
+        current = self.head
+        while current:
+            count += 1
+            current = current.next
+        return count

ds_toolkit/stack.py

@@ -0,0 +1,86 @@
+class Stack:
+    """Stack implementation using a list."""
+
+    def __init__(self):
+        self._stack = []
+
+    def push(self, value):
+        """Push an element onto the stack."""
+        self._stack.append(value)
+
+    def pop(self):
+        """Pop the top element from the stack."""
+        if self.is_empty():
+            raise IndexError("Pop from an empty stack")
+        return self._stack.pop()
+
+    def top(self):
+        """Return the top element of the stack without removing it."""
+        if self.is_empty():
+            raise IndexError("Top from an empty stack")
+        return self._stack[-1]
+
+    def is_empty(self):
+        """Check if the stack is empty."""
+        return len(self._stack) == 0
+
+    def size(self):
+        """Return the size of the stack."""
+        return len(self._stack)
+
+    def to_list(self):
+        """Return the stack as a list."""
+        return self._stack[:]
+
+
+class LinkedListStack:
+    """Stack implementation using a linked list."""
+
+    class Node:
+        """A simple Node class for the linked list."""
+        def __init__(self, data):
+            self.data = data
+            self.next = None
+
+    def __init__(self):
+        self.top = None
+        self.size = 0
+
+    def is_empty(self):
+        """Check if the stack is empty."""
+        return self.size == 0
+
+    def push(self, value):
+        """Push an element onto the stack."""
+        new_node = self.Node(value)
+        new_node.next = self.top
+        self.top = new_node
+        self.size += 1
+
+    def pop(self):
+        """Pop the top element from the stack."""
+        if self.is_empty():
+            raise IndexError("Pop from an empty stack")
+        popped_value = self.top.data
+        self.top = self.top.next
+        self.size -= 1
+        return popped_value
+
+    def top(self):
+        """Return the top element of the stack without removing it."""
+        if self.is_empty():
+            raise IndexError("Top from an empty stack")
+        return self.top.data
+
+    def size(self):
+        """Return the size of the stack."""
+        return self.size
+
+    def to_list(self):
+        """Return the stack as a list."""
+        result = []
+        current = self.top
+        while current:
+            result.append(current.data)
+            current = current.next
+        return result

ds_toolkit/union_find.py

@@ -0,0 +1,36 @@
+class UnionFind:
+    """Union-Find (Disjoint Set Union) data structure with path compression and union by rank."""
+
+    def __init__(self, size):
+        """Initialize the UnionFind data structure with `size` elements."""
+        self.parent = list(range(size))  # Each element is its own parent initially
+        self.rank = [1] * size  # Rank to keep the tree flat
+
+    def find(self, x):
+        """Find the representative (root) of the set that `x` belongs to."""
+        if self.parent[x] != x:
+            self.parent[x] = self.find(self.parent[x])  # Path compression
+        return self.parent[x]
+
+    def union(self, x, y):
+        """Union the sets containing `x` and `y`."""
+        rootX = self.find(x)
+        rootY = self.find(y)
+
+        if rootX != rootY:
+            # Union by rank: attach the smaller tree under the larger tree
+            if self.rank[rootX] > self.rank[rootY]:
+                self.parent[rootY] = rootX
+            elif self.rank[rootX] < self.rank[rootY]:
+                self.parent[rootX] = rootY
+            else:
+                self.parent[rootY] = rootX
+                self.rank[rootX] += 1
+
+    def connected(self, x, y):
+        """Check if elements `x` and `y` belong to the same set."""
+        return self.find(x) == self.find(y)
+
+    def to_list(self):
+        """Return the list of parents for all elements."""
+        return self.parent

toolkit_ds-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2024] [Aravind]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

toolkit_ds-0.1.0.dist-info/METADATA

@@ -0,0 +1,300 @@
+Metadata-Version: 2.1
+Name: toolkit_ds
+Version: 0.1.0
+Summary: A Python package implementing core data structures and algorithms.
+Home-page: https://github.com/ARAVIND281/ds_toolkit
+Author: Aravind S
+Author-email: aravind@inbo.tech
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# DS Toolkit
+
+DS Toolkit is a Python package providing implementations of common data structures such as Stack, Queue, Linked List, Binary Search Tree (BST), AVL Tree, and more. This toolkit helps developers easily use these data structures in their Python projects.
+
+## Features
+
+- **Stack**: A simple implementation of a stack data structure using Python lists.
+- **Queue**: A basic queue implementation with both list-based and linked list-based options.
+- **Binary Search Tree (BST)**: An implementation of a binary search tree.
+- **AVL Tree**: An implementation of a self-balancing binary search tree.
+- **Union Find**: Data structure for handling disjoint sets.
+
+## Installation
+
+You can install the `ds_toolkit` package directly from PyPI using pip:
+
+```bash
+pip install ds-toolkit
+```
+
+Alternatively, if you want to install it directly from the source, clone the repository and use the following:
+
+```bash
+git clone https://github.com/ARAVIND281/ds_toolkit.git
+cd ds_toolkit
+pip install .
+```
+## Usage
+
+### Stack
+
+The stack is a simple Last In, First Out (LIFO) data structure. You can perform the following operations on the stack:
+
+- **push(value)**: Adds a value to the top of the stack.
+- **pop()**: Removes and returns the value at the top of the stack.
+- **top()**: Returns the value at the top without removing it.
+- **is_empty()**: Checks if the stack is empty.
+- **size()**: Returns the number of elements in the stack.
+- **to_list()**: Returns a list representation of the stack.
+
+#### Example:
+
+```python
+from ds_toolkit.stack import Stack
+
+stack = Stack()
+
+# Push items onto the stack
+stack.push(10)
+stack.push(20)
+
+# Pop the top item
+print(stack.pop())  # Output: 20
+
+# Peek at the top item
+print(stack.top())  # Output: 10
+
+# Check if the stack is empty
+print(stack.is_empty())  # Output: False
+
+# Get the size of the stack
+print(stack.size())  # Output: 1
+
+# Convert stack to list
+print(stack.to_list())  # Output: [10]
+```
+
+### Queue
+
+The queue is a simple First In, First Out (FIFO) data structure. You can perform the following operations on the queue:
+
+### Queue
+
+A queue is a First In, First Out (FIFO) data structure. This means that elements are processed in the order in which they are added, with the first element added being the first one to be removed. The following operations are supported:
+
+- **enqueue(value)**: Adds a value to the end of the queue.
+- **dequeue()**: Removes and returns the value at the front of the queue.
+- **front()**: Returns the value at the front of the queue without removing it.
+- **is_empty()**: Checks if the queue is empty.
+- **size()**: Returns the number of elements in the queue.
+- **to_list()**: Returns the queue as a list.
+
+#### Example:
+
+```python
+from ds_toolkit.queue import Queue
+
+# Create a new Queue instance
+queue = Queue()
+
+# Enqueue items into the queue
+queue.enqueue(10)
+queue.enqueue(20)
+queue.enqueue(30)
+
+# Dequeue the first item (10)
+print(queue.dequeue())  # Output: 10
+
+# Check if the queue is empty
+print(queue.is_empty())  # Output: False
+
+# Get the size of the queue
+print(queue.size())  # Output: 2
+
+# Peek at the front item (20)
+print(queue.front())  # Output: 20
+
+# Convert the queue to a list
+print(queue.to_list())  # Output: [20, 30]
+```
+
+### Binary Search Tree (BST)
+
+A **Binary Search Tree (BST)** is a type of binary tree where each node has at most two children, and for each node:
+
+- The left child has a value less than the node's value.
+- The right child has a value greater than the node's value.
+
+BST supports efficient search, insertion, and deletion operations, with an average time complexity of **O(log n)**.
+
+#### Operations:
+
+- **insert(value)**: Inserts a value into the BST.
+- **search(value)**: Searches for a value in the BST and returns `True` if it exists, otherwise `False`.
+- **delete(value)**: Deletes a node with the given value.
+- **find_min()**: Returns the minimum value in the BST.
+- **find_max()**: Returns the maximum value in the BST.
+- **inorder_traversal()**: Returns a list of values in ascending order (left-root-right traversal).
+- **preorder_traversal()**: Returns a list of values in preorder (root-left-right traversal).
+- **postorder_traversal()**: Returns a list of values in postorder (left-right-root traversal).
+- **height()**: Returns the height (max depth) of the tree.
+
+#### Example:
+
+```python
+from ds_toolkit.bst import BinarySearchTree
+
+# Create a new Binary Search Tree
+bst = BinarySearchTree()
+
+# Insert values into the BST
+bst.insert(50)
+bst.insert(30)
+bst.insert(70)
+bst.insert(20)
+bst.insert(40)
+bst.insert(60)
+bst.insert(80)
+
+# Search for a value
+print(bst.search(40))  # Output: True
+print(bst.search(25))  # Output: False
+
+# Inorder traversal (sorted order)
+print(bst.inorder_traversal())  # Output: [20, 30, 40, 50, 60, 70, 80]
+
+# Find minimum and maximum values
+print(bst.find_min())  # Output: 20
+print(bst.find_max())  # Output: 80
+
+# Delete a node
+bst.delete(20)  # Deletes the node with value 20
+print(bst.inorder_traversal())  # Output: [30, 40, 50, 60, 70, 80]
+
+# Get tree height
+print(bst.height())  # Output: 3 (based on the tree's structure)
+```
+
+### AVL Tree
+
+An **AVL Tree** is a self-balancing binary search tree (BST) where the difference in heights between the left and right subtrees (the balance factor) is at most 1 for all nodes. If the balance factor goes beyond this limit, the tree is rebalanced using rotations.
+
+#### Operations:
+
+- **insert(value)**: Inserts a value into the AVL tree while maintaining the balance.
+- **delete(value)**: Deletes a node with the specified value while maintaining the balance.
+- **search(value)**: Searches for a value in the AVL tree and returns `True` if found, otherwise `False`.
+- **find_min()**: Returns the node with the minimum value.
+- **find_max()**: Returns the node with the maximum value.
+- **height()**: Returns the height (maximum depth) of the AVL tree.
+- **inorder_traversal()**: Returns a list of values in ascending order (left-root-right traversal).
+- **preorder_traversal()**: Returns a list of values in preorder (root-left-right traversal).
+- **postorder_traversal()**: Returns a list of values in postorder (left-right-root traversal).
+
+#### Example:
+
+```python
+from ds_toolkit.avl import AVLTree
+
+# Create a new AVL Tree
+avl = AVLTree()
+
+# Insert values into the AVL Tree
+avl.insert(50)
+avl.insert(30)
+avl.insert(70)
+avl.insert(20)
+avl.insert(40)
+avl.insert(60)
+avl.insert(80)
+
+# Search for a value
+print(avl.search(40))  # Output: True
+print(avl.search(25))  # Output: False
+
+# Inorder traversal (sorted order)
+print(avl.inorder_traversal())  # Output: [20, 30, 40, 50, 60, 70, 80]
+
+# Find minimum and maximum values
+print(avl.find_min())  # Output: 20
+print(avl.find_max())  # Output: 80
+
+# Delete a node
+avl.delete(20)  # Deletes the node with value 20
+print(avl.inorder_traversal())  # Output: [30, 40, 50, 60, 70, 80]
+
+# Get tree height
+print(avl.height())  # Output: 3 (based on the tree's structure)
+```
+
+### Union Find (Disjoint Set Union - DSU)
+
+The **Union Find** data structure efficiently handles the dynamic connectivity problem. It supports two primary operations:
+1. **Union**: Merges two sets into one.
+2. **Find**: Determines which set an element belongs to.
+
+Union Find is commonly used for problems involving connectivity, such as determining connected components in a graph or finding the minimum spanning tree.
+
+#### Operations:
+
+- **find(x)**: Returns the representative (or leader) of the set containing element `x`.
+- **union(x, y)**: Merges the sets containing `x` and `y`.
+- **connected(x, y)**: Returns `True` if `x` and `y` are in the same set, otherwise `False`.
+- **size(x)**: Returns the size of the set containing element `x`.
+- **make_set(x)**: Initializes a set for a new element `x`.
+
+#### Example:
+
+```python
+from ds_toolkit.union_find import UnionFind
+
+# Create a UnionFind object
+uf = UnionFind()
+
+# Add elements to the UnionFind structure
+uf.make_set(1)
+uf.make_set(2)
+uf.make_set(3)
+uf.make_set(4)
+uf.make_set(5)
+
+# Perform union operations
+uf.union(1, 2)  # Union of 1 and 2
+uf.union(3, 4)  # Union of 3 and 4
+uf.union(2, 3)  # Union of 2 and 3 (now 1, 2, 3, and 4 are in the same set)
+
+# Check if two elements are connected
+print(uf.connected(1, 4))  # Output: True (since 1, 2, 3, and 4 are in the same set)
+print(uf.connected(1, 5))  # Output: False (1 and 5 are in different sets)
+
+# Find the representative of a set
+print(uf.find(3))  # Output: 1 (since 1, 2, 3, and 4 are all connected, and 1 is the root)
+
+# Check the size of a set
+print(uf.size(1))  # Output: 4 (the set containing 1, 2, 3, and 4 has size 4)
+```
+
+## Author
+
+This project is maintained by [Aravind S](https://github.com/ARAVIND281). 
+
+If you have any questions or suggestions, feel free to reach out via GitHub or through the issues section of the repository.
+
+### About the Author
+
+This project is developed by **Aravind S**, the founder of **Finmitr** and **Golden Crop**.
+
+- GitHub: [@ARAVIND281](https://github.com/ARAVIND281)
+- Email: [aravind@inbo.tech](mailto:aravind@inbo.tech)
+- Website: [inbo.tech](https://inbo.tech)
+
+You can connect with Aravind on [LinkedIn](https://www.linkedin.com/in/aravinds28/).
+
+---
+
+Thank you for exploring this project!

toolkit_ds-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+ds_toolkit/__init__.py,sha256=08Ocu5wYNMocZPGxslnNzObKOhg8PF_gUTTqQCoalBc,519
+ds_toolkit/avl.py,sha256=UdzABvoavfJWFvGH5Tgon75HkCRKxT80I2KVyl-GKFw,5942
+ds_toolkit/bst.py,sha256=7xjylhH2zo-5RLSKL0Qs8QMBhyrg9obFN0Hwzg4kIvk,3401
+ds_toolkit/doubly_linked_list.py,sha256=pJBEdwUiGng0sSlblNGkZ_MnIUzbJ_i91of8W40XACc,2205
+ds_toolkit/heap.py,sha256=S4j78Jp_gN3tEGujXCx1SJaE0nACO-YC23upiw_PC54,2229
+ds_toolkit/queue.py,sha256=RP82eGM0VAHipXHTI5cxjl5x2IQPsWS3bJ-1zJQ3RpA,2552
+ds_toolkit/singly_linked_list.py,sha256=JkBrP5qid_PWzn5Ddve_8IFVfqlgWc3ZGeTZqCfYkxQ,1798
+ds_toolkit/stack.py,sha256=TSBuyFTqOH5BkHA-6vm8yH4ZmRJEyaRWyvf_SGRnnxM,2313
+ds_toolkit/union_find.py,sha256=ltiO0b4RvtzRd_43FmJ0tVsk37zCK9injnWseryOgKQ,1392
+toolkit_ds-0.1.0.dist-info/LICENSE,sha256=9Tgi4U7pC-bSjx9ChA2A_qii6qX2l5gQCRVgur4jF_w,1068
+toolkit_ds-0.1.0.dist-info/METADATA,sha256=KuL28BOfWxH-rgwL-DwW5-gxx4KxWQtQjmZ7zvdF5Zo,9674
+toolkit_ds-0.1.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+toolkit_ds-0.1.0.dist-info/top_level.txt,sha256=danCqjMv5Iw6sSBe0pawqg47jADt9EFm-_ztB09BeZA,11
+toolkit_ds-0.1.0.dist-info/RECORD,,

toolkit_ds-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.6.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

toolkit_ds-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ds_toolkit