Array on Swayam Blog

Array

Sun, 02 Feb 2025 00:00:00 +0000

1. Sorting Algorithms

Sorting arranges elements in a specific order (ascending or descending).

Bubble Sort – Repeatedly swaps adjacent elements if they are in the wrong order.
Selection Sort – Selects the smallest/largest element and places it in order.
Insertion Sort – Builds the sorted array one element at a time.
Merge Sort – Uses the divide-and-conquer technique to sort.
Quick Sort – Selects a pivot and partitions elements around it.
Heap Sort – Uses a binary heap to sort efficiently.
Radix Sort – Sorts numbers digit by digit.
Counting Sort – Counts occurrences of elements (used for small range values).
Sorting

2. Searching Algorithms

Used to find an element in an array.

Linear Search – Searches sequentially from start to end.
Binary Search – Searches in a sorted array by dividing it into halves.
Jump Search – Jumps ahead by fixed steps and performs a linear search.
Interpolation Search – Improved binary search that assumes a uniform distribution of values.
Exponential Search – Useful for searching in unbounded or infinite-sized arrays.
Searching

3. Two-Pointer Techniques

Used for problems requiring element comparison or sum-based conditions.

Two-Sum Problem – Find two numbers in an array that add up to a target.
Three-Sum Problem – Find three numbers that sum to a target.
Dutch National Flag Algorithm – Used for sorting arrays with three types of elements (e.g., 0s, 1s, and 2s).

4. Divide and Conquer Algorithms

Breaks the array into smaller parts, solves each, and merges results.

Merge Sort – Recursively divides and merges sorted parts.
Quick Sort – Uses a pivot to partition the array.
Binary Search – Recursively searches a sorted array.

5. Greedy Algorithms

Make the best choice at each step to find an optimal solution.

Activity Selection Problem – Select maximum non-overlapping activities.
Interval Scheduling – Schedule tasks with given constraints.

6. Sliding Window Algorithms

Efficiently finds a subarray or subset in an array.

Fixed Window Size – Finds max/min sum of a subarray of size k.
Variable Window Size – Used for finding the smallest subarray with a sum ≥ target.
Maximum Sum Subarray (Kadane’s Algorithm) – Finds the largest sum of contiguous subarrays.

7. Hashing-Based Algorithms

Use hash tables for quick lookups and frequency counting.

Two Sum (Hash Map Approach) – Stores values and looks for complements.
Subarray with Zero Sum – Uses hashing to detect if a sum has occurred before.
Longest Consecutive Sequence – Uses a hash set to track elements.

8. Dynamic Programming (DP) Algorithms

Used for optimization problems.

Longest Increasing Subsequence (LIS) – Finds the longest increasing sequence.
0/1 Knapsack Problem – Determines the best way to pack items into a knapsack.
Subset Sum Problem – Finds if a subset with a given sum exists.
Coin Change Problem – Finds the minimum number of coins for a given amount.

9. Matrix Manipulation Algorithms

Arrays can be represented as matrices for solving problems.

Rotate a Matrix (90 degrees, 180 degrees, etc.)
Spiral Order Traversal – Traverse a 2D array in a spiral.
Flood Fill Algorithm – Used in image processing (similar to DFS/BFS).
Pathfinding (Dijkstra’s, Floyd-Warshall, etc.) – Find shortest paths in graphs represented as matrices.

10. Bit Manipulation Algorithms

Use bitwise operations to solve problems efficiently.

Finding the Single Non-Repeating Element (XOR Trick)
Counting Set Bits (Brian Kernighan’s Algorithm)
Subsets using Bitmasking – Generate all subsets using bitwise operations.

Searching

Sun, 02 Feb 2025 00:00:00 +0000

1. Linear Search

Approach: Sequentially checks each element in the array.
Time Complexity:
- Best: O(1)
- Worst: O(n)
- Average: O(n)
Space Complexity: O(1)

2. Binary Search (For Sorted Arrays Only)

Approach: Repeatedly divides the array in half and searches in the relevant half.
Time Complexity:
- Best: O(1)
- Worst: O(log n)
- Average: O(log n)
Space Complexity:
- O(1) (Iterative)
- O(log n) (Recursive, due to function call stack)

3. Jump Search (For Sorted Arrays)

Approach: Jumps ahead by a block size (√n) and does a linear search within that block.
Time Complexity:
- Best: O(1)
- Worst: O(√n)
- Average: O(√n)
Space Complexity: O(1)

4. Interpolation Search (For Uniformly Distributed Sorted Data)

Approach: Uses the formula to estimate the probable position of the target. $$ pos=left+ \frac {(target−arr[left])×(right−left)}{(arr[right]−arr[left])} $$

Time Complexity:
- Best: O(1)
- Worst: O(n) (when data is skewed)
- Average: O(log log n)
Space Complexity: O(1)

5. Exponential Search (For Unbounded Sorted Arrays)

Approach: Starts with small steps (1, 2, 4, 8…) to find a suitable range, then uses Binary Search.
Time Complexity:
- Best: O(1)
- Worst: O(log n)
- Average: O(log n)
Space Complexity: O(1)

6. Fibonacci Search (For Sorted Arrays)

Approach: Uses Fibonacci numbers instead of dividing by 2 like Binary Search.
Time Complexity:
- Best: O(1)
- Worst: O(log n)
- Average: O(log n)
Space Complexity: O(1)

Comparison Table

Algorithm	Best Case	Worst Case	Average Case	Space Complexity	Sorted Array Required?
Linear Search	O(1)	O(n)	O(n)	O(1)	No
Binary Search	O(1)	O(log n)	O(log n)	O(1) / O(log n)	Yes
Jump Search	O(1)	O(√n)	O(√n)	O(1)	Yes
Interpolation Search	O(1)	O(n)	O(log log n)	O(1)	Yes
Exponential Search	O(1)	O(log n)	O(log n)	O(1)	Yes
Fibonacci Search	O(1)	O(log n)	O(log n)	O(1)	Yes

Sorting

Sat, 01 Feb 2025 00:00:00 +0000

Sort

1. Comparison-Based Sorting

These algorithms compare elements to determine their order.

a. Bubble Sort

Repeatedly swaps adjacent elements if they are in the wrong order.
Time Complexity: O(n²)
Space Complexity: O(1)

b. Selection Sort

Finds the smallest element and places it in the correct position.
Time Complexity: O(n²)
Space Complexity: O(1)

c. Insertion Sort

Picks one element at a time and places it in its correct position.
Time Complexity: O(n²)
Space Complexity: O(1)
Efficient for small or nearly sorted data.

d. Merge Sort (Divide and Conquer)

Divides the array into halves, sorts them, and merges them.
Time Complexity: O(n log n)
Space Complexity: O(n)

e. Quick Sort (Divide and Conquer)

Picks a pivot, partitions the array, and sorts recursively.
Time Complexity: O(n log n) (Best & Avg), O(n²) (Worst)
Space Complexity: O(log n) (due to recursion)

f. Heap Sort

Converts the array into a heap and extracts elements in order.
Time Complexity: O(n log n)
Space Complexity: O(1)

g. Shell Sort

Variation of insertion sort that sorts elements at a gap.
Time Complexity: O(n log n) (Best), O(n²) (Worst)
Space Complexity: O(1)

2. Non-Comparison-Based Sorting

These algorithms do not compare elements directly.

a. Counting Sort

Counts occurrences of elements and places them in sorted order.
Time Complexity: O(n + k) (k is range of numbers)
Space Complexity: O(k)
Works only for integer values with a known range.

b. Radix Sort

Sorts numbers digit by digit using counting sort as a subroutine.
Time Complexity: O(nk) (k is number of digits)
Space Complexity: O(n + k)
Works well for fixed-size numbers like integers.

c. Bucket Sort

Divides elements into buckets and sorts each bucket individually.
Time Complexity: O(n + k) (depends on bucket distribution)
Space Complexity: O(n + k)
Works well for uniformly distributed data.

3. Hybrid Sorting Algorithms

These algorithms combine multiple sorting techniques.

a. Tim Sort

Combination of Merge Sort and Insertion Sort.
Used in Python’s built-in sorting (sorted() and .sort()).
Time Complexity: O(n log n)
Space Complexity: O(n)

b. Introsort

Hybrid of Quick Sort, Heap Sort, and Insertion Sort.
Used in C++ STL sort().
Time Complexity: O(n log n)
Space Complexity: O(log n)

Choosing the Right Sorting Algorithm

Algorithm	Best Case	Worst Case	Average Case	Space Complexity	Stable?
Bubble Sort	O(n)	O(n²)	O(n²)	O(1)	Yes
Selection Sort	O(n²)	O(n²)	O(n²)	O(1)	No
Insertion Sort	O(n)	O(n²)	O(n²)	O(1)	Yes
Merge Sort	O(n log n)	O(n log n)	O(n log n)	O(n)	Yes
Quick Sort	O(n log n)	O(n²)	O(n log n)	O(log n)	No
Heap Sort	O(n log n)	O(n log n)	O(n log n)	O(1)	No
Counting Sort	O(n + k)	O(n + k)	O(n + k)	O(k)	Yes
Radix Sort	O(nk)	O(nk)	O(nk)	O(n + k)	Yes
Bucket Sort	O(n + k)	O(n²)	O(n)	O(n + k)	Yes
Tim Sort	O(n)	O(n log n)	O(n log n)	O(n)	Yes