OCR A2 Computing
F453:17 - Data Structures and Data Manipulation
Page 1 of 8
Data Structures and Data Manipulation
OCR Specification Points
3.3.5 Data structures and data manipulation
Topics:
•
•
Implementation of data structures, including stacks, queues and trees.
Searching, merging and sorting.
Candidates should be able to:
• explain how static data structures may be used to implement dynamic data structures;
• describe algorithms for the insertion, retrieval and deletion of data items stored in stack,
queue and tree structures;
• explain the difference between binary searching and serial searching, highlighting the
advantages and disadvantages of each;
• explain how to merge data files;
• explain the differences between the insertion and quick sort methods, highlighting the
characteristics, advantages and disadvantages of each.
Data Structures
A data structure is a way of storing data in a way that its position has meaning.
- e.g. Listing names in alphabetical order would give their position meaning.
There are a number of structures that can be used.
- For example:
 Arrays and Records
 Serial, sequential, indexed sequential and direct access files
- When these are used will depend on the circumstances – the most appropriate structure for
the data should be used.
Data Structures can be grouped into two main categories:
- Dynamic
- Static
Implementation of Static Data Structures
Arrays and Lists
Static Data Structures
Data structure whose size is fixed when it is created in memory.
• e.g. Array (or List)
This shows an example of an array stored in memory in alphabetical order.
Here decisions about the array must be made before it is used:
Daniel Jones
OCR A2 Computing
F453:17 - Data Structures and Data Manipulation
• Name
• Data type
• Size
• Shape (number of dimensions)
This example is a list as it is one dimensional.
• You can have arrays with many dimensions.
Arrays are accessed by providing the array name and its index (from 0).
• e.g. People[2] would output “Janet” (with real address 5)
Advantages:
• Little to no risk of overflow or underflow errors – as it will always take
up the same space in memory.
• This will most likely be reserved so no other program can access it
• The program/memory management system can allocate a fixed amount
of memory.
Page 2 of 8
2
….
People
Array
Index
3
Ben
0
4
Harry
1
5
Janet
2
6
Harry
3
7
Louise
4
8
…
N/A
9
….
N/A
Disadvantages:
• Requires knowledge of the size of the array before it has been created. This can result in:
• Waste of resources – once they have been reserved the space it can no longer be used by other
processes/data.
• Running out of space when the prediction of space is too little.
Implementation of Dynamic Data Structures
Linked Lists, Queues, Stacks, Binary Trees and their implementation.
There are four type of dynamic data structures we need to know:
1. Linked List
2. Queue
3. Stack
4. Binary Trees
Linked List
A linked list is similar to an array in that it stores a list of values, however it is dynamic and can be
extended or shortened to the size of the data inside it at will.
To do this pointers are used:
- Each data item no holds two pieces of information:
1. Data = the original data the item held.
2. Pointer = the address of the next item in the list.
- The Start Pointer stores the address of the first item in the list.
1. This is what actually allows the list to be accessed by the program.
- The last item in the lists’ pointer will be Null (blank).
1. This indicates the end of the list.
2. Called a Null Pointer.
Inserting an item simply requires:
- Change pointer of previous item to its new location.
Daniel Jones
OCR A2 Computing
F453:17 - Data Structures and Data Manipulation
Page 3 of 8
- Make its equal to the previous pointers old value.
Deleting an item simply requires:
- Taking its pointer value, and replacing the previous items’ pointer value with this.
Static and Dynamic Data Structures Comparison
Static
Data structure whose size is fixed when it is created in memory.
• e.g. Array
Advantages:
• The program/memory management system can allocate a fixed amount of memory.
• No risk of overflow or underflow errors
- As it will always take up the same space in memory.
Disadvantages:
- Requires knowledge of the size of the array before it has been created. This can result in:
- Waste of resources – once they have been reserved the space it can no longer be used
by other processes/data.
- Running out of space when the prediction of space is too little.
- Any manipulation other than adding or taking from the end requires moving large amounts of
the data.
- Inefficient use of memory and cpu-time.
Dynamic
Data structure which will extend and change its size to fit the data.
- e.g. Linked List
Advantages:
- Can extend as far as physically possible – more flexible.
- Allows for the program to be more easily written – less must be determined at compilation
time.
- Inserting, merging and deleting of items is very easy and requires little processing power.
Disadvantages:
- Unnecessary + inefficient for small amounts of data.
 In this case the size of the data may be even smaller than the extra data needed to
make it dynamic.
- Data can be highly fragmented over extended use. This may cause a physical bottleneck when
the hardware needs to access this data.
Queues
A queue is a data structure, similar in implementation to a list/array.
- However it implements a “First In First Out” (FIFO or LILO) order.
 Hence le queue!
 So is therefore a “serial structure where the position is related to the chronological
appearance of the data”.
- It can grow and shrink in size.
Daniel Jones
OCR A2 Computing
F453:17 - Data Structures and Data Manipulation
Page 4 of 8

For example if items are being processed faster than they are being added to the
queue, the queues size will be smaller.
- Have two pointers:
 Head Pointer holds the address of the oldest item in the queue (next to be read).
 Tail Pointer holds the free address before the most recently added item in the
queue (last to be read).
There are two operations you can do to a queue:
- Enqueue = putting something on the end of the queue.
 Value added to address pointed to by tail pointer.
 The tail pointer is then incremented.
- Dequeue = reading and removing the item at the front of the queue.
 Value at head pointer read.
 Head pointer incremented.
Stack
A stack is a method of storing data following the first in last out (FILO) principle.
A stack pointer is used to store the location of the most recently added item of the stack.
• Used to read the data.
• Note: Only the value pointed to by the stack pointer can be read at any time.
Push = the action of adding something to the stack.
• Stack Pointer Incremented (7=>8)
• Value is then stored in the address represented by stack pointer.
Pop = the action of removing an item from the top of the stack.
• Stack Pointer is decremented (8=>7)
• Note: The data does not need to be deleted as there is no longer any reference to it.
Binary Trees
A binary tree is data structure which stores items of data.
- Each item of data points to another tw o. (binary!)
- The direction in which they are pointed gives their
position meaning.
 Can be used to sort alphabetically (as the example
has been).
If the traversing algorithm is known.
- The first node is called the root node.
- Each pointer (arrow) is a possible path from the node
- After each new set of items are created they are called a
new layer.
Daniel Jones
Chloe
Barry
Alex
Terence
Ben
Becky
Bex
Example of a binary tree.
OCR A2 Computing
F453:17 - Data Structures and Data Manipulation
The syllabus specifies one way of traversing trees:
1. If there is a left branch that has yet to be traversed, then follow it and
repeat.
2. Read the node if it hasn’t already been read.
3. I there is a right branch traverse it and go back to 1.
4. Go back up one layer.
Page 5 of 8
Follow this shape, but
recursively.
However other algorithms can be used.
- Such as the method used to traverse binary trees for Reverse Polish.
Implementing a Binary Tree
Binary Trees are implemented using a “linked list of arrays”.
• Each node is represented by an array containing:
- Data the node represents
- Pointer to righ t hand child node ↴
- Pointer to left hand child node → (null if on an
end of the tree)
• The pointers store the address in memory of the
nodes’
children.
- In this way it acts as a linked list.
Example binary tree represented as arrays in memory:
Root Node = 0
Each node
represented
by an array of
length 3.
Daniel Jones
Example node with associated data.
OCR A2 Computing
F453:17 - Data Structures and Data Manipulation
Page 6 of 8
Implementing Stack and Queue’s
Static data structures can be used to implement dynamic data structures.
- This is because most computers do not implement dynamic data structures
natively. And so these must be developed in code.
- Often higher level languages will have implement ations built in.
 e.g. This is done by vb.net .
A stack can be implemented by using an array.
- Methods can be added to the array class to
allow popping and pushing to an array.
 And it will be stored identically in memory.
- However a linked list can be used as well. This provides
a more flexible implementation.
 Meaning the stack does not need to take up a
continuous
section of memory.
 It can also remove the source of some stack
overflows errors.
As when the available continuous memory runs out can
simply point to more free space. (as opposed to writing over
other data).
Array stored in memory as a stack by
restricting access to the top item only
(highest index -> “Louise”).
A similar method can be applied to create a queue but by restricting reading/deleting (enqueue) to the
top, and adding (dequeue) to the bottom.
Data Manipulation
Methods of searching, sorting and merging lists/files.
Searching
Linear Searches
A serial search is where a list is searched in order from its’ first to its’ last item.
- This list is not necessarily ordered (but can be).
- Can be slow – especially as the dataset increases.
- As there is no order of items, it will have to check each item on the list before it
can determine the item does not exist.
 Inefficient/waste of cpu time.
A sequential search is a linear search performed on an ordered dataset.
- Main advantage over serial searching is that if the item does not exist, this can
be determined more quickly.
 When it passes the point where the item should be, it will stop.
Daniel Jones
OCR A2 Computing
F453:17 - Data Structures and Data Manipulation

Page 7 of 8
e.g. When looking for “Ben” in fig.1, will stop when it gets to
“Beth” – as
“Beth” is after “Ben” in the alphabet.
Binary Search
A binary search is a method of searching data which has been pre-sorted.
- Works by splitting the list in two each time, and taking the section which
contains the data item.
 Hence le binary (two)
- Very efficient – much faster than a serial search.
 Will take a maximum of log2[Number of items in the list] iterations
to find a specific value.
 As opposed to [Number of items in the list] for a serial/linear
search.
The algorithm can be summarised as: (in a LIST of length N)
- Find midpoint value of list: LIST[N/2]
 If an odd number, round up e.g. 13/2 = 6.5 = 7 -> LIST[7]
- If target = midpoint, item found at index of midpoint.
- If target is greater than midpoint, delete all values above.
If target is smaller than midpoint, delete all values below.
- Go back to 1.
Sorting
Insertion Sort
A method of sorting in which each item is copied from the file into a new file, in the correct position.
- Simple, but has some disadvantages:
 Inefficient use of time – very slow.
 Requires a lot space in memory.
Algorithm:
1. Read each value, storing the address of the smallest.
2. When all have been read:
a. Copy smallest to the first place in the new file
b. Remove smallest from old file.
3. Go back to 1, until the old file is empty.
Quick Sort
A Quick sort is an alternative method sorting.
- Complicated, and cumbersome method but...
 Becomes increasingly efficient as the number of items increases.
 Relatively easy to program.
Algorithm:
- Display list in a row, with a fixed arrow on the first value, and a movable arrow on the last
(however does not actually matter)
- If the two pointed to values are in the right order:
 Move the movable arrow towards the centre.
- Else:
Daniel Jones
OCR A2 Computing
-
F453:17 - Data Structures and Data Manipulation
 Swap the arrows.
Repeat 2-3. until arrows are adjacent – the middle item is now in the correct place.
Repeat with sub lists on either side the correctly ordered item.
 This is a good exemplar use of recursion.
Merging
A merge sort is a method of merging two already sorted (sequential) files.
Outline:
1. Read first value from each file
2. Compare
3. Write smallest value to new file
4. Read next value from file used
5. Back to 2. until no more items are left.
6. Write remainder of longest file to new file.
Daniel Jones
Page 8 of 8