Algorithm Analysis: Binary Search

Overview

Binary search is an efficient algorithm for finding an item in a sorted array. It works by repeatedly dividing the search interval in half.

Time Complexity

The time complexity of binary search is $O(\log n)$O(logn), where $n$n is the number of elements in the array. This is because we eliminate half of the remaining elements with each comparison.

Algorithm Flow

Rendering diagram...

Implementation

def binary_search(arr, target):
    low, high = 0, len(arr) - 1
    
    while low <= high:
        mid = (low + high) // 2
        
        if arr[mid] == target:
            return mid
        elif arr[mid] > target:
            high = mid - 1
        else:
            low = mid + 1
    
    return -1

Space Complexity

Binary search uses $O(1)$O(1) auxiliary space for the iterative version, making it very memory-efficient.

Main Document Title

Introduction

Brief overview of the topic.

Core Concepts

Concept 1

Detailed explanation of the first concept.

Implementation Details

Specific implementation notes.

Concept 2

Detailed explanation of the second concept.

Advanced Topics

Performance Optimization

Tips for improving performance.

Conclusion

Summary and next steps.

Understanding Recursion

The Concept

Recursion is when a function calls itself to solve smaller instances of the same problem.

The Analogy

Think of Russian nesting dolls. To see the smallest doll, you must first open each larger doll. Each doll contains a smaller version of itself, until you reach the base case—the smallest doll that doesn't open.

The Example

Here's a recursive function to calculate factorial:

def factorial(n):
    # Base case: factorial of 0 or 1 is 1
    if n <= 1:
        return 1
    # Recursive case: n! = n × (n-1)!
    return n * factorial(n - 1)

The Visualization

Rendering diagram...

The mathematical representation: $n! = n \times (n-1)!$n!=n×(n−1)! with base case $0! = 1$0!=1

System Architecture

Our microservices architecture separates concerns and enables independent scaling:

Rendering diagram...

Key Components:

• API Gateway: Single entry point, handles routing and rate limiting
• Auth Service: JWT-based authentication, session management
• User Service: User profiles, preferences, and settings
• Order Service: Order processing, inventory management
• Redis Cache: Reduces database load, improves response times

Time Complexity Analysis

Bubble Sort

Bubble sort repeatedly steps through the list, compares adjacent elements, and swaps them if they're in the wrong order.

Best Case: $O(n)$O(n) - Array is already sorted, only one pass needed

Average Case: $O(n^2)$O(n2) - Random order requires multiple passes

Worst Case: $O(n^2)$O(n2) - Array is reverse sorted

The number of comparisons in the worst case is:

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        swapped = False
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                swapped = True
        if not swapped:  # Optimization for best case
            break
    return arr

Space Complexity: $O(1)$O(1) - Sorts in place with no additional arrays

Binary Search Implementation

Here's a complete implementation of binary search with error handling:

from typing import List, Optional

def binary_search(arr: List[int], target: int) -> Optional[int]:
    """
    Search for target in sorted array using binary search.
    
    Args:
        arr: Sorted list of integers
        target: Value to search for
        
    Returns:
        Index of target if found, None otherwise
        
    Time Complexity: O(log n)
    Space Complexity: O(1)
    """
    if not arr:
        return None
        
    low, high = 0, len(arr) - 1
    
    while low <= high:
        mid = (low + high) // 2
        
        if arr[mid] == target:
            return mid
        elif arr[mid] > target:
            high = mid - 1
        else:
            low = mid + 1
    
    return None

# Example usage
numbers = [1, 3, 5, 7, 9, 11, 13, 15]
result = binary_search(numbers, 7)
print(f"Found at index: {result}")  # Output: Found at index: 3

result = binary_search(numbers, 6)
print(f"Found at index: {result}")  # Output: Found at index: None

Key Points:

• Type hints for clarity
• Docstring with complexity analysis
• Handles edge case (empty array)
• Includes example usage with expected output

Merge Sort: A Divide-and-Conquer Algorithm

Overview

Merge sort is an efficient, stable sorting algorithm that uses the divide-and-conquer paradigm. It divides the array into smaller subarrays, sorts them recursively, and then merges them back together.

Algorithm Visualization

Rendering diagram...

Time Complexity

The recurrence relation for merge sort is:

Using the Master Theorem, this resolves to:

This holds for all cases (best, average, and worst), making merge sort very predictable.

Space Complexity

Merge sort requires $O(n)$O(n) auxiliary space for the temporary arrays used during merging.

Implementation

def merge_sort(arr):
    """
    Sort array using merge sort algorithm.
    
    Time: O(n log n)
    Space: O(n)
    """
    if len(arr) <= 1:
        return arr
    
    # Divide
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    
    # Conquer (merge)
    return merge(left, right)

def merge(left, right):
    """Merge two sorted arrays."""
    result = []
    i = j = 0
    
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    
    result.extend(left[i:])
    result.extend(right[j:])
    return result

When to Use Merge Sort

Advantages:

• Guaranteed $O(n \log n)$O(nlogn) performance
• Stable sort (preserves relative order)
• Predictable performance

Disadvantages:

• Requires $O(n)$O(n) extra space
• Slower than quicksort in practice for small arrays

Best for: Large datasets where stability matters and extra space is available.

POST /api/users

Create a new user account.

Request

POST /api/users HTTP/1.1
Content-Type: application/json
Authorization: Bearer <token>

{
  "email": "user@example.com",
  "name": "John Doe",
  "role": "developer"
}

Response

Success (201 Created):

{
  "id": "usr_123",
  "email": "user@example.com",
  "name": "John Doe",
  "role": "developer",
  "created_at": "2024-01-15T10:30:00Z"
}

Error (400 Bad Request):

{
  "error": "validation_error",
  "message": "Invalid email format",
  "field": "email"
}

Parameters

Authentication

Requires a valid JWT token with users:create permission.

Rate Limiting

• 10 requests per minute per IP
• 100 requests per hour per account

Example

import requests

response = requests.post(
    "https://api.example.com/api/users",
    headers={"Authorization": f"Bearer {token}"},
    json={
        "email": "user@example.com",
        "name": "John Doe",
        "role": "developer"
    }
)

if response.status_code == 201:
    user = response.json()
    print(f"Created user: {user['id']}")

Authentication API

Version: 2.0 | Last Updated: 2024-01-15

What's New in v2.0

• JWT tokens replace API keys
• OAuth 2.0 support added
• Refresh token rotation implemented

Migration from v1.0

If you're using v1.0 API keys, follow this migration guide:

Before (v1.0)

headers = {"X-API-Key": "your-api-key"}
response = requests.get(url, headers=headers)

After (v2.0)

headers = {"Authorization": f"Bearer {jwt_token}"}
response = requests.get(url, headers=headers)

Deprecation Notice

⚠️ v1.0 API keys will be deprecated on June 1, 2024. Please migrate to JWT tokens before this date.

View v1.0 Documentation (archived)