Time complexity is the measure of time an algorithm takes to run, while space complexity is the measure of memory an algorithm uses.

Space complexity is the speed at which an algorithm executes.

Time complexity refers to the amount of data an algorithm can process.

Time complexity is the total number of lines in an algorithm.

Best case: average performance; Worst case: minimum performance; Average case: maximum performance.

Best case: minimum performance; Worst case: maximum performance; Average case: expected performance.

Best case: expected performance; Worst case: average performance; Average case: minimum performance.

Best case: maximum performance; Worst case: expected performance; Average case: minimum performance.

The substitution method is a technique for solving recurrence relations by guessing a solution and proving it by induction.

The substitution method requires solving the recurrence relation using matrix algebra.

The substitution method is a graphical technique for visualizing recurrence relations.

The substitution method involves using a calculator to solve equations directly.

O(n)

O(log n)

O(n^2)

O(1)

Binary search can be applied to unsorted data without any preprocessing.

Binary search is faster than linear search because it reduces the search space exponentially.

Binary search requires more comparisons than linear search.

Linear search is more efficient for large datasets than binary search.

O(1)

O(n)

O(log n)

O(n log n)

Interpolation search is best used for uniformly distributed sorted arrays, particularly when the dataset is large and the values are evenly distributed.

Interpolation search is primarily used for searching in linked lists.

Interpolation search can be used for any type of data distribution.

Interpolation search is effective for small, unsorted datasets.

A complex algorithm that uses dynamic programming to find substrings.

The naive string matching algorithm is a straightforward method for finding a substring in a string by checking each position for a match.

An algorithm that sorts the string before searching for the substring.

A method that only checks the first character of the string for matches.

It employs a binary search method to locate patterns.

The algorithm relies on sorting the text and patterns.

The Rabin-Karp algorithm works by using hashing to efficiently search for patterns in a text.

It uses brute force to find patterns in the text.

It has a linear time complexity compared to the naive algorithm's quadratic time complexity.

It uses a brute-force approach for pattern matching.

It requires more memory than the naive algorithm.

It can only match patterns of fixed length.

F(n) = F(n-1) + F(n-2) with F(0) = 0 and F(1) = 1

F(n) = F(n-1) * F(n-2) with F(0) = 1 and F(1) = 1

F(n) = 2F(n-1) with F(0) = 0

F(n) = F(n-1) - F(n-2) with F(0) = 1 and F(1) = 2

The Master Theorem is a method for solving differential equations.

The Master Theorem applies only to linear recurrences.

The Master Theorem simplifies the analysis of recurrences in divide-and-conquer algorithms.

The Master Theorem is used to optimize sorting algorithms.

Space complexity is irrelevant to algorithm performance.

Space complexity is only determined by the number of variables used.

Space complexity is measured in bytes rather than Big O notation.

Space complexity is determined by analyzing the amount of memory an algorithm uses relative to the input size, expressed in Big O notation.

Fast execution for all dataset sizes.

Inefficiency for large datasets and unsuitable for sorted data.

Always finds the target in sorted data.

Requires less memory than binary search.

When the data is sorted in descending order.

When the data is uniformly distributed.

When the data is highly skewed.

When the dataset is small and unsorted.

O(n * m)

O(m)

O(n + m)

O(n)

The KMP algorithm sorts the pattern before searching.

The KMP algorithm generates a random sequence from the pattern.

The KMP algorithm uses a hash table to store the pattern.

The KMP algorithm preprocesses the pattern by creating a longest prefix-suffix (LPS) array.

The prefix table determines the length of the pattern to be searched.

The prefix table helps in skipping unnecessary comparisons in the KMP algorithm.

The prefix table is used to store the final results of the KMP algorithm.

The prefix table is a data structure that holds the frequency of characters in the pattern.

The average case is always the same as the worst case.

The average case complexity is irrelevant for searching algorithms.

The average case complexity of a searching algorithm is determined by analyzing the expected number of operations over all possible inputs.

Average case analysis only applies to sorting algorithms.