‘壹’ java做二个数的最大公约数
1、欧几里德算法和扩展欧几里德算法
欧几里德算法
欧几里德算法又称辗转相除法，用于计算两个整数a,b的最大公约数。其计算原理依赖于下面的定理：
定理：gcd(a,b) = gcd(b,a mod b)
证明：a可以表示成a = kb + r，则r = a mod b
假设d是a,b的一个公约数，则有
d|a, d|b，而r = a - kb，因此d|r
因此d是(b,a mod b)的公约数
假设d 是(b,a mod b)的公约数，则
d | b , d |r ，但是a = kb +r
因此d也是(a,b)的公约数
因此(a,b)和(b,a mod b)的公约数是一样的，其最大公约数也必然相等，得证
欧几里德算法就是根据这个原理来做的，其算法用C++语言描述为：
void swap(int & a, int & b)
{
int c = a;
a = b;
b = c;
}
int gcd(int a,int b)
{
if(0 == a )
{
return b;
}
if( 0 == b)
{
return a;
}
if(a > b)
{
swap(a,b);
}
int c;
for(c = a % b ; c > 0 ; c = a % b)
{
a = b;
b = c;
}
return b;
}
2、Stein算法
欧几里德算法是计算两个数最大公约数的传统算法，他无论从理论还是从效率上都是很好的。但是他有一个致命的缺陷，这个缺陷只有在大素数时才会显现出来。
考虑现在的硬件平台，一般整数最多也就是64位，对于这样的整数，计算两个数之间的模是很简单的。对于字长为32位的平台，计算两个不超过32位的整数的模，只需要一个指令周期，而计算64位以下的整数模，也不过几个周期而已。但是对于更大的素数，这样的计算过程就不得不由用户来设计，为了计算两个超过64位的整数的模，用户也许不得不采用类似于多位数除法手算过程中的试商法，这个过程不但复杂，而且消耗了很多CPU时间。对于现代密码算法，要求计算128位以上的素数的情况比比皆是，设计这样的程序迫切希望能够抛弃除法和取模。
Stein算法由J. Stein 1961年提出，这个方法也是计算两个数的最大公约数。和欧几里德算法 算法不同的是，Stein算法只有整数的移位和加减法，这对于程序设计者是一个福音。
为了说明Stein算法的正确性，首先必须注意到以下结论：
gcd(a,a) = a，也就是一个数和他自身的公约数是其自身
gcd(ka,kb) = k gcd(a,b)，也就是最大公约数运算和倍乘运算可以交换，特殊的，当k=2时，说明两个偶数的最大公约数必然能被2整除
C++/java 实现
// c++/java stein 算法
int gcd(int a,int b){
if(a<b)//arrange so that a>b{
int temp = a;
a = b;
b=temp;
}
if(0==b)//the base case
return a;
if(a%2==0 && b%2 ==0)//a and b are even
return 2*gcd(a/2,b/2);
if ( a%2 == 0)// only a is even
return gcd(a/2,b);
if ( b%2==0 )// only b is even
return gcd(a,b/2);
return gcd((a+b)/2,(a-b)/2);// a and b are odd
}
‘贰’ 用java从键盘输入两个正整数，求他们的最大公约数
从键盘输入那么就会用到Java的Scanner类，最大公约数，这里会用到算法，网络上面也有，下面是其中一种：
importjava.util.Scanner;
publicclassTestDivisor{
publicstaticvoidmain(String[]args){
Scannerinput=newScanner(System.in);//新建一个输入流对象，这里会导包
System.out.println("请输入第一个数：");
intnum1=input.nextInt();//接收输入的整数
System.out.println("请输入第二个数：");
intnum2=input.nextInt();//接收输入的整数
intnum3=num1%num2;//num1跟num2取余得到num3
while(num3>0){
num1=num2;
num2=num3;
num3=num1%num2;
}
input.close();//关闭输入流
System.out.println("最大公约数是："+num2);
}
}
/**
GCD算法的实现--GCB是最大公约数缩写
2.1递归实现
intgcd(inta,intb)
{
if(!b)returna;
elsereturngcd(b,a%b);
}
2.2迭代实现
intgcd(inta,intb)
{
intc=a%b;
while(c){
a=b;
b=c;
c=a%b;
}
returnb;
}
*
*/
‘叁’ java中如何求两个数的最大公约数
求最大公约数：提示用户输入两个正整数，并求出它们的最大公约数。
方法一：（辗转相除法）
设用户输入的两个整数为n1和n2且n1>n2，余数=n1%n2。当余数不为0时，把除数赋给n1做被除数，把余数赋给n2做除数再求得新余数，若还不为0再重复知道余数为0，此时n2就为最大公约数。
例：gcd(20,8)
20=2*8+4
8=2*4 因此gcd(20,8)=4
代码实现：
import javax.swing.JOptionPane;public class GreatestCommonDivisor{ public static void main(String[] args){
String num1String = JOptionPane.showInputDialog("Please enter the first integer:"); int num1 = Integer.parseInt(num1String);
String num2String = JOptionPane.showInputDialog("Please enter the second integer:"); int num2 = Integer.parseInt(num2String); if(num1<num2){ int temp=num1;
num1=num2;
num2=temp;
} int remainder = num1%num2; int n1=num1,n2=num2; while(remainder!=0){
num1=num2;
num2=remainder;
remainder=num1%num2;
}
JOptionPane.showMessageDialog(null,String.format("The greatest common divisor for %d and %d is %d.",n1,n2,num2));
}
}
方法二：假设输入的两个整数为n1和n2，检查k(k=2,3,4…)是否为n1和n2的最大公约数，直到k大于两个数中较小的一个。
代码实现：
import javax.swing.JOptionPane;public class GreatestCommonDivisor{ public static void main(String[] args){
String num1String = JOptionPane.showInputDialog("Please enter the first integer:"); int num1 = Integer.parseInt(num1String);
String num2String = JOptionPane.showInputDialog("Please enter the second integer:"); int num2 = Integer.parseInt(num2String); int gcd=1,k=1; while(k<=num1 && k<=num2)
{ if(num1%k==0 && num2%k==0)
gcd=k;
k++;
}
JOptionPane.showMessageDialog(null,String.format("The greatest common divisor for %d and %d is %d.",num1,num2,gcd));
}
}
‘肆’ java求两个数的最大公约数和最小公倍数
先求出两个数的最大公约数，计算的方法有很多，最简单的一种就是采用辗转相除法，求得两个数的最大公约数以后，在计算原来的两数的乘积除以最大公约数，就是这两个数的最小公倍数。
‘伍’ java最大公约数算法
三种算法：
//欧几里得算法（辗转相除）：
public static int gcd(int m,int n) {
if(m<n) {
int k=m;
m=n;
n=k;
}
//if(m%n!=0) {
// m=m%n;
// return gcd(m,n);
//}
//return n;
return m%n == 0?n:gcd(n,m%n);
}
//连续整数检测算法：
public static int gcd1(int m,int n) {
int t;
if(m<n) {
t=m;
}else {
t=n;
}
while(m%t!=0||n%t!=0){
t--;
}
return t;
}
//公因数法：(更相减损）
public static int gcd2(int m,int n) {
int i=0,t,x;
while(m%2==0&n%2==0) {
m/=2;
n/=2;
i++;
}
if(m<n){
t=m;
m=n;
n=t;
}
while(n!=(m-n)) {
x=m-n;
m=(n>x)?n:x;
n=(n<x)?n:x;
}
if(i==0)
return n;
else
return (int)Math.pow(2, i)*n;
}
public static void main(String[] args) {
System.out.println("请输入两个正整数:");
Scanner scan = new Scanner(System.in);
Scanner scan2=new Scanner(System.in);
int m=scan.nextInt();
int n=scan2.nextInt();
System.out.println("欧几里得算法求最大公约数是:"+gcd(m,n));
System.out.println("连续整数检测算法求最大公约数是:"+gcd1(m,n));
System.out.println("公因数法求最大公约数是:"+gcd2(m,n));
}
}
‘陆’ 用java求两数的最大公约数和最小公倍数。
import java.util.*;
public class lianxi06 {
public static void main(String[] args) {
int a ,b,m;
Scanner s = new Scanner(System.in);
System.out.print( "键入一个整数： ");
a = s.nextInt();
System.out.print( "再键入一个整数： ");
b = s.nextInt();
deff cd = new deff();
m = cd.deff(a,b);
int n = a * b / m;
System.out.println("最大公约数: " + m);
System.out.println("最小公倍数: " + n);
}
}
class deff{
public int deff(int x, int y) {
int t;
if(x < y) {
t = x;
x = y;
y = t;
}
while(y != 0) {
if(x == y) return x;
else {
int k = x % y;
x = y;
y = k;
}
}
return x;
}
}
‘柒’ JAVA输入2个数，求他们的最大公约数。
package com.code;
import java.util.Scanner;
public class TestRun {
public static void main(String[] args) {
int m;
int n;
int temp;
Scanner input = new Scanner(System.in);
m = input.nextInt();
n = input.nextInt();
if (m > n) {
temp = n;
} else {
temp = m;
}
for (int i= temp; i >= 1; i--) {
if (m % i == 0 && n % i == 0) {
temp=i;
break;
}
}
System.out.println("temp:" +temp );
}
}
1、break指跳出当前循环，当i从temp开始减小到为公约数时，break跳出循环就好了，return指跳出整个方法，所以后面的语句都不执行了。
2、最后输出的temp值你的程序是没有变的，temp是个参照，i才是变化的数字，当i减小到合要求时，将I赋值给temp此时temp才为公约数，否则temp一直是输入数值中较小的那个。
3、两个数要除的数值应该为逐渐减小的 i，而不是一直不变的temp
‘捌’ JAVA求2个整数的最大公约数
public
class
CommonDivisor
{
public
static
void
main(String[]
args)
{
int
n1
=
21;
int
n2
=
14;
System.out.println("最大公约数是"
+
fun(n1,
n2));
}
public
static
int
fun(int
n1,
int
n2)
{
int
m
=
1;
if
(n1
<
n2)
{
int
t
=
n1;
n1
=
n2;
n1
=
t;
}
for
(int
i
=
n2;
i
>
1;
i--)
{
if
((n1
%
i
==
0)
&&
(n2
%
i
==
0))
{
return
i;
}
}
return
m;
}
}
//
the
end