Data Structures and Algorithms Multiple Choice Questions (MCQs) and Answers

The ratio of the number of entries to the number of buckets in the table

The maximum number of collisions allowed before resizing

The percentage of keys that are null

The average search time for an entry

Using a prime number for the size of the hash table

Increasing the size of the keys

Decreasing the number of entries

Using multiple hash functions for the same key

By computing the hash of the key and searching linearly

By directly indexing the array with the key

By computing the hash of the key and using it as an index

By sorting the keys and performing a binary search

Open addressing with linear probing

Storing values in a list at each index

Doubling the hash table size on a collision

Using a secondary hash function

By periodically decreasing the table size

By rehashing all entries into a larger table when the load factor reaches a threshold

By limiting the number of entries

By converting the table to a binary search tree on overflow

Overwriting the previous value

Linking new values to the existing ones in a linked list

Ignoring new values with duplicate keys

Storing values in an adjacent table

The hash function is too complex

The load factor is too high, causing excessive collisions

The keys are not distributed uniformly

All entries are stored in a single bucket

The hash function always returns the same value

Collisions are not handled correctly

The table is full and cannot resize

The key is null

Inconsistent hash function performance

Varying sizes of entries

Periodic table resizing operations

Non-uniform key distribution

Breaking down problems into smaller subproblems

Finding the quickest solution without regard for correctness

Using recursion exclusively

Memorizing intermediate results

When an optimal solution needs to be guaranteed for all cases

When subproblems overlap and are dependent

When subproblems are independent and a local optimum is acceptable

When the problem size is very small

Greedy algorithms consider all possible solutions before making a choice

Dynamic programming uses recursion to solve subproblems

Greedy algorithms make the locally optimal choice at each step

Dynamic programming cannot handle overlapping subproblems

Storing the results of expensive function calls and returning the cached result when the same inputs occur again

Randomly selecting subproblems to solve

Optimizing memory usage by deleting unnecessary data

A technique for improving the runtime of greedy algorithms

The Traveling Salesman Problem

Sorting algorithms

The Knapsack Problem

Binary search

Greedy algorithms evaluate all possible paths before choosing the shortest

Greedy algorithms make a series of localized decisions to find a solution

Brute force methods use recursion exclusively

Brute force methods cannot find global optima

A problem that can be divided into subproblems, which are not related

A problem that does not have a defined optimal solution

A problem where the optimal solution can be constructed from optimal solutions of its subproblems

A problem that can only be solved in linear time

By using a loop to iteratively calculate each number

By storing each Fibonacci number calculated in an array and using it for future calculations

By recursion without memoization

By guessing and checking

Memoization

Tabulation

Backtracking

Divide and conquer

Greedy algorithm

Dynamic programming

Divide and conquer

Backtracking

It reduces the computational complexity

It eliminates the need for calculation

It uses less memory

It relies on simpler mathematical concepts

Because it makes globally optimal choices at each step

Because it makes locally optimal choices without considering the future

Because it evaluates every possible path before making a decision

Because it uses dynamic programming techniques

The problem does not have overlapping subproblems

Subproblems are not being correctly memoized

There are too many subproblems

The base cases are defined incorrectly

Overlooking better solutions due to making premature decisions

Incorrectly assuming the problem has overlapping subproblems

Using too much memory

Not using recursion enough

To find the shortest path between all pairs of nodes

To detect cycles within the graph

To find the shortest path from a single source to all other nodes in the graph

To create a minimum spanning tree

DFS uses a queue, while BFS uses a stack

DFS can find the shortest path; BFS cannot

BFS uses a queue, while DFS uses a stack

DFS is recursive, while BFS cannot be made recursive

A subset of vertices that are mutually reachable by any other vertex in the subset

A component where each vertex is connected to every other vertex by a direct edge

A set of vertices with no incoming edges

A set of vertices in a directed graph where each vertex has the same degree

Finding the shortest path in a graph with negative edge weights

Creating a minimum spanning tree

Finding the maximum flow in a network

Detecting and breaking cycles in a directed graph

Prim's algorithm is used for shortest path finding, while Kruskal's is used for minimum spanning trees

Prim's requires a starting vertex; Kruskal's does not

Prim's is a greedy algorithm; Kruskal's is not

Prim's can handle negative edge weights; Kruskal's cannot

They are used to detect cycles in undirected graphs

They provide a way to schedule tasks with dependencies

They find the shortest path in weighted graphs

They compute the maximum flow in networks

By using a depth-first search and assigning colors to each node

By finding the shortest path between all pairs of nodes

By creating a minimum spanning tree

By performing a matrix multiplication