java算法实例

1. 求一个整数的各个位数的和，例如235的各个数位的和是10。

解析：该问题的关键是要分解整数。思考：一个数和10求余将会得到其个位数字，如：123%10 = 3，那么如果12 % 10 = 2，1 % 10 = 1，这样就实现了整数的分解。具体步骤是：

一、 将一个数与0进行比较，如果该数等于0，则各位数字的和就是0；

二、 如果该数不是0，则将该数对10取余数（该余数就是分解的各个数位的数字）；

三、 将该数字减小为原来的十分之一，继续执行步骤二。

下面是java代码的实现：

import java.util.Scanner;

public class Test {

    public static void main(String[] args) {
	System.out.println("请输入一个整数：");
	Scanner scanner = new Scanner(System.in);
	int number = scanner.nextInt();
	int sum = SumOfAllNumbers(number);
	System.out.println("整数" + number + "的各个数字的和是：" + sum);
    }

    /* 该方法返回一个整数的各个数位的数字之和，如999则返回27 */
    private static int SumOfAllNumbers(int number) {
	int sum = 0;
	number = number < 0 ? -number : number; // 判断正负
	while (number != 0) {
	    sum += number % 10;
	    number /= 10;
	}
	return sum;
    }
}

将以上的while循环改造成do-while循环可以进一步简化代码：

do {
	    sum += number % 10;
	} while ((number /= 10) != 0);

2. 使用System.currentTimeMillis()函数取得一个随机的大写字母（不能使用随机函数）

分析：这个题目的关键就是如何产生一个范围在[65,90]的随机数。我们知道System.currentTimeMillis()返回系统距离1970-1-1 00:00:00分的毫秒数。把它对26取余数就可以得到一个0~25的随机数，这样就产生了一个字母的相对索引。这个随机数再加上65就可以得到一个[65,90]的随机数了：

实现如下：

(char) (System.currentTimeMillis() % 26 + 65)

3. 编写一个算法实现4个整数的升序排序。

思路：从第一个数开始依次比较相邻的两个数，一遍结束以后，最大的数就到了末尾【冒泡排序的基本实现】，然后再从第一个数开始比较，这次只需要到第二个数，重复这个过程直到最后比较的两个数是第一个数和第二个数。

实现如下：

System.out.println("请输入4个整数：");
	Scanner scanner = new Scanner(System.in);
	int num1 = scanner.nextInt();
	int num2 = scanner.nextInt();
	int num3 = scanner.nextInt();
	int num4 = scanner.nextInt();
	// 这个是冒泡排序的基本思想，后面的排序可能扰乱前面的顺序，最后的两个数是最先排好序的
	/* 第一遍（3次） */
	if (num1 > num2) {
	    int temp = num1;
	    num1 = num2;
	    num2 = temp;
	}
	if (num2 > num3) {
	    int temp = num2;
	    num2 = num3;
	    num3 = temp;
	}
	if (num3 > num4) {
	    int temp = num3;
	    num3 = num4;
	    num4 = temp;
	}

	/* 第二遍（2次） */
	if (num1 > num2) {
	    int temp = num1;
	    num1 = num2;
	    num2 = temp;
	}
	if (num2 > num3) {
	    int temp = num2;
	    num2 = num3;
	    num3 = temp;
	}
	/* 第三遍（1次） */
	if (num1 > num2) {
	    int temp = num1;
	    num1 = num2;
	    num2 = temp;
	}

	System.out.println("升序排列：" + num1 + "," + num2 + "," + num3 + ","
		+ num4);

以上是一个典型的冒泡排序，假如有n个数需要比较，一共需要比较n-1遍，第一遍比较n-1次，第二遍比较n-2次，……第n-1遍比较1次，总共需要比较的次数是1+2+……+（n-1）=n*（n-1）/2次，时间复杂度为Q（n^2）。

也可以采用以下的思想进行排序：

先找出所有数中最小的一个，并将该数赋值给第一个数；然后从剩下的数中再找出一个最小的数，赋值给第二个数，重复这个过程，直到倒数第二个数成功赋值。

实现如下：

System.out.println("请输入4个整数：");
	Scanner scanner = new Scanner(System.in);
	int num1 = scanner.nextInt();
	int num2 = scanner.nextInt();
	int num3 = scanner.nextInt();
	int num4 = scanner.nextInt();
	/* 选出最小的数（3次） */
	if (num1 > num2) {
	    int temp = num1;
	    num1 = num2;
	    num2 = temp;
	}
	if (num1 > num3) {
	    int temp = num1;
	    num1 = num3;
	    num3 = temp;
	}
	if (num1 > num4) {
	    int temp = num1;
	    num1 = num4;
	    num4 = temp;
	}

	/* 找出第二小的数（2次） */
	if (num2 > num3) {
	    int temp = num2;
	    num2 = num3;
	    num3 = temp;
	}
	if (num2 > num4) {
	    int temp = num2;
	    num2 = num4;
	    num4 = temp;
	}
	/* 找出第三小的数（1次） */
	if (num3 > num4) {
	    int temp = num3;
	    num3 = num4;
	    num4 = temp;
	}

	System.out.println("升序排列：" + num1 + "," + num2 + "," + num3 + ","
		+ num4);

以上算法是先求出小的数放在第一个位置，然后求出第二小的数放入第二个位置，依次类推直到倒数第二个数确定。算法的时间复杂度也和冒泡的差不多，确定第一个数需要比较n-1次，确定第二个数需要比较n-2次，确定n-1（倒数第二个数）需要比较1次，总共执行比较的次数是（n-1）+（n-2）+……+1 = n*（n-1）/2次，算法的时间复杂度为O(n^2)。

4. 编写一个程序该程序能够从52张牌中随机取出一张（大小和花色）。

思路一：产生两个随机数，随机数1是[1,13]之间的，用于表示牌的大小；随机数2是[0,3]之间的用于表示花色。实现如下：

int size = (int) (Math.random() * 13 + 1); // 牌的大小
	int color = (int) (Math.random() * 4); // 牌的花色
	String big = null;
	if (1 == size) {
	    big = "Ace";
	} else if (11 == size) {
	    big = "Jack";
	} else if (12 == size) {
	    big = "Queen";
	} else if (13 == size) {
	    big = "King";
	} else {
	    big = size + "";
	}
	String type = null;
	switch (color) {
	case 0:
	    type = "黑梅花";
	    break;
	case 1:
	    type = "红方块";
	    break;
	case 2:
	    type = "红心";
	    break;
	case 3:
	    type = "黑桃";
	    break;
	default:
	    break;
	}
	System.out.println("你的牌大小是" + big + ",你的牌花色是" + type);

思路二：52张牌有4种花色，每种花色有13张牌，我们可以产生一个[0,51]之间的一个随机数，把这个随机数对13求余数，得到13种状态，表示大小；把该随机数对13做商得到4种状态，表示4种花色。

private static final int NUM_OF_CARDS = 52;

    public static void main(String[] args) {
	int number = (int) (Math.random() * 52);
	int size = number % 13 + 1; // 大小
	String big = null;
	if (1 == size) {
	    big = "Ace";
	} else if (11 == size) {
	    big = "Jack";
	} else if (12 == size) {
	    big = "Queen";
	} else if (13 == size) {
	    big = "King";
	} else {
	    big = size + "";
	}
	int color = number / 13;
	String type = null;
	switch (color) {
	case 0:
	    type = "方块";
	    break;
	case 1:
	    type = "梅花";
	    break;
	case 2:
	    type = "红桃";
	    break;
	case 3:
	    type = "黑桃";
	default:
	    break;
	}
	System.out.println("牌的大小是" + big + ",牌的花色是" + type);
    }

从代码的行数来看，两种思路并不存在明显的差别，但是思路二更值得我们去学习，因为它只产生了一个随机数，在资源受限的情况下更有效率。

5. 蒙特卡罗模拟：蒙特卡罗模拟使用随机数和概率来解决问题。这个方法在计算数学、物理、化学和财经方面有非常广泛的应用。下面的例子给出使用蒙塔卡罗来模拟π的值。为了使用蒙特卡罗方法计算π，画出圆的一个外界正方形：