124 Algorithm design methods

Learn how to translate a software specification into a clear and testable algorithm using structured design strategies.

Outline

This section introduces the process of designing algorithms within the software development lifecycle. You will learn how to interpret problem briefs, apply strategic thinking to problem decomposition, and use structured methods to outline algorithms using pseudocode and flowcharts. We will draw on industry-aligned models such as top-down and bottom-up design, and prepare you to test, refine, and document your solutions using best-practice approaches.

Targets

In this topic, students learn to:

• Analyse software specifications to identify processes, inputs, and outputs

• Apply top-down and bottom-up approaches to break down complex problems

• Structure mainline logic and subprograms for clarity and modularity

• Design algorithms using strategy patterns, including divide and conquer and backtracking

• Use desk checking and trace tables to validate logic and test edge cases

• Link algorithm design to software development models such as Waterfall and Agile

Glossary

mainline logic

The top-level flow of an algorithm, typically calling subroutines to complete each part of the task.

top-down design

The top-level flow of an algorithm, typically calling subroutines to complete each part of the task.

bottom-up design

Building simple modules first, then integrating them into larger solutions.

divide and conquer

A problem-solving technique that divides the problem into parts and solves each recursively.

backtracking

An algorithm design technique that explores possible solutions and abandons invalid paths.

refinement

The process of expanding a high-level step into more detailed algorithmic steps.

desk checking

Manually walking through an algorithm with test inputs to check correctness.

trace table

A table used to track variable values and control flow during an algorithm's execution.

Overview

Designing algorithms is one of the most critical stages in software engineering. It bridges the gap between understanding the problem and implementing a solution in code. This process begins with analysis: What are the inputs? What outputs are expected? What logical decisions and repetitions are needed?

Effective algorithm design often begins with top-down decomposition. This means breaking a complex task into manageable subroutines. Each subroutine can then be refined until its function is clear and easily implemented. This approach is supported by structure charts, which show the hierarchy and flow of data between modules.

Alternatively, a bottom-up strategy can be used where familiar, well-tested modules are developed independently and combined into a working system. This method is standard in Agile development, where reusable components and libraries may already exist.

Advanced design strategies like divide and conquer are essential for solving complex or recursive problems, such as searching or sorting. Backtracking is used in problems where multiple solution paths must be explored, such as puzzles or constrained optimisation problems.

Developers might use desk checking and trace tables to test algorithms' logic before coding. These help identify logic errors, unexpected outputs, or infinite loops before any syntax is introduced. Testing at this stage supports good design and avoids unnecessary rework later in development.

In a formal development process like Waterfall, algorithm design is front-loaded and documented thoroughly. In Agile, algorithms may be iteratively refined based on user feedback and testing during sprints.

This section builds directly on earlier learning in control structures and algorithm representation. We are shifting the focus from how to write algorithms to how to design and validate them. Developing these skills will support later project work and the handling of exam-style questions requiring algorithmic thinking.