Data Structures

  1. Linear Data Structures
    1. Arrays
      1. Definition and Properties
        1. Fixed-size Arrays
          1. Dynamic-size Arrays
            1. Homogeneous Elements
            2. Memory Representation
              1. Contiguous Memory Allocation
                1. Address Calculation
                2. Static Arrays
                  1. Declaration and Initialization
                    1. Limitations
                    2. Dynamic Arrays
                      1. Dynamic Memory Allocation
                        1. Resizing Strategies
                          1. Amortized Analysis
                          2. Core Operations
                            1. Access Operations
                              1. Random Access
                                1. Indexing
                                2. Search Operations
                                  1. Linear Search
                                    1. Binary Search on Sorted Arrays
                                    2. Insertion Operations
                                      1. Insertion at End
                                        1. Insertion at Beginning
                                          1. Insertion at Arbitrary Position
                                          2. Deletion Operations
                                            1. Deletion by Index
                                              1. Deletion by Value
                                            2. Complexity Analysis
                                              1. Time Complexity of Operations
                                                1. Space Complexity
                                                2. Multi-dimensional Arrays
                                                  1. Two-dimensional Arrays
                                                    1. Higher-dimensional Arrays
                                                      1. Row-major Order
                                                        1. Column-major Order
                                                      2. Linked Lists
                                                        1. Core Concepts
                                                          1. Nodes and Pointers
                                                            1. Node Structure
                                                              1. Pointer Manipulation
                                                              2. Head Pointer
                                                                1. Tail Pointer
                                                                  1. Sentinel Nodes
                                                                  2. Types of Linked Lists
                                                                    1. Singly Linked Lists
                                                                      1. Forward Traversal
                                                                      2. Doubly Linked Lists
                                                                        1. Bidirectional Traversal
                                                                          1. Additional Memory Overhead
                                                                          2. Circular Linked Lists
                                                                            1. Circular Singly Linked List
                                                                              1. Circular Doubly Linked List
                                                                            2. Core Operations
                                                                              1. Traversal Operations
                                                                                1. Iterative Traversal
                                                                                  1. Recursive Traversal
                                                                                  2. Search Operations
                                                                                    1. Linear Search
                                                                                    2. Insertion Operations
                                                                                      1. Insertion at Beginning
                                                                                        1. Insertion at End
                                                                                          1. Insertion at Specific Position
                                                                                          2. Deletion Operations
                                                                                            1. Deletion from Beginning
                                                                                              1. Deletion from End
                                                                                                1. Deletion from Specific Position
                                                                                              2. Complexity Analysis
                                                                                                1. Time Complexity of Operations
                                                                                                  1. Space Complexity
                                                                                                  2. Arrays vs Linked Lists Comparison
                                                                                                    1. Memory Usage
                                                                                                      1. Access Patterns
                                                                                                        1. Performance Trade-offs
                                                                                                      2. Stacks
                                                                                                        1. LIFO Principle
                                                                                                          1. Stack Order and Behavior
                                                                                                          2. Stack ADT
                                                                                                            1. Interface Specification
                                                                                                            2. Core Operations
                                                                                                              1. Push Operation
                                                                                                                1. Pop Operation
                                                                                                                  1. Peek Operation
                                                                                                                    1. IsEmpty Operation
                                                                                                                      1. IsFull Operation
                                                                                                                      2. Implementation Approaches
                                                                                                                        1. Array-based Implementation
                                                                                                                          1. Fixed-size Stack
                                                                                                                            1. Dynamic Stack
                                                                                                                            2. Linked List-based Implementation
                                                                                                                            3. Applications of Stacks
                                                                                                                              1. Function Call Stack
                                                                                                                                1. Recursion Handling
                                                                                                                                2. Expression Evaluation
                                                                                                                                  1. Infix to Postfix Conversion
                                                                                                                                    1. Postfix Evaluation
                                                                                                                                      1. Prefix Evaluation
                                                                                                                                      2. Undo and Redo Functionality
                                                                                                                                        1. Syntax Parsing
                                                                                                                                      3. Queues
                                                                                                                                        1. FIFO Principle
                                                                                                                                          1. Queue Order and Behavior
                                                                                                                                          2. Queue ADT
                                                                                                                                            1. Interface Specification
                                                                                                                                            2. Core Operations
                                                                                                                                              1. Enqueue Operation
                                                                                                                                                1. Dequeue Operation
                                                                                                                                                  1. Peek Operation
                                                                                                                                                    1. IsEmpty Operation
                                                                                                                                                      1. IsFull Operation
                                                                                                                                                      2. Implementation Approaches
                                                                                                                                                        1. Array-based Implementation
                                                                                                                                                          1. Linear Queue
                                                                                                                                                            1. Circular Array Queue
                                                                                                                                                            2. Linked List-based Implementation
                                                                                                                                                            3. Queue Variations
                                                                                                                                                              1. Double-Ended Queue
                                                                                                                                                                1. Insertion at Both Ends
                                                                                                                                                                  1. Deletion at Both Ends
                                                                                                                                                                  2. Priority Queue
                                                                                                                                                                    1. Priority Assignment
                                                                                                                                                                      1. Heap-based Implementation
                                                                                                                                                                    2. Applications of Queues
                                                                                                                                                                      1. Task Scheduling
                                                                                                                                                                        1. Buffering Systems
                                                                                                                                                                          1. Producer-Consumer Problem
                                                                                                                                                                          2. Breadth-First Search

                                                                                                                                                                      Previous

                                                                                                                                                                      1. Introduction to Data Structures and Algorithms

                                                                                                                                                                      Go to top

                                                                                                                                                                      Next

                                                                                                                                                                      3. Hierarchical Data Structures