Euclid’s algorithm & recursion

The greatest common divisor

The greatest common divisor of two nonnegative integers, not both zero, is the largest positive integer dividing both. For 48 and 18, the common divisors are 1, 2, 3 and 6; the greatest is 6.

The source introduces Euclid’s method for efficiently computing this value. The implementation contains both a recursive gcd and an iterative gcd2, allowing the same mathematical idea to be studied in two forms.

Why remainders preserve the answer

Write p = kq + r, where r is p modulo q. Every divisor of p and q also divides r = p − kq. Conversely, a divisor of q and r divides p = kq + r. Therefore the two pairs have exactly the same common divisors.

Replacing (p, q) by (q, r) preserves the answer and shrinks the second argument when q is positive. When q is zero, p is the answer.

A complete dry run: gcd(48, 18)

48 = 2 × 18 + 12, so replace (48, 18) with (18, 12). Next, 18 = 1 × 12 + 6, giving (12, 6). Finally, 12 = 2 × 6 + 0, giving (6, 0). The zero second argument triggers the base case, returning 6.

• Call 1: gcd(48, 18) → gcd(18, 12).
• Call 2: gcd(18, 12) → gcd(12, 6).
• Call 3: gcd(12, 6) → gcd(6, 0).
• Call 4: return 6; the suspended calls return the same value.

The source examples: 12, 10 and 270, 192

The original lecture first lists divisors. For 30, 36 and 24, the common divisors are 1, 2, 3 and 6, so their GCD is 6. For 13 and 48, only 1 is common, so they are coprime.

For gcd(12, 10), use 12 = 10 × 1 + 2, then 10 = 2 × 5 + 0. The result is 2. For gcd(270, 192), the remainders are 78, 36, 6 and 0, giving a GCD of 6. These preserve the worked inputs from the source pages.

The source also explains the subtraction form: gcd(A, B) = gcd(B, A − B). Repeated subtraction gives gcd(A − QB, B), which is the remainder step when Q is the quotient. The proof works in both directions: a common divisor of A and B divides their difference, and a common divisor of B and A − B divides their sum A.

Reading the original code

In gcd, if (q == 0) return p is the stopping condition. The recursive call passes q as the next first argument and p % q as the next second argument. No work is required after that call returns.

In gcd2, temp preserves the old q before q is overwritten. Updating p = temp completes the state transition. Omitting the temporary value would mix the old and new states.

The original comment warns that negative inputs may produce a negative result. This code is preserved as supplied. For the standard positive GCD interpretation, use nonnegative inputs. The code returns 0 for (0, 0), while the largest-positive-divisor definition does not define that case.

How fast does the problem shrink?

For positive inputs, the number of remainder steps is O(log min(p, q)); consecutive Fibonacci numbers produce the slowest Euclidean reduction pattern. This counts arithmetic operations, assuming each integer remainder is a unit-cost operation.

The iterative version uses O(1) extra variables. The recursive version uses O(log min(p, q)) call frames in the worst case. With arbitrary-precision integers, arithmetic operations themselves have a size-dependent cost.

Remember for revision

Explain both preservation and progress: the GCD does not change, and a positive remainder is smaller than its divisor. State the input assumptions when discussing correctness or complexity.

Original implementations

Read the complete original code and its documentation. Core algorithm pages add a walkthrough, complexity discussion and a worked example.

Check your understanding

Supplementary practice. Try each question before opening the answer.