It includes:
- Student Learning Record (A3 version in word)
- Student Learning Record (PDF version)
- Student Learning Record (PowerPoint version)
- Set of student activities and workshops with answers
- Answers to the exam questions from the back of the SLR
- Teacher Marking Checklist
- Year 13 Recap Lesson
This topic covers:
H046
- 2.3.1 a-f Algorithms
H446
- 2.3.1 a-f Algorithms
Specific knowledge required for AS Level:
- Candidates need to be able to write algorithms using flow charts, pseudocode and program code.
- Candidates need to be able to follow the code as shown in the OCR pseudocode guide, but are not expected to write code in this syntax.
- Candidate’s code is not expected to be syntactically correct, but must use appropriate code structures.
- Candidates need to understand the need for standard sorting algorithms.
- Candidates need to understand how the sorting algorithms bubble and insertion work and the situations when each can, and cannot be used.
- Candidates need to be able to use the algorithms to sort data, and complete, write and correct algorithms to perform each sorting algorithm.
- Candidates need to understand the need for standard searching algorithms.
- Candidates need to understand how the searching algorithms binary and linear work and the situations when each can, and cannot be used.
- Candidates need to be able to use the algorithms to search data sets for specific values that may, or may not exist in the data set.
- Candidates need to understand when each searching algorithm can, and cannot be used.
- Candidates need to be able to complete, write and correct algorithms to perform each searching algorithm.
- Candidates should have experience of using the data structures stacks and queues.
- Candidates need to understand the differences and similarities between stacks and queues.
- Candidates need to be able to add and remove data from both stacks and queues.
- Candidates need to understand how pointers are used within stacks and queues.
- Candidates need to understand how stacks and queues can be implemented in a computer system, for example through the use of an array with pointers.
- Candidates need to be able to read, correct and write algorithms to add and remove data items, and manipulate data items in a stack and queue. Candidates need to understand how the choice of algorithm can be affected by the data set.
- Candidates need to understand the impact of specific algorithms on speed and memory use.
- Candidates are not expected to know about Big O notation, but should be aware of how and when a program can use more memory, or can take longer to run and be able to compare algorithms to determine which will use more/less memory, and which will run faster/slower.
Specific knowledge required for A Level:
- Candidates need to be able to write algorithms using flow charts, pseudocode and program code.
- Candidates need to be able to follow the code as shown in the OCR pseudocode guide, but are not expected to write code in syntax.
- Candidates’ code is not expected to be syntactically perfect, but must use appropriate structures and techniques.
- Candidates need to understand that there are a range of possible solutions to a task, and that these algorithms may be different in respect to their execution time and the amount of memory they make use of.
- Candidates need to be able to compare different algorithms for a given data set and demonstrate an understanding of which is more efficient in terms of speed and/or memory.
- Candidates need to be able to compare the use of one or more algorithms against several different data sets, to determine how they will differ in their use of memory and speed of execution.
- Candidates need to understand how the efficiency of an algorithm is measured using Big O notation.
- Candidates need to understand the meaning of constant, linear, polynomial, exponential and logarithmic complexity. They need to be able to recognise and draw each of these complexities of using a graph and be able to read and write the notation.
- Candidates need to know the best and worst case complexities for the searching and sorting methods.
- Candidates need to understand the difference between best case, average case and worst case complexities and how and why these can differ for an algorithm. Candidates need to have an understanding of the situations where queues, stacks, trees etc. can be used and be able to recommend and justify their use In specific scenarios or programs.
- Candidates need to have an understanding of a stack as a dynamic data structure.
- Candidates need to be able to add and remove items to a stack.
- Candidates need to be able read, trace and write code to implement a stack structure (including adding and removing items).
- Candidates need to understand how a stack can be implemented using a different data structure, such as a static array.
- Candidates need to have an understanding of a queue as a dynamic data structure.
- Candidates need to be able to add and remove data to/from a queue.
- Candidates need to be able to read, trace and write code to implement a queue structure (including adding and removing items).
- Candidates need to understand how a queue can be implemented using a different data structure, such as a static array. Candidates need to have an understanding of a tree structure, both binary and multi branch trees.
- Candidates need to be able to add and remove data to/from a tree.
- Candidates need to be able to read, trace and write code to implement a tree structure (including adding and removing items).
- Candidates need to understand how a tree can be implemented using a different data structure, such as a linked list.
- Candidates need to understand why and how trees are traversed.
- Candidates need to understand how a depth-first (post-order) traversal works, and be able to perform the traversal on a tree.
- Candidates need to be able to read, trace and write code for a post-order traversal.
- Candidates need to understand how a breadth-first traversal works, and be able to perform the search on a tree.
- Candidates need to be able to read, trace and write code for a breadth-first traversal on a tree.
