# Stein’s Algorithm for finding GCD

Stein’s algorithm or binary GCD algorithm is an algorithm that computes the greatest common divisor of two non-negative integers. Stein’s algorithm replaces division with arithmetic shifts, comparisons, and subtraction.

Examples:

```Input: a = 17, b = 34
Output : 17

Input: a = 50, b = 49
Output: 1
```

Algorithm to find GCD using Stein’s algorithm gcd(a,b)

1. If both a and b are 0, gcd is zero gcd(0, 0) = 0.
2. gcd(a, 0) = a and gcd(0, b) = b because everything divides 0.
3. If a and b are both even, gcd(a, b) = 2*gcd(a/2, b/2) because 2 is a common divisor. Multiplication with 2 can be done with bitwise shift operator.
4. If a is even and b is odd, gcd(a, b) = gcd(a/2, b). Similarly, if a is odd and b is even, then
gcd(a, b) = gcd(a, b/2). It is because 2 is not a common divisor.
5. If both a and b are odd, then gcd(a, b) = gcd(|a-b|/2, b). Note that difference of two odd numbers is even
6. Repeat steps 3–5 until a = b, or until a = 0. In either case, the GCD is power(2, k) * b, where power(2, k) is 2 raise to the power of k and k is the number of common factors of 2 found in step 2.

Iterative Implementation

```// Iterative C++ program to implement Stein's Algorithm
#include<bits/stdc++.h>
using namespace std;

//Function to implement Stein's Algorithm
int gcd(int a, int b)
{
/* GCD(0, b) == b; GCD(a,0) == a, GCD(0,0) == 0 */
if (a == 0)
return b;
if (b == 0)
return a;

/*Finding K, where K is the greatest power of 2
that divides both a and b. */
int k;
for (k = 0; ((a | b) & 1) == 0; ++k)
{
a >>= 1;
b >>= 1;
}

/* Dividing a by 2 until a becomes odd */
while ((a & 1) == 0)
a >>= 1;

/* From here on, 'a' is always odd. */
do
{
/* If b is even, remove all factor of 2 in b */
while ((b & 1) == 0)
b >>= 1;

/* Now a and b are both odd. Swap if necessary
so a <= b, then set b = b - a (which is even).*/
if (a > b)
swap(a, b);   // Swap u and v.

b = (b - a);
}   while (b != 0);

/* restore common factors of 2 */
return a << k;
}

// Driver code
int main()
{
int  a = 34, b = 17;
printf("Gcd of given numbers is %d\n", gcd(a,b));
return 0;
}
```

Output:

```Gcd of given numbers is 17
```

Recursive Implementation

```//Recursive C++ program to implement Stein's Algorithm
#include<bits/stdc++.h>
using namespace std;

//Function to implement Stein's Algorithm
int gcd(int a, int b)
{
if (a == b)
return a;

/* GCD(0,b) == b; GCD(a,0) == a, GCD(0,0) == 0 */
if (a == 0)
return b;
if (b == 0)
return a;

// look for factors of 2
if (~a & 1 )        // a is even
{
if (b & 1)      // b is odd
return gcd(a >> 1, b);
else            // both a and b are even
return gcd(a >> 1, b >> 1) << 1;
}

if (~b & 1)         // a is odd, b is even
return gcd(a, b >> 1);

// reduce larger number
if (a > b)
return gcd((a - b) >> 1, b);

return gcd((b - a) >> 1, a);
}

// Driver code
int main()
{
int  a=34, b=17;
printf("Gcd of given numbers is %d\n", gcd(a,b));
return 0;
}
```

Output:

```Gcd of given numbers is 17
```

Time Complexity: O(N*N) where N is the number of bits in the larger number.

You may also like – Basic and Extended Euclidian Algorithm

References:

This article is contributed by Rahul Agrawal. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
3.5 Average Difficulty : 3.5/5.0
Based on 4 vote(s)