CSE408

Transform and Conquer

Lecture Unit III

Transform-and-Conquer

•Solve problems through transformation methods.

•Instance Simplification: Make simpler cases.

•Represent problem in a new format.

•Representation Change: Adjust structure.

•Reduce to a known solvable problem.

•Problem Reduction: Use existing algorithms.

Transform-and-Conquer Examples

• Pre Sorting: Sort the input before solving the problem.

• Binary Search Tree

• Finding Minimum and Finding Maximum

• Counting, Radix and Bucket Sort

• Heap and Heap Sort.

• Hashing, Selection Sort and Bubble Sort.

Presorting

Pre-sorting simplifies solving the problem.

Reduces complexity for subsequent operations.

Efficient solutions arise from sorted data.

Sorting helps in faster algorithms later.

Organizing data first improves performance.

Requires sorting before solving the problem.

Common Use Cases for Presorting

Binary search requires sorted input data.

Finding median is faster with sorting.

Merging intervals becomes simpler after sorting.

Closest pair problems benefit from pre-sorting.

Sorting improves search operations in algorithms.

Sorting simplifies problems like range queries.

Binary Search

Binary search works on sorted data.

It divides search space into halves.

Navigates by comparing middle element.

Algorithm runs in O(logn).

Repeatedly narrows down search range.

Yields efficient results in large datasets.

Binary Search
Time Complexity Analysis

•Best Case: O(1)

Target found in middle

•Average Case: O(logn)

Reduces search space by half

•Worst Case: O(logn)

Continues halving until found

Limitations of Binary Search

•Requires sorted data

•Cannot be used on unsorted arrays

•Sorting before search:O(nlogn)

•Not ideal for dynamic data

•Inefficient for frequent updates

•Works best on static data

Use Cases of Binary Search

•Searching in large datasets

•Database lookups

•Indexing in data structures

•Searching in balanced trees

•Optimal for sorted arrays

•Frequently used in algorithms

Balanced Search Trees

•A balanced type of binary tree.

•Keeps tree height small for efficiency.

•Operations: Search, insert, delete optimized.

•Depth proportional to log(n) nodes.

•Ensures logarithmic height for fast operations.

•Avoids degeneration into inefficient structure.

Key Characteristics

•Height-Balanced: Keeps height difference limited.

•Left, right subtree heights differ minimally.

•BST Property: Left keys < node < right.

•Ensures ordered traversal and search.

•Logarithmic Height: Tree height is O(log n).

•Efficient operations: search, insert, delete.

Types of Balanced Search Trees

• AVL Tree:
• Balances the tree by ensuring that the height difference
(balance factor) between the left and right subtrees of any node
is at most 1.
• Uses rotations (single or double) to maintain balance after
insertions or deletions.
• Operations: O(logn).
• Red-Black Tree:
• Balances the tree using color properties and ensures no path
from the root to a leaf is more than twice as long as any other.
• Allows slightly more imbalance than AVL trees but performs
fewer rotations.
• Operations: O(logn).
• B-Tree:
• A generalization of a binary search tree that allows nodes to
have more than two children.
• Often used in databases and file systems due to its efficient
handling of large blocks of data.
• Operations: O(logn).
Splay Tree:
•A self-adjusting tree that moves recently accessed elements
closer to the root for faster access in future operations.
•Not strictly balanced but maintains O(logn) amortized
complexity.
Uses of Balanced Search Trees

•Efficient Operations: Search, insert, O(logn).

Balancing ensures consistent operation speed.

•Avoid Degeneration: Prevents BST becoming a linked list.

Degeneration leads to inefficient O(n)

•Wide Applicability: Databases, memory management, routing.

Handles large-scale data efficiently.

Minimum and Maximum in BST

•Minimum: Leftmost node in the tree.

•Traverse left subtree until null.

•Maximum: Rightmost node in the tree.

•Traverse right subtree until null.

•Efficient retrieval in O(logn).

•Maintains BST properties during operations.

Minimum in a BST

Found at leftmost tree node.

Steps :

Start at the root node.

Traverse left child repeatedly.

Stop at node with no left child.

Smallest Key: Found at this node.

Time Complexity: O(h) tree height.

Maximum in a BST

Found at rightmost tree node.

Steps Start at the root node.

Traverse right child repeatedly.

Stop at node with no right child.

Largest Key: Found at this node.

Time Complexity: O(h), tree height and h=O(logn).

Counting Sort

•Non-comparison-based sorting algorithm.

•Uses frequency count of elements.

•Works efficiently on small ranges.

•Outputs a stable sorted array.

•Requires additional memory for counts.

•Time: O(n+k), Space: O(n+k).

How Counting Sort Works

•Step 1: Identify input value range.

•Step 2: Count frequency of elements.

•Step 3: Compute cumulative counts.

•Step 4: Place elements using counts.

•Step 5: Output sorted array.

•Stable and preserves element order.

Complexity

Time Complexity:
O(n+k)
Where n is the number of elements.
k is the range of values.
Space Complexity:

Space: O(n+k)
Radix Sort

•Non-comparison-based sorting algorithm.

•Sorts digits starting from least significant.

•Uses stable sort for each digit.

•Efficient for fixed range integers.

•Time complexity: O(n⋅d)

•Space complexity: O(n+k).

How Radix Sort Works

•Step 1: Find the maximum value.

•Step 2: Sort by each digit using Counting Sort.

•Step 3: Repeat for all digits.

•Step 4: Output the sorted array.

•Step 5: Start from least significant digit.

•Stable sorting ensures correct order.

Complexity

Time Complexity:
•Best, Average, Worst: O(n⋅d)

where n is the number of elements

d is the number of digits in the largest number.

Space Complexity:
•Space: O(n+k)
Bucket Sort

•Distributes elements into buckets.

•Each bucket is sorted individually.

•Suitable for uniformly distributed data.

•Typically uses Insertion Sort for sorting buckets.

•Time complexity: O(n+k) for uniform data.

•Space complexity: O(n+k)

How Bucket Sort Works

•Step 1: Create empty buckets.

•Step 2: Distribute elements into buckets.

•Step 3: Sort individual buckets (using another sort).

•Step 4: Concatenate sorted buckets into result.

•Step 5: Ideal for evenly distributed data.

•Efficient for data within known range.

Bucket Sort Complexity Analysis

Best Case:

O(n+k) when elements are uniformly distributed.

Worst Case:

O(n^2) when all elements fall into a single bucket.

Average Case:

O(n+k+n⋅logn), assuming balanced distribution.

Space Complexity: O(n+k) due to the bucket array.

Heap

•Heap: A complete binary tree.

Max-Heap: Parent nodes are greater than children.

Min-Heap: Parent nodes are smaller than children.

Heap Property: Ensures efficient access

Time Complexity:

Insertion: O(logn).

Deletion: O(logn).
Heap Sort

Heap Sort: A comparison-based sorting algorithm.

Steps:

1.Build a max-heap.

2.Extract the root (max element) and place it at the end.

3.Restore heap property.

Complexity

•Time Complexity:

•Best, Average, Worst: O(nlogn).

•Space Complexity:

•O(1), in-place sorting.

Hashing

Hashing: Technique for mapping data to fixed-size values.

Hash Function: Converts keys to indices in a hash table.

Hash Table: Array-based structure for storing key-value pairs.

Collision: Occurs when two keys map to the same index.

Handling Collisions:

Chaining: Store multiple elements in the same index.

Open Addressing: Probe for the next available index.

Complexity

Time Complexity (Average):

Insert, Search, Delete: O(1)

Time Complexity (Worst Case):

O(n) for collision-heavy scenarios.

Selection Sort

•Simple, intuitive sorting algorithm.

•Finds smallest or largest element.

•Moves to correct position iteratively.

•Inefficient for larger datasets.

•Best for small, simple cases.

•Slower than Quick or Merge Sort.

How Selection Sort Works

•Start with the first element.

•Iterate the list, finding the minimum element in the unsorted part.

•Swap found minimum element with first element of the unsorted part.

•Move the boundary of the sorted part by one element.

•Repeat until the entire list is sorted.

Key Characteristics:

Time Complexity:

Worst : O(n^2) Average : O(n^2) Best Case: O(n^2)

Space Complexity: O(1) (In-place sorting)

Stable: No, unless extra logic is added for stability.

Use Cases: Small datasets , where simplicity is preferred over

performance.
Bubble Sort

•Simple comparison-based algorithm.

•Repeatedly swaps adjacent elements.

•Moves larger elements upward.

•Stops when no swaps occur.

•Inefficient for large datasets.

•Time complexity: O(n^2)

How Bubble Sort Works

•Compare adjacent elements.

•Swap if out of order.

•Largest element "bubbles up."

•Repeat for unsorted part.

•Stop when no swaps occur.

•Sorted list is produced.

Complexity

Best Case: O(n)(Already sorted).

Worst Case: O(n^2)

Average Case: O(n^2)

Space Complexity: O(1) (In-place).

Many comparisons and swaps.

Inefficient for large datasets.