The Uses of Algorithms Quiz

Analysing and designing an algorithm involves understanding the problem, identifying inputs and outputs, and breaking the task into logical steps. The algorithm should be efficient, clear, and suitable for implementation in code. 

The suitability of an algorithm depends on factors such as the size and structure of the dataset, required speed, and memory constraints. For example, binary search is efficient for sorted data, while linear search is more suitable for small or unsorted datasets. 

Time complexity measures how long an algorithm takes to run as input size increases, while space complexity measures how much memory it uses. Both are important for evaluating performance. 

Big O notation describes the upper bound of an algorithm’s growth rate. It is useful because it allows comparison of algorithms independent of hardware or implementation details. 

Constant time O(1) means execution time does not change with input size. Linear time O(n) grows proportionally. Logarithmic time O(log n) grows slowly as input increases. Polynomial time (e.g., O(n²)) grows more rapidly. Exponential time O(2ⁿ) grows very quickly and is often impractical. 

Algorithms can be compared by analysing their time and space complexity, considering best, worst, and average cases, and evaluating how they perform with different input sizes. 

Stacks use a last-in, first-out approach, with algorithms involving push and pop operations. Queues use a first-in, first-out approach, with enqueue and dequeue operations. These structures are used in tasks like function calls and task scheduling. 

Linked lists are traversed by following pointers from one node to the next. Elements can be added or removed by updating pointers, making them flexible but less efficient for random access. 

Depth-first traversal (post-order) processes child nodes before the parent, while breadth-first traversal explores nodes level by level. These methods are used for searching and processing tree structures. 

Linear search checks each element sequentially, making it simple but inefficient for large datasets. Binary search repeatedly divides a sorted list, making it much faster but requiring sorted data. 

Bubble sort repeatedly swaps adjacent elements until sorted, but it is inefficient for large datasets. Insertion sort builds a sorted list one element at a time and is more efficient for small or nearly sorted datasets. 

Merge sort divides the list into smaller parts, sorts them, and merges them back together, offering consistent performance. Quick sort selects a pivot and partitions the data, often faster in practice but with a worst-case scenario of poor performance. 

Dijkstra’s algorithm finds the shortest path between nodes in a graph by exploring the lowest-cost paths first. It is widely used in navigation systems and network routing. 

The A* algorithm improves on Dijkstra’s by using heuristics to guide the search, making it faster in many cases. It is commonly used in pathfinding for games and robotics. 

The choice of algorithm significantly impacts performance. Efficient algorithms reduce execution time and resource usage, which is critical in large-scale systems such as search engines, financial systems, and real-time applications.