AQA A-Level Computer Science 4.2 Fundamentals of data structures overview quiz quiz

An array holds items of many different types, whereas a record can only ever hold a single type

They are completely identical and the two terms can be used interchangeably

A record can only ever hold integer values, while an array can hold any type

An array holds many items of the same type; a record groups fields of different types

It can grow and shrink at run time using the heap

Its maximum size is fixed when the program is first compiled

It can only ever store numeric values

It is always faster to access than any static structure

Last in, first out order

First in, first out

Largest value removed first

Random unpredictable order

It always removes the item with the highest priority value first, like a priority queue

It can store items of many different data types at once

It reuses freed slots by wrapping the pointers with modulo arithmetic

It can never become full no matter how many items are added

Because a stack is a first-in first-out structure

Because it automatically sorts the subroutine calls into order

Because a stack always uses far less memory than an equivalent queue

Because the most recent call must return first, matching LIFO order

For a sparse graph with few edges, to save memory

For a dense graph that has a very large number of edges between nodes

When fast constant-time edge lookup is essential

Never, because an adjacency matrix is always the better choice

The values in descending order

The values in ascending sorted order

The values in the order they were inserted

Only the leaf nodes

When the hash table completely runs out of available memory space

When a key is deleted from the table by the program

When two different keys hash to the same index

When the hash function is far too slow to compute

Using a binary search tree

Using a linear array

Using a stack

Using a hash table

Post-order

Pre-order

In-order

Level-order

Data redundancy, where the same data is needlessly stored many times over

Deadlock, where two operations each wait for a record the other holds

A hash collision between two keys

A stack overflow from deep recursion