The document outlines various algorithms with their time and space complexities, such as linear search, binary search, selection sort, insertion sort, bubble sort, merge sort, and quick sort. Each algorithm is categorized based on its characteristics, including whether it is stable, uses in-place memory, and employs techniques like divide-and-conquer. Key performance metrics for each are provided, detailing their efficiency in terms of time and space requirements.

1. Algorithm
Time Complexity
Space Complexity
Features
Linear Search
O(n)
O(1)
Time: Linear time
Space: Constant time
Memory: In-place
Feature: sequential search, brute-force search
Binary Search
O(log n)
O(1)
Time: Logarithmic Time
Space: Constant time
Memory: not
Feature: divide-and-conquer
Selection Sort
O(n^2)
O(1)
Time: Quadratic Time
Space: Constant time
Memory: In-place
Feature: not stable
Insertion Sort
O(n)
O(1)
Time: Linear Time
Space: Constant time
Memory: In-place
Feature: sequential search
Bubble Sort
O(n)
O(1)

2. Time: Linear Time
Space: Constant time
Memory: not & in-place both variants
Feature: largest element has bubbled to the top of the array
Merge Sort
O(n log (n))
O(n)
Time: Linearithmic time
Space: Linear time
Memory: not
Feature: divide-and-conquer
Quick Sort
O(n log (n))
O(n)
Time: Linearithmic time
Space: Linear time
Memory: In-place
Feature: divide-and-conquer,recursive
Algorithm
Time Complexity
Space Complexity
Features
Linear Search
O(n)
O(1)
Time: Linear time
Space: Constant time
Memory: In-place
Feature: sequential search, brute-force search
Binary Search
O(log n)
O(1)
Time: Logarithmic Time
Space: Constant time
Memory: not
Feature: divide-and-conquer

3. Selection Sort
O(n^2)
O(1)
Time: Quadratic Time
Space: Constant time
Memory: In-place
Feature: not stable
Insertion Sort
O(n)
O(1)
Time: Linear Time
Space: Constant time
Memory: In-place
Feature: sequential search
Bubble Sort
O(n)
O(1)
Time: Linear Time
Space: Constant time
Memory: not & in-place both variants
Feature: largest element has bubbled to the top of the array
Merge Sort
O(n log (n))
O(n)
Time: Linearithmic time
Space: Linear time
Memory: not
Feature: divide-and-conquer
Quick Sort
O(n log (n))
O(n)
Time: Linearithmic time
Space: Linear time
Memory: In-place
Feature: divide-and-conquer,recursive

4. Solution
Algorithm
Time Complexity
Space Complexity
Features
Linear Search
O(n)
O(1)
Time: Linear time
Space: Constant time
Memory: In-place
Feature: sequential search, brute-force search
Binary Search
O(log n)
O(1)
Time: Logarithmic Time
Space: Constant time
Memory: not
Feature: divide-and-conquer
Selection Sort
O(n^2)
O(1)
Time: Quadratic Time
Space: Constant time
Memory: In-place
Feature: not stable
Insertion Sort
O(n)
O(1)
Time: Linear Time
Space: Constant time
Memory: In-place
Feature: sequential search
Bubble Sort
O(n)

5. O(1)
Time: Linear Time
Space: Constant time
Memory: not & in-place both variants
Feature: largest element has bubbled to the top of the array
Merge Sort
O(n log (n))
O(n)
Time: Linearithmic time
Space: Linear time
Memory: not
Feature: divide-and-conquer
Quick Sort
O(n log (n))
O(n)
Time: Linearithmic time
Space: Linear time
Memory: In-place
Feature: divide-and-conquer,recursive
Algorithm
Time Complexity
Space Complexity
Features
Linear Search
O(n)
O(1)
Time: Linear time
Space: Constant time
Memory: In-place
Feature: sequential search, brute-force search
Binary Search
O(log n)
O(1)
Time: Logarithmic Time
Space: Constant time
Memory: not

6. Feature: divide-and-conquer
Selection Sort
O(n^2)
O(1)
Time: Quadratic Time
Space: Constant time
Memory: In-place
Feature: not stable
Insertion Sort
O(n)
O(1)
Time: Linear Time
Space: Constant time
Memory: In-place
Feature: sequential search
Bubble Sort
O(n)
O(1)
Time: Linear Time
Space: Constant time
Memory: not & in-place both variants
Feature: largest element has bubbled to the top of the array
Merge Sort
O(n log (n))
O(n)
Time: Linearithmic time
Space: Linear time
Memory: not
Feature: divide-and-conquer
Quick Sort
O(n log (n))
O(n)
Time: Linearithmic time
Space: Linear time
Memory: In-place
Feature: divide-and-conquer,recursive