Euclidean algorithm

The Euclidean algorithm, often known as Euclid's algorithm, is an effective way to determine the greatest common divisor (GCD), or the biggest number that divides two integers (numbers) evenly and without leaving a remainder. It was initially described in the 300 BC book The Elements by the Greek mathematician Euclid, for whom it was called. One of the first algorithms still in use, an algorithm is a step-by-step process for carrying out a computation in accordance with predetermined principles. It is a component of several number-theoretic and cryptographic calculations and may be used to simplify fractions. There are several theoretical and real-world uses for the Euclidean algorithm. It is employed in conducting division in modular arithmetic as well as simplifying fractions. This algorithm is employed in both strategies for cracking these cryptosystems by factoring very big composite numbers as well as the cryptographic protocols that safeguard internet communications.

The greatest common divisor of two positive integers can be discovered using the Euclidean method. The greatest integer that divides two numbers evenly is called the GCD. Factorizing both integers and multiplying common prime factors is an easy approach to find GCD.

GCD's fundamental Euclidean algorithm:

The following facts form the basis of the algorithm.

GCD remains same if we lower a larger integer by subtracting a smaller one from it. Therefore, if we continually deduct the greater of two, we arrive at GCD.
Now, if we divide the smaller number rather of subtracting it, the process halts when we reach the final result of 0.

A recursive function to calculate GCD using Euclid's approach is provided below:

// C++ program to demonstrate
// Basic Euclidean Algorithm
#include <bits/stdc++.h>
using namespace std;
// Function to return
// gcd of a and b
int gcd(int a, int b)
{
	if (a == 0)
		return b;
	return gcd(b % a, a);
}
// Driver Code
int main()
{
	int a = 10, b = 15;

	// Function call
	cout << "GCD(" << a << ", " << b << ") = " << gcd(a, b)
		<< endl;
	a = 35, b = 10;
	cout << "GCD(" << a << ", " << b << ") = " << gcd(a, b)
		<< endl;
	a = 31, b = 2;
	cout << "GCD(" << a << ", " << b << ") = " << gcd(a, b)
		<< endl;
	return 0;
}

Output

GCD(10, 15) = 5
GCD(35, 10) = 5
GCD(31, 2) = 1
.................................
Process executed in 1.11 seconds
Press any key to continue.

Time Complexity: O (Log min(a, b))

Auxiliary Space: O (Log (min(a,b))

Extended Euclidean Algorithm

Additionally, the extended Euclidean method discovers integer coefficients x and y such that axe + by = gcd(a, b) is true.

Input: a = 30, b = 20
Output: gcd = 10, x = 1, y = -1
(Note that 30*1 + 20*(-1) = 10)

Input: a = 35, b = 15
Output: gcd = 5, x = 1, y = -2
(Note that 35*1 + 15*(-2) = 5)

The results of the recursive call gcd(b%a, a) are used by the extended Euclidean algorithm to update the results of gcd(a, b). Let x1 and y1 be the recursively derived values for x and y. Using the equations shown below, x and y are updated.

ax + by = gcd(a, b)
gcd(a, b) = gcd(b%a, a)
gcd(b%a, a) = (b%a)x1 + ay1
ax + by = (b%a)x1 + ay1
ax + by = (b - [b/a] * a)x1 + ay1
ax + by = a(y1 - [b/a] * x1) + bx1

Comparing LHS and RHS,
x = y1 - ⌊b/a⌋ * x1
 y = x1

An application of the aforesaid strategy is shown below:

// C++ program to demonstrate working of
// extended Euclidean Algorithm
#include <bits/stdc++.h>
using namespace std;
// Function for extended Euclidean Algorithm
int gcdExtended(int a, int b, int *x, int *y)
{
	// Base Case
	if (a == 0)
	{
		*x = 0;
		*y = 1;
		return b;
	}
	int x1, y1; // To store results of recursive call
	int gcd = gcdExtended(b%a, a, &x1, &y1);

	// Update x and y using results of
	// recursive call
	*x = y1 - (b/a) * x1;
	*y = x1;
	return gcd;
}
// Driver Code
int main()
{
	int x, y, a = 35, b = 15;
	int g = gcdExtended(a, b, &x, &y);
	cout << "GCD(" << a << ", " << b
		<< ") = " << g << endl;
	return 0;
}

Output

gcd(35, 15) = 5
..........................
Process executed in 1.11 seconds
Press any key to continue.

Time Complexity: O (log N)

Auxiliary Space: O (log N)

How does Extended Algorithm Work?

As seen above, x and y are results for inputs a and b,
a.x + b.y = gcd             --(1) 
And x1 and y1 are results for inputs b%a and a
(b%a).x1 + a.y1 = gcd  
When we put b%a = (b - (⌊b/a⌋).a) in above,
we get following. Note that ⌊b/a⌋ is floor(b/a)
(b - (⌊b/a⌋).a).x1 + a.y1  = gcd
Above equation can also be written as below
b.x1 + a.(y1 - (⌊b/a⌋).x1) = gcd             -(2)
After comparing coefficients of 'a' and 'b' in (1) and
(2), we get following,
x = y1 - ⌊b/a⌋ * x1
y = x1

How Can an Extended Algorithm Be Useful?

When a and b are coprime (or gcd is 1), the extended Euclidean method is quite helpful. Since y is the modular multiplicative inverse of "b modulo a," and x is the inverse of "a modulo b," In instance, a crucial step in the RSA public-key encryption method is the computation of the modular multiplicative inverse.

Next TopicFloyd's Algorithm

← prev next →