Algorithms

  1. Sorting and Searching Algorithms
    1. Searching Algorithms
      1. Linear Search
        1. Algorithm Description
          1. Implementation
            1. Iterative Version
              1. Recursive Version
              2. Time Complexity Analysis
                1. Space Complexity
                  1. Variants
                2. Binary Search
                  1. Prerequisites
                    1. Sorted Array Requirement
                      1. Random Access Requirement
                      2. Algorithm Description
                        1. Implementation
                          1. Recursive Implementation
                            1. Iterative Implementation
                            2. Time Complexity Analysis
                              1. Space Complexity
                                1. Variants
                                2. Applications
                                  1. Dictionary Lookups
                                    1. Database Queries
                                  2. Interpolation Search
                                    1. Principle
                                      1. Uniform Distribution Assumption
                                        1. Algorithm Description
                                          1. Time Complexity
                                            1. Best Case
                                              1. Worst Case
                                                1. Average Case
                                            2. Elementary Sorting Algorithms
                                              1. Bubble Sort
                                                1. Algorithm Description
                                                  1. Implementation
                                                    1. Time Complexity Analysis
                                                      1. Best Case
                                                        1. Average Case
                                                          1. Worst Case
                                                          2. Space Complexity
                                                            1. Optimizations
                                                              1. Early Termination
                                                                1. Cocktail Sort
                                                                2. Stability Analysis
                                                                3. Selection Sort
                                                                  1. Algorithm Description
                                                                    1. Implementation
                                                                      1. Time Complexity Analysis
                                                                        1. Space Complexity
                                                                          1. Stability Analysis
                                                                            1. Variants
                                                                              1. Double Selection Sort
                                                                            2. Insertion Sort
                                                                              1. Algorithm Description
                                                                                1. Implementation
                                                                                  1. Time Complexity Analysis
                                                                                    1. Space Complexity
                                                                                      1. Stability Analysis
                                                                                        1. Optimizations
                                                                                          1. Binary Insertion Sort
                                                                                            1. Shell Sort Connection
                                                                                            2. Practical Applications
                                                                                              1. Small Arrays
                                                                                                1. Nearly Sorted Arrays
                                                                                            3. Efficient Sorting Algorithms
                                                                                              1. Merge Sort
                                                                                                1. Divide-and-Conquer Approach
                                                                                                  1. Algorithm Description
                                                                                                    1. Merging Process
                                                                                                      1. Two-Way Merge
                                                                                                        1. Sentinel Values
                                                                                                        2. Implementation
                                                                                                          1. Top-Down Approach
                                                                                                            1. Bottom-Up Approach
                                                                                                            2. Time Complexity Analysis
                                                                                                              1. Space Complexity Analysis
                                                                                                                1. Stability
                                                                                                                  1. Variants
                                                                                                                    1. Natural Merge Sort
                                                                                                                      1. In-Place Merge Sort
                                                                                                                    2. Quick Sort
                                                                                                                      1. Divide-and-Conquer Approach
                                                                                                                        1. Partitioning Process
                                                                                                                          1. Partitioning Schemes
                                                                                                                            1. Lomuto Partition Scheme
                                                                                                                              1. Hoare Partition Scheme
                                                                                                                              2. Pivot Selection Strategies
                                                                                                                                1. First Element
                                                                                                                                  1. Last Element
                                                                                                                                    1. Random Element
                                                                                                                                      1. Median-of-Three
                                                                                                                                      2. Implementation
                                                                                                                                        1. Basic Version
                                                                                                                                          1. Randomized Version
                                                                                                                                            1. Three-Way Partitioning
                                                                                                                                            2. Time Complexity Analysis
                                                                                                                                              1. Best Case
                                                                                                                                                1. Average Case
                                                                                                                                                  1. Worst Case
                                                                                                                                                  2. Space Complexity
                                                                                                                                                    1. Optimizations
                                                                                                                                                      1. Tail Recursion Elimination
                                                                                                                                                        1. Hybrid with Insertion Sort
                                                                                                                                                        2. Variants
                                                                                                                                                          1. Dual-Pivot Quick Sort
                                                                                                                                                        3. Heap Sort
                                                                                                                                                          1. Heap Data Structure Review
                                                                                                                                                            1. Algorithm Description
                                                                                                                                                              1. Heap Construction
                                                                                                                                                                1. Bottom-Up Heapification
                                                                                                                                                                  1. Time Complexity
                                                                                                                                                                  2. Sorting Process
                                                                                                                                                                    1. Extract-Max Operations
                                                                                                                                                                      1. Heap Maintenance
                                                                                                                                                                      2. Implementation
                                                                                                                                                                        1. Time Complexity Analysis
                                                                                                                                                                          1. Space Complexity
                                                                                                                                                                            1. Stability Analysis
                                                                                                                                                                              1. Comparison with Other O(n log n) Sorts
                                                                                                                                                                            2. Linear-Time Sorting Algorithms
                                                                                                                                                                              1. Counting Sort
                                                                                                                                                                                1. Algorithm Description
                                                                                                                                                                                  1. Counting Array Construction
                                                                                                                                                                                    1. Reconstruction Process
                                                                                                                                                                                      1. Implementation
                                                                                                                                                                                        1. Time Complexity Analysis
                                                                                                                                                                                          1. Space Complexity Analysis
                                                                                                                                                                                            1. Stability
                                                                                                                                                                                              1. Limitations
                                                                                                                                                                                                1. Range Dependency
                                                                                                                                                                                                  1. Integer Keys
                                                                                                                                                                                                  2. Variants
                                                                                                                                                                                                    1. Stable Counting Sort
                                                                                                                                                                                                  3. Radix Sort
                                                                                                                                                                                                    1. Principle
                                                                                                                                                                                                      1. Digit-by-Digit Sorting
                                                                                                                                                                                                        1. LSD Radix Sort
                                                                                                                                                                                                          1. Least Significant Digit First
                                                                                                                                                                                                            1. Implementation
                                                                                                                                                                                                            2. MSD Radix Sort
                                                                                                                                                                                                              1. Most Significant Digit First
                                                                                                                                                                                                                1. Implementation
                                                                                                                                                                                                                  1. Recursive Structure
                                                                                                                                                                                                                  2. Time Complexity Analysis
                                                                                                                                                                                                                    1. Space Complexity Analysis
                                                                                                                                                                                                                      1. Stability
                                                                                                                                                                                                                        1. Applications
                                                                                                                                                                                                                          1. Integer Sorting
                                                                                                                                                                                                                            1. String Sorting
                                                                                                                                                                                                                          2. Bucket Sort
                                                                                                                                                                                                                            1. Algorithm Description
                                                                                                                                                                                                                              1. Bucket Distribution
                                                                                                                                                                                                                                1. Uniform Distribution Assumption
                                                                                                                                                                                                                                  1. Hash Function Design
                                                                                                                                                                                                                                  2. Sorting Within Buckets
                                                                                                                                                                                                                                    1. Implementation
                                                                                                                                                                                                                                      1. Time Complexity Analysis
                                                                                                                                                                                                                                        1. Best Case
                                                                                                                                                                                                                                          1. Average Case
                                                                                                                                                                                                                                            1. Worst Case
                                                                                                                                                                                                                                            2. Space Complexity
                                                                                                                                                                                                                                              1. Use Cases
                                                                                                                                                                                                                                                1. Floating Point Numbers
                                                                                                                                                                                                                                                  1. Uniformly Distributed Data
                                                                                                                                                                                                                                              2. Sorting Algorithm Analysis
                                                                                                                                                                                                                                                1. Comparison-Based Sorting
                                                                                                                                                                                                                                                  1. Lower Bound Theory
                                                                                                                                                                                                                                                    1. Decision Tree Model
                                                                                                                                                                                                                                                      1. Information-Theoretic Argument
                                                                                                                                                                                                                                                        1. Ω(n log n) Lower Bound
                                                                                                                                                                                                                                                        2. Stability in Sorting
                                                                                                                                                                                                                                                          1. Importance
                                                                                                                                                                                                                                                            1. Stable vs Unstable Algorithms
                                                                                                                                                                                                                                                              1. Making Unstable Algorithms Stable
                                                                                                                                                                                                                                                              2. In-Place vs Out-of-Place Sorting
                                                                                                                                                                                                                                                                1. Memory Usage
                                                                                                                                                                                                                                                                  1. Space Complexity Classification
                                                                                                                                                                                                                                                                    1. Trade-offs
                                                                                                                                                                                                                                                                    2. Adaptive Sorting
                                                                                                                                                                                                                                                                      1. Performance on Nearly Sorted Data
                                                                                                                                                                                                                                                                      2. Practical Considerations
                                                                                                                                                                                                                                                                        1. Cache Performance
                                                                                                                                                                                                                                                                          1. Memory Hierarchy
                                                                                                                                                                                                                                                                            1. Parallel Sorting
                                                                                                                                                                                                                                                                              1. Hybrid Algorithms
                                                                                                                                                                                                                                                                              2. Sorting Algorithm Selection
                                                                                                                                                                                                                                                                                1. Problem Size Considerations
                                                                                                                                                                                                                                                                                  1. Data Characteristics
                                                                                                                                                                                                                                                                                    1. Memory Constraints
                                                                                                                                                                                                                                                                                      1. Stability Requirements

                                                                                                                                                                                                                                                                                  Previous

                                                                                                                                                                                                                                                                                  3. Algorithmic Design Paradigms

                                                                                                                                                                                                                                                                                  Go to top

                                                                                                                                                                                                                                                                                  Next

                                                                                                                                                                                                                                                                                  5. Graph Algorithms