A finite set of well-defined steps to solve a problem

A programming language used to write software

Two nested loops each iterating over the input

Dividing the problem in half at each step

The array is automatically resized to a larger block of memory

The new element is stored in a separate linked list

To rearrange elements into a defined order

To find whether a value exists in a collection

To reduce the memory footprint of a data structure

Bubble sort, insertion sort, and merge sort

It partitions the list into elements smaller and larger than itself

It marks the midpoint of the final sorted output

It is always discarded before sorting begins

It can grow or shrink dynamically without reallocating a whole block of memory

It always uses less total memory than an array

It provides constant-time access by index

A reference to the following node in the list

Insertion and removal are only allowed at one end

Customers waiting in line at a ticket counter

To store key-value pairs at positions derived from a hash function

To keep keys sorted in ascending order at all times

To store only the keys, with values kept in a separate file

The heights of its subtrees differ by no more than a small, bounded amount

By following right child links from the root until reaching a node with no right child

By following left child links from the root until reaching a node with no left child

An insertion or deletion that makes a subtree's height difference exceed the allowed limit

Every single search operation performed on the tree

The tree reaching a fixed maximum number of nodes

The shortest path from a source vertex to other vertices in a weighted graph

The minimum number of vertices in a graph

The total weight of edges needed to connect all vertices

The depth of the tallest branch in the graph

The work needed roughly doubles each time the input size doubles

The work needed grows very slowly as the problem size is repeatedly halved

The work needed stays exactly the same no matter the input size

Repeated subproblems that can be solved once and reused

A single subproblem solved exactly one time

No relationship between subproblems at all

Memoization caches results top-down as recursive calls occur, while tabulation fills a table bottom-up

Tabulation always uses more memory than memoization

Memoization cannot be combined with recursion

The minimum number of coins needed to make that amount

Picking the option that looks best right now, without reconsidering earlier choices

Trying every possible combination before deciding

Always picking the smallest available value

Activity selection to maximize the number of non-overlapping activities

Finding all Hamiltonian cycles in a graph

Either take the whole item or leave it out entirely

Take any fractional portion of the item you like

Take the item multiple times without limit

A stack removes the most recently added element first, while a queue removes the oldest

A queue can only store numbers, while a stack can store any type

A stack allows random access by index, while a queue does not

Arrays allow direct constant-time indexing, while linked lists require traversing from the head

DSA Quiz