Data Structures in Python - Full Crash Course

Data Structures Crash Course in Python - Summary

Key Concepts:

• Linked List: Nodes containing data and a pointer to the next node.
• Doubly Linked List: Nodes with pointers to both the next and previous nodes.
• Stack: LIFO (Last-In, First-Out) data structure with push, pop, and peek operations.
• Queue: FIFO (First-In, First-Out) data structure with enqueue and dequeue operations.
• Hashmap: Key-value store using a hash function to map keys to indices.
• Binary Search Tree: Tree structure where left child keys are smaller and right child keys are larger than the parent.
• Heap: Tree-based data structure satisfying the heap property (min-heap or max-heap).
• Try (Prefix Tree): Tree structure optimized for string prefix searching.
• Graph: Data structure consisting of nodes and edges, representing relationships between entities.
• BFS (Breadth-First Search): Graph traversal algorithm exploring neighbors layer by layer.
• DFS (Depth-First Search): Graph traversal algorithm exploring deeply along each branch.

1. Linked Lists and Doubly Linked Lists

• Linked List:
  • Nodes store a value and a pointer (next) to the subsequent node.
  • Traversal requires iterating through nodes (O(n) time complexity).
  • Operations: traverse, display, contains, length, append, prepend, insert, delete, pop, get.
  • Example: append adds a node to the end; if the list is empty, the new node becomes the head.
  • Runtime Complexity: append (O(n)), prepend (O(1)), insert (O(n)), delete (O(n)), contains (O(n)), length (O(n) or O(1) if size is tracked).
• Doubly Linked List:
  • Each node has pointers to both the next (next) and previous (prev) nodes.
  • Facilitates easier prepending and appending (if a tail pointer is maintained).
  • Modifications to append, prepend, insert, and delete to maintain prev pointers.
  • Example: append can be O(1) if a tail pointer is maintained, as the last node is directly accessible.
  • Runtime Complexity: append (O(1) with tail pointer), prepend (O(1)), insert (O(n)), delete (O(n)).

2. Stacks

• Stack:
  • LIFO (Last-In, First-Out) data structure.
  • Operations: push (add to top), pop (remove from top), peek (view top).
  • Implemented using a Node class (value and next pointer).
  • Maintains a top pointer and size for O(1) length lookups.
  • Example: push creates a new node, points it to the current top, and updates the top.
  • Runtime Complexity: push (O(1)), pop (O(1)), peek (O(1)), length (O(1)), is_empty (O(1)).

3. Queues

• Queue:
  • FIFO (First-In, First-Out) data structure.
  • Operations: enqueue (add to rear), dequeue (remove from front), peek (view front).
  • Maintains front and rear pointers for efficient operations.
  • Example: enqueue adds a node to the rear; if the queue is empty, both front and rear point to the new node.
  • Runtime Complexity: enqueue (O(1)), dequeue (O(1)), peek (O(1)), length (O(1)), is_empty (O(1)).

4. Hashmaps

• Hashmap:
  • Key-value store using a hash function to map keys to indices in an array (buckets).
  • Collisions are handled using separate chaining (each bucket is a list).
  • Hash Function: Polynomial rolling hash (string to integer).
    • Converts the key to a string, iterates through characters, and calculates a hash value using ASCII codes and modulo operation.
    • Ensures the hash value is within the capacity of the hashmap.
  • Operations: put (insert/update), get (retrieve), remove (delete), contains (check existence).
  • Example: put calculates the bucket index, iterates through the bucket, updates the value if the key exists, or appends a new key-value pair.
  • Runtime Complexity: put, get, remove, contains (average O(1), worst-case O(n)), length (O(1)), keys, values, items (O(n)).

5. Binary Search Trees

• Binary Search Tree:
  • Tree structure where left child keys are smaller and right child keys are larger than the parent.
  • Operations: insert, search, delete, contains, traverse.
  • Traversal methods: inorder, preorder, postorder (implemented as generators).
  • Deletion Cases:
    • Leaf node: Simply remove the node.
    • Node with one child: Replace the node with its child.
    • Node with two children: Replace the node with its inorder successor.
  • Example: insert navigates the tree based on key comparisons, creating a new node or updating an existing one.
  • Runtime Complexity: insert, search, delete, contains (average O(log n), worst-case O(n)), traverse (O(n)).

6. Heaps

• Heap:
  • Tree-based data structure satisfying the heap property (min-heap or max-heap).
  • Implemented using an array (list) for efficient index-based navigation.
  • Operations: insert, extract_min, peek_min, heapify, melt.
  • Index Calculations:
    • Parent: (index - 1) // 2
    • Left Child: 2 * index + 1
    • Right Child: 2 * index + 2
  • Sift Up (Swim): Moves a node up the tree to restore the heap property.
  • Sift Down (Sink): Moves a node down the tree to restore the heap property.
  • Example: extract_min replaces the root with the last element, then sifts down to maintain the heap property.
  • Runtime Complexity: insert (O(log n)), extract_min (O(log n)), peek_min (O(1)), heapify (O(n)), melt (O(n)).

7. Tries (Prefix Trees)

• Try (Prefix Tree):
  • Tree structure optimized for string prefix searching.
  • Nodes store a dictionary of child nodes (characters) and a flag indicating the end of a word.
  • Operations: insert, search, delete, has_prefix, starts_with, list_words.
  • DFS (Depth-First Search): Used to traverse the tree and collect words.
  • Example: insert creates nodes for each character in the word, setting the is_end_of_word flag for the last character.
  • Runtime Complexity: insert, search, delete, has_prefix (O(m), where m is the length of the word), starts_with (O(m + k), where m is the prefix length and k is the total number of characters in all suffixes), list_words (O(n), where n is the number of nodes in the try).

8. Graphs

• Graph:
  • Data structure consisting of nodes and edges, representing relationships between entities.
  • Can be directed or undirected, weighted or unweighted.
  • Represented using an adjacency list (dictionary of nodes and their neighbors).
  • Operations: add_node, remove_node, add_edge, remove_edge, get_neighbors, has_node, has_edge, get_nodes, get_edges, BFS, DFS.
  • BFS (Breadth-First Search): Explores neighbors layer by layer using a queue.
  • DFS (Depth-First Search): Explores deeply along each branch using a stack.
  • Example: add_edge creates a connection between two nodes, adding the destination node to the source node's neighbor list.
  • Runtime Complexity: Varies depending on the operation and graph representation.

Conclusion:

This crash course provides a practical understanding of fundamental data structures by implementing them from scratch in Python. The video emphasizes the importance of understanding the underlying mechanisms and runtime complexities of these structures, enabling developers to make informed decisions about data structure selection and algorithm design. The implementations cover essential operations and highlight the trade-offs between different approaches, such as using a linked list versus an array for a stack or queue. The inclusion of graph algorithms like BFS and DFS demonstrates the versatility of these structures in solving real-world problems.