Euclid’s GCD. This article describes how to calculate in Java the greatest common divisor of two positive number with Euclid’s algorithm.
1. Euclid’s Algorithm for the Greatest Common Divisor
The greatest common divisor (gcd) of two positive integers is the largest integer that divides both numbers without leaving a remainder. Euclid’s algorithm efficiently computes the gcd by leveraging the following property: if p > q
, then the gcd of p
and q
is the same as the gcd of p % q
and q
.
Here, p % q
is the remainder when p
is divided by q
. For example, 33 % 5
equals 3
.
This property is based on the fact that the gcd of p
and q
must also divide any difference of p
and multiples of q
— such as (p  q)
, (p  2q)
, or (p  3q)
. Thus, instead of repeatedly subtracting q
from p
, Euclid’s algorithm simplifies the process by directly using the remainder p % q
.
This iterative approach continues until the remainder is zero, at which point the other number in the pair is the greatest common divisor.
1.1. Why Recursion?
The Euclidean algorithm lends itself well to recursion because the problem can be broken down into smaller subproblems. Each step reduces the size of the problem by computing p % q
, and the recursion continues until the base case (q == 0
) is reached. This makes the code both concise and easy to understand.
Recursion can be viewed as repeatedly simplifying the problem, as the gcd of p
and q
is reduced to the gcd of q
and p % q
at each step.
1.2. Complexity Analysis
Euclid’s algorithm runs in O(log(min(p, q)))
time, where p
and q
are the input integers. This is due to the fact that with each step, the size of the larger number is reduced by a constant factor.
For example:
* If p
is much larger than q
, then in the first step, p % q
is much smaller than p
.
* As a result, the algorithm quickly reduces the size of the input and terminates after logarithmic steps.
Euclid’s algorithm is therefore highly efficient, even for large inputs.
1.3. Practical Applications
The greatest common divisor is widely used in: * Simplifying Fractions: The gcd is essential for reducing fractions to their simplest form. * Cryptography: Algorithms like RSA make extensive use of the gcd for key generation. * Modular Arithmetic: The gcd is a fundamental operation in number theory, especially for calculating modular inverses. * Game Development: Gcd calculations can be useful in collision detection and in determining ratios in game physics.
Understanding Euclid’s algorithm is a key concept for solving these types of problems efficiently.
1.4. Comparison with Other GCD Algorithms
Euclid’s algorithm is not the only method to calculate the gcd. Other approaches include:

Prime Factorization: This method involves finding the prime factors of both numbers and multiplying the common prime factors. However, this approach is computationally expensive for large numbers.

Binary GCD Algorithm: Also known as Stein’s algorithm, this method uses only binary operations (shifts, subtractions, etc.) and can be more efficient on systems where binary operations are faster than division.
Euclid’s algorithm remains popular due to its simplicity, efficiency, and suitability for most gcdrelated tasks.
2. Implementation in Java
To demonstrate Euclid’s algorithm for finding the greatest common divisor (gcd) in Java, create a new project named com.vogella.algorithms.euclid
. Implement the following program:
package de.vogella.algorithms.euclid;
/**
* A utility class for calculating the greatest common divisor (gcd) of two numbers
* using Euclid's algorithm.
* <p>
* The algorithm is based on the principle that the gcd of two numbers, p and q,
* is equivalent to the gcd of q and p % q (when p is greater than q). The process
* repeats until q is zero, at which point p is the gcd.
*
* @author Lars Vogel
*/
public class GreatestCommonDivisor {
/**
* Calculates the greatest common divisor (gcd) of two integers using recursion.
*
* @param p the first integer
* @param q the second integer
* @return the gcd of p and q
*/
public static int gcd(int p, int q) {
if (q == 0) {
return p;
}
return gcd(q, p % q);
}
/**
* Main method for testing the gcd implementation using assertions.
* <p>
* Enable assertions by adding the VM argument: ea
* </p>
*/
public static void main(String[] args) {
assert gcd(4, 16) == 4 : "Test failed for gcd(4, 16)";
assert gcd(16, 4) == 4 : "Test failed for gcd(16, 4)";
assert gcd(15, 60) == 15 : "Test failed for gcd(15, 60)";
assert gcd(15, 65) == 5 : "Test failed for gcd(15, 65)";
assert gcd(1052, 52) == 4 : "Test failed for gcd(1052, 52)";
System.out.println("All tests passed.");
}
}
2.1. Handling Edge Cases
Euclid’s algorithm can handle most inputs, but it’s important to address edge cases. For example:

When one or both numbers are zero: The gcd of any number
n
and zero isn
. This is already handled by the algorithm whenq == 0
. 
Negative numbers: The gcd of two numbers should be positive. If either input is negative, the algorithm still works, but returning the absolute value ensures a positive gcd.
You can update the code to handle negative numbers as follows:
public static int gcd(int p, int q) {
p = Math.abs(p);
q = Math.abs(q);
if (q == 0) {
return p;
}
return gcd(q, p % q);
}
2.2. Iterative Implementation
While the recursive approach is elegant, you can also implement Euclid’s algorithm iteratively. This avoids potential issues with deep recursion and may be slightly more efficient in certain cases.
public class GreatestCommonDivisorIterative {
public static int gcd(int p, int q) {
while (q != 0) {
int temp = q;
q = p % q;
p = temp;
}
return p;
}
}
This implementation works by continually updating p
and q
until q
becomes zero, at which point p
holds the gcd.
3. Links and Literature
Nothing listed.
3.1. vogella Java example code
If you need more assistance we offer Online Training and Onsite training as well as consulting