Bruce_YanWQ

Java算法实例

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

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

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

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

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

下面是Java代码的实现：

[java] view plain copy

print ?

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;
}
}

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循环可以进一步简化代码：

[java] view plain copy

print ?

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

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]的随机数了：

实现如下：

[java] view plain copy

print ?

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

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

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

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

实现如下：

[java] view plain copy

print ?

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);

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）。

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

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

实现如下：

[java] view plain copy

print ?

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);

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]之间的用于表示花色。实现如下：

[java] view plain copy

print ?

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);

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种花色。

[java] view plain copy

print ?

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);
}

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

假设这个圆的半径是1，那么圆的面积就是π而其外接正方形的面积就是4.随机产生正方形中的一个点，这个点落在圆内的概率就是circleArea/squareArea（圆面积/正方形面积）=π/4。

编写程序在正方形内随机产生1000000个点，用numberOfHits表示落在圆内的点。因此numberOfHits大约是1000000*（π/4）——可以近似认为π = 4*numberOfHits/1000000。程序清单如下：

[java] view plain copy

print ?

public class MonteCarloSimulation {
public static void main(String[] args) {
final int NUMBER_OF_TRIALS = 10000000;
int numberOfHits = 0;
for (int i = 0; i < NUMBER_OF_TRIALS; i++) {
double x = Math.random() * 2.0 - 1;
double y = Math.random() * 2.0 - 1;
if (x * x + y * y <= 1) {
++numberOfHits;
}
}
double pi = 4.0 * numberOfHits / NUMBER_OF_TRIALS;
System.out.println(”PI = ” + pi);
}
}

public class MonteCarloSimulation {

    public static void main(String[] args) {
        final int NUMBER_OF_TRIALS = 10000000;
        int numberOfHits = 0;
        for (int i = 0; i < NUMBER_OF_TRIALS; i++) {
            double x = Math.random() * 2.0 - 1;
            double y = Math.random() * 2.0 - 1;
            if (x * x + y * y <= 1) {
                ++numberOfHits;
            }
        }
        double pi = 4.0 * numberOfHits / NUMBER_OF_TRIALS;
        System.out.println("PI = " + pi);
    }

}

运行结果：

PI = 3.14154564

6. 显示素数。在5行中显示前50个素数，每行10个数。该问题可以分解为以下的任务：

-判定一个给定的数是否是素数；

-针对number = 2,3,4,5,6，……，测试它是否是素数。

-统计素数的个数。

-打印每个素数每行10个。

显然需要编写循环，反复检测新的number是否是素数。如果number是素数，则计数器加1.计数器count的值被初始化为0.当它等于50的时候循环终止。该算法的伪码实现如下：

[python] view plain copy

print ?

设置打印出来的素数的个数为常量NUMBER_OF_PRIMERS;
使用count来对素数个数进行计数并将其初值设为0;
设置number的初始值为2;
while( count < NUMBER_OF_PRIMES ){
测试该数是否是素数;
if ( 该数是素数 ) {
打印该素数并将count增加1;
}
number++;
}

设置打印出来的素数的个数为常量NUMBER_OF_PRIMERS;
使用count来对素数个数进行计数并将其初值设为0;
设置number的初始值为2;
while( count < NUMBER_OF_PRIMES ){
    测试该数是否是素数;
    if ( 该数是素数 ) {
        打印该素数并将count增加1;
    }
    number++;
}

为了测试某个数是否是素数，就需要检测它是否能够被2,3,4，一直到number/2的数整除（如果能够整除就说明它不是素数），这个算法的伪码描述如下：

[python] view plain copy

print ?

使用布尔变量isPrime表示number是否是素数;
设置isPrime的初始值为true;
for ( int divisor = 2; divisor <= number / 2 ; divisor++ ) {
if ( number % divisor == 0 ) {
isPrime = false;
break;
}
}

使用布尔变量isPrime表示number是否是素数;
设置isPrime的初始值为true;
for ( int divisor = 2; divisor <= number / 2 ; divisor++ ) {
    if ( number % divisor == 0 ) {
        isPrime = false;
        break;
    }
}

该算法的完整实现如下：

[java] view plain copy

print ?

public class PrimeNumber {
public static void main(String[] args) {
final int NUMBER_OF_PRIMES = 50;
final int NUMBER_OF_PRIMES_PER_LINE = 10;
int count = 0;// 素数个数的计数器
int number = 2;// 用来测试是否是素数
System.out.println(”开始的50个素数”);
while (count < NUMBER_OF_PRIMES) {
boolean isPrime = true; // 先假设是素数
// 测试该数字是否是素数
for (int i = 2; i <= number / 2; i++) {
if (number % i == 0) {
isPrime = false;
break;// 已经知道该数不是素数，退出本次测试
}
}
if (isPrime) {
if (++count % NUMBER_OF_PRIMES_PER_LINE == 0) {
System.out.println(number);
} else {
System.out.print(number + ”\t”);
}
}
++number;
}
}
}

public class PrimeNumber {

    public static void main(String[] args) {
    final int NUMBER_OF_PRIMES = 50;
    final int NUMBER_OF_PRIMES_PER_LINE = 10;
    int count = 0;// 素数个数的计数器
    int number = 2;// 用来测试是否是素数

    System.out.println("开始的50个素数");

    while (count < NUMBER_OF_PRIMES) {
        boolean isPrime = true; // 先假设是素数
        // 测试该数字是否是素数
        for (int i = 2; i <= number / 2; i++) {
        if (number % i == 0) {
            isPrime = false;
            break;// 已经知道该数不是素数，退出本次测试
        }
        }

        if (isPrime) {
        if (++count % NUMBER_OF_PRIMES_PER_LINE == 0) {
            System.out.println(number);
        } else {
            System.out.print(number + "\t");
        }
        }

        ++number;
    }
    }

}

运行结果：

以上的代码可以进一步模块化：

[java] view plain copy

print ?

public class PrimeNumberMethod {
public static void main(String[] args) {
System.out.println(”开头的50个素数是：”);
printPrimeNumbers(50);
}
/*
* 打印指定个数的素数（从2开始）
*/
private static void printPrimeNumbers(int numberOfPrimes) {
final int NUMBER_OF_PRIME_PER_LINE = 10;
int count = 0;// 素数的个数
int number = 2;// 从2开始测试
while (count < numberOfPrimes) {
if (isPrime(number)) {
System.out.print(number + ”\t”);
if (++count % NUMBER_OF_PRIME_PER_LINE == 0) {
System.out.println();
}
}
number++;
}
}
/*
* 判断是否是素数
*/
private static boolean isPrime(int number) {
for (int divisor = 2; divisor <= number / 2; divisor++) {
if (0 == number % divisor) {
return false;
}
}
return true;
}
}

public class PrimeNumberMethod {

    public static void main(String[] args) {
        System.out.println("开头的50个素数是：");
        printPrimeNumbers(50);
    }

    /*
     * 打印指定个数的素数（从2开始）
     */
    private static void printPrimeNumbers(int numberOfPrimes) {
        final int NUMBER_OF_PRIME_PER_LINE = 10;
        int count = 0;// 素数的个数
        int number = 2;// 从2开始测试

        while (count < numberOfPrimes) {
            if (isPrime(number)) {
                System.out.print(number + "\t");
                if (++count % NUMBER_OF_PRIME_PER_LINE == 0) {
                    System.out.println();
                }
            }
            number++;
        }
    }

    /*
     * 判断是否是素数
     */
    private static boolean isPrime(int number) {
        for (int divisor = 2; divisor <= number / 2; divisor++) {
            if (0 == number % divisor) {
                return false;
            }
        }
        return true;
    }

}

7. （找出2个最高分）编写程序，提示用户输入学生的个数、每个学生的名字以及分数，最后显示获得最高分的学生姓名和分数以及获得第二高分的学生姓名及其分数。

思路一：创建一个学生类，重写hashCode（）方法和equals（）方法并且实现Compareable接口使学生类拥有排序的功能；创建一个ArrayList将学生对象加入到ArrayList集合中；调用集合工具类Collections的sort（）方法对ArrayList集合中的元素进行排序操作，最后依次取出前面的两个元素。实现如下：

学生类：

[java] view plain copy

print ?

/**
* 学生类，该类重写了hashCode（）和equals（）方法并实现了Comparable接口用于排序
*
*/
public class Student implements Comparable {
private String name;
private float score;
public Student(String name, float score) {
super();
this.name = name;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public float getScore() {
return score;
}
public void setScore(float score) {
this.score = score;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + Float.floatToIntBits(score);
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof Student))
return false;
Student other = (Student) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (Float.floatToIntBits(score) != Float.floatToIntBits(other.score))
return false;
return true;
}
@Override
public int compareTo(Student o) {
if (o.score > this.score) {
return 1;
} else if (o.score == this.score) {
return 0;
} else {
return -1;
}
}
@Override
public String toString() {
return “Student [name=” + name + “, score=” + score + “]”;
}
}

/**
 * 学生类，该类重写了hashCode（）和equals（）方法并实现了Comparable接口用于排序
 *
 */
public class Student implements Comparable {
    private String name;
    private float score;

    public Student(String name, float score) {
    super();
    this.name = name;
    this.score = score;
    }

    public String getName() {
    return name;
    }

    public void setName(String name) {
    this.name = name;
    }

    public float getScore() {
    return score;
    }

    public void setScore(float score) {
    this.score = score;
    }

    @Override
    public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    result = prime * result + Float.floatToIntBits(score);
    return result;
    }

    @Override
    public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (!(obj instanceof Student))
        return false;
    Student other = (Student) obj;
    if (name == null) {
        if (other.name != null)
        return false;
    } else if (!name.equals(other.name))
        return false;
    if (Float.floatToIntBits(score) != Float.floatToIntBits(other.score))
        return false;
    return true;
    }

    @Override
    public int compareTo(Student o) {
    if (o.score > this.score) {
        return 1;
    } else if (o.score == this.score) {
        return 0;
    } else {
        return -1;
    }
    }

    @Override
    public String toString() {
    return "Student [name=" + name + ", score=" + score + "]";
    }

}

测试类：

[java] view plain copy

print ?

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
System.out.println(”请输入学生的个数：”);
Scanner scanner = new Scanner(System.in);
int numberOfStudent = scanner.nextInt();
String name = null;
float score = 0;
for (int i = 0; i < numberOfStudent; i++) {
scanner = new Scanner(System.in);
System.out.println(”请输入学生姓名：”);
name = scanner.nextLine();
System.out.println(”请输入学生成绩：”);
score = scanner.nextFloat();
arrayList.add(new Student(name, score));
}
Collections.sort(arrayList);//用集合工具类Collections进行排序
System.out.println(”最高分是” + arrayList.get(0).getName() + “，分数是”
+ arrayList.get(0).getScore());
System.out.println(”第二高分是” + arrayList.get(1).getName() + “，分数是”
+ arrayList.get(1).getScore());
}
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class Test {

    public static void main(String[] args) {
    ArrayList arrayList = new ArrayList();
    System.out.println("请输入学生的个数：");
    Scanner scanner = new Scanner(System.in);
    int numberOfStudent = scanner.nextInt();
    String name = null;
    float score = 0;
    for (int i = 0; i < numberOfStudent; i++) {
        scanner = new Scanner(System.in);
        System.out.println("请输入学生姓名：");
        name = scanner.nextLine();
        System.out.println("请输入学生成绩：");
        score = scanner.nextFloat();
        arrayList.add(new Student(name, score));
    }
    Collections.sort(arrayList);//用集合工具类Collections进行排序
    System.out.println("最高分是" + arrayList.get(0).getName() + "，分数是"
        + arrayList.get(0).getScore());
    System.out.println("第二高分是" + arrayList.get(1).getName() + "，分数是"
        + arrayList.get(1).getScore());

    }

}

思路一采用了面向对象的设计，本身是很值得提倡的，但是发现其到处在调用API，没有一点算法精神在里面，并且代码很容易就到了100行，其实这100行我们真正用得到的代码并不多。
思路二：先定义2组变量，一组用于存储最高分的姓名和成绩，另外一组用于存储第二高分的姓名和成绩。最高分和第二高分都初始化为0，每当用户输入一个成绩就与最高分进行比较，如果高于当前的最高分，就将该成绩赋值给最高分；如果当前成绩小于最高分，并且大于第二高分，则将当前的成绩赋值给第二高分。实现如下：

[java] view plain copy

print ?

import java.util.Scanner;
public class getMaxAndSecondScore {
public static void main(String[] args) {
System.out.println(”输入学生的个数：”);
Scanner scanner = new Scanner(System.in);
int number = scanner.nextInt();
float maxScore = 0;
float secondScore = 0;
String maxName = ”“;
String secondName = ”“;
for (int i = 0; i < number; i++) {
scanner = new Scanner(System.in);
System.out.println(”请输入学生姓名：”);
String name = scanner.nextLine();
System.out.println(”请输入学生分数：”);
float score = scanner.nextFloat();
if (score > maxScore) {
maxScore = score;
maxName = name;
}
if (score < maxScore && score > secondScore) {
secondScore = score;
secondName = name;
}
}
System.out.println(”最高分是：” + maxName + “分数是：” + maxScore + “\n第二高分是：”
+ secondName + ”分数是” + secondScore);
}
}

import java.util.Scanner;

public class getMaxAndSecondScore {

    public static void main(String[] args) {
    System.out.println("输入学生的个数：");
    Scanner scanner = new Scanner(System.in);
    int number = scanner.nextInt();
    float maxScore = 0;
    float secondScore = 0;
    String maxName = "";
    String secondName = "";
    for (int i = 0; i < number; i++) {
        scanner = new Scanner(System.in);
        System.out.println("请输入学生姓名：");
        String name = scanner.nextLine();
        System.out.println("请输入学生分数：");
        float score = scanner.nextFloat();
        if (score > maxScore) {
        maxScore = score;
        maxName = name;
        }
        if (score < maxScore && score > secondScore) {
        secondScore = score;
        secondName = name;
        }
    }
    System.out.println("最高分是：" + maxName + "分数是：" + maxScore + "\n第二高分是："
        + secondName + "分数是" + secondScore);
    }

}

实现二短短30行代码搞定问题，体现了算法的精髓。

8. 求最大公约数：首先找出n1和n2的最小值d，然后依次检验d，d-1，d-2，……，2，1是否为n1和n2的公约数，第一个满足条件的约数就是n1和n2的最大公约数。实现如下：

[java] view plain copy

print ?

import java.util.Scanner;
public class Test {
public static void main(String[] args) {
System.out.println(”请输入两个数：”);
Scanner scanner = new Scanner(System.in);
int num1 = scanner.nextInt();
int num2 = scanner.nextInt();
int gcd = getGcd(num1, num2);
System.out.println(num1 + ”和” + num2 + “的最大公约数是” + gcd);
}
private static int getGcd(int num1, int num2) {
int temp = num1 < num2 ? num1 : num2;
int gcd = 1;
for (int i = temp; i > 0; i–) {
if (num1 % i == 0 && num2 % i == 0) {
gcd = i;
break; // 第一个符合条件的数就是最大公约数
}
}
return gcd;
}
}

import java.util.Scanner;

public class Test {

    public static void main(String[] args) {
    System.out.println("请输入两个数：");
    Scanner scanner = new Scanner(System.in);
    int num1 = scanner.nextInt();
    int num2 = scanner.nextInt();
    int gcd = getGcd(num1, num2);
    System.out.println(num1 + "和" + num2 + "的最大公约数是" + gcd);
    }

    private static int getGcd(int num1, int num2) {
    int temp = num1 < num2 ? num1 : num2;
    int gcd = 1;
    for (int i = temp; i > 0; i--) {
        if (num1 % i == 0 && num2 % i == 0) {
        gcd = i;
        break; // 第一个符合条件的数就是最大公约数
        }
    }
    return gcd;
    }

}

9. （找出一个整数的因子）编写程序，读入一个整数，然后以升序的方式显示它的所有最小因子。例如，若输入的整数是120，那么输出应该是2，2，2，3,，5。

分析：从2开始进行测试，如果该数能够被被2，整除，则输出其因子2，将原来的数除以该因子赋值给num；否则将测试条件加1再进行测试，重复以上两个步骤直到测试条件大于需要测试的整数。实现如下：

[java] view plain copy

print ?

import java.util.Scanner;
public class Test {
public static void main(String[] args) {
System.out.println(”请输入正整数：”);
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
printFactor(num);
}
private static void printFactor(int num) {
System.out.println(”数” + num + “的最小公因子有：”);
int i = 2;
while (i <= num) {
if (num % i == 0) {
System.out.print(i + ”\t”);// 输出因子
num /= i;// 除以该因子，再进行测试
} else {
i++;
}
}
}
}

import java.util.Scanner;

public class Test {

    public static void main(String[] args) {
    System.out.println("请输入正整数：");
    Scanner scanner = new Scanner(System.in);
    int num = scanner.nextInt();
    printFactor(num);
    }

    private static void printFactor(int num) {
    System.out.println("数" + num + "的最小公因子有：");
    int i = 2;
    while (i <= num) {
        if (num % i == 0) {
        System.out.print(i + "\t");// 输出因子
        num /= i;// 除以该因子，再进行测试
        } else {
        i++;
        }
    }
    }

}

10. （显示金字塔）编写程序，提示用户输入一个在1~15之间的数，然后显示一个金字塔形状的图案，如图所示：

分析：此问题可以分解为以下2个方面，从行的角度来看需要确定每行打印的数字以及每一行打印完成之后要打印一个换行；从列的角度来看每一行需要确定开头的空白数目，以及每一行的升序和降序排列。具体实现如下：

[java] view plain copy

print ?

import java.util.Scanner;
public class Test {
public static void main(String[] args) {
System.out.print(”请输入金字塔的层数：”);
Scanner scanner = new Scanner(System.in);
int numberOfLine = scanner.nextInt();
printPyramidr(numberOfLine);
}
private static void printPyramidr(int numberOfLine) {
if (numberOfLine < 1 || numberOfLine > 15) {
System.out.println(”输入的范围是1~15”);
} else {
System.out.println(”==========================================”);
for (int row = 1; row <= numberOfLine; row++) {
/* 控制每一行前面的空格 */
for (int col = 1; col <= numberOfLine - row; col++) {
System.out.print(”\t”);// 第n行前面有有numberOfLine-n个空白
}
/* 从大到小输出 */
for (int num = row; num > 0; num–) {
System.out.print(num + ”\t”);// 从大到小打印行的序号
}
/* 从小到大输出 */
for (int num = 2; num <= row; num++) {
System.out.print(num + ”\t”);// 从第二行开始顺序输出到行值
}
System.out.println();// 每执行一个最外层循环换行
}
System.out.println(”==========================================”);
}
}
}

import java.util.Scanner;

public class Test {

    public static void main(String[] args) {
    System.out.print("请输入金字塔的层数：");
    Scanner scanner = new Scanner(System.in);
    int numberOfLine = scanner.nextInt();
    printPyramidr(numberOfLine);
    }

    private static void printPyramidr(int numberOfLine) {
    if (numberOfLine < 1 || numberOfLine > 15) {
        System.out.println("输入的范围是1~15");
    } else {
        System.out.println("==========================================");
        for (int row = 1; row <= numberOfLine; row++) {
        /* 控制每一行前面的空格 */
        for (int col = 1; col <= numberOfLine - row; col++) {
            System.out.print("\t");// 第n行前面有有numberOfLine-n个空白
        }
        /* 从大到小输出 */
        for (int num = row; num > 0; num--) {
            System.out.print(num + "\t");// 从大到小打印行的序号
        }
        /* 从小到大输出 */
        for (int num = 2; num <= row; num++) {
            System.out.print(num + "\t");// 从第二行开始顺序输出到行值
        }
        System.out.println();// 每执行一个最外层循环换行
        }
        System.out.println("==========================================");
    }
    }

}

在以上基础上进行改进：如何打印下述的金字塔？

分析：每行的空格数 = 最大行数-当前行数；每行的*数目 = 2*该行行数 - 1，实现如下：

[java] view plain copy

print ?

import java.util.Scanner;
public class Test {
public static void main(String[] args) {
System.out.print(”请输入金字塔的层数：”);
Scanner scanner = new Scanner(System.in);
int numberOfLine = scanner.nextInt();
printPyramidr(numberOfLine);
}
private static void printPyramidr(int numberOfLine) {
if (numberOfLine < 1 || numberOfLine > 15) {
System.out.println(”输入的范围是1~15”);
} else {
System.out.println(”==========================================”);
for (int row = 1; row <= numberOfLine; row++) {
/* 控制每一行前面的空格 */
for (int col = 1; col <= numberOfLine - row; col++) {
System.out.print(” ”);// 第n行前面有有numberOfLine-n个空白
}
for (int col = 0; col <2*row-1; col++) {
System.out.print(”*”);
}
System.out.println();// 每执行一个最外层循环换行
}
System.out.println(”==========================================”);
}
}
}

import java.util.Scanner;

public class Test {

    public static void main(String[] args) {
    System.out.print("请输入金字塔的层数：");
    Scanner scanner = new Scanner(System.in);
    int numberOfLine = scanner.nextInt();
    printPyramidr(numberOfLine);
    }

    private static void printPyramidr(int numberOfLine) {
    if (numberOfLine < 1 || numberOfLine > 15) {
        System.out.println("输入的范围是1~15");
    } else {
        System.out.println("==========================================");
        for (int row = 1; row <= numberOfLine; row++) {
        /* 控制每一行前面的空格 */
        for (int col = 1; col <= numberOfLine - row; col++) {
            System.out.print(" ");// 第n行前面有有numberOfLine-n个空白
        }
        for (int col = 0; col <2*row-1; col++) {
            System.out.print("*");
        }

        System.out.println();// 每执行一个最外层循环换行
        }
        System.out.println("==========================================");
    }
    }

}

11. 计算自然对数的底数e。可以使用以下公式：e = 1 + 1/1! + 1/2! + 1/3! + …… + 1/i!。当i→∞时即可得出e的值。

思路一：使用递归计算出n的阶乘，以上公式可以看做初始值为1，其中每一项为n的阶乘的倒数，将他们相加即可，实现如下：

[java] view plain copy

print ?

public class Test {
public static void main(String[] args) {
double e = 1;
for (int i = 1; i <= 50; i++) {
long num = fact(i);
e += 1.0 / num;
}
System.out.println(”e = ” + e);
}
/*
* 计算n的阶乘
*/
public static long fact(int n) {
if (n == 1) {
return 1;
} else {
return n * fact(n - 1);
}
}
}

public class Test {
    public static void main(String[] args) {
        double e = 1;
        for (int i = 1; i <= 50; i++) {
            long num = fact(i);
            e += 1.0 / num;
        }
        System.out.println("e = " + e);
    }

    /*
     * 计算n的阶乘
     */
    public static long fact(int n) {
        if (n == 1) {
            return 1;
        } else {
            return n * fact(n - 1);
        }
    }
}

但是以上代码存在一个很严重的问题，它没有办法达到条件i→∞，事实上当i=500时，e = Infinity，当i= 50000时会抛出java.lang.StackOverflowError错误（因为递归的的层数太多），所以以上代码是行不通的。通过观察公式我们可以看出，第二项1/2！ = 1 /1！/2；第三项1/3！ = 1/2!/3，依据以上思路设计如下算法：

[java] view plain copy

print ?

public class Test {
public static void main(String[] args) {
double e = 1;
double num = 1;
for (int i = 1; i <= 5000000; i++) {
num /= i;// 当前的值等于上一次的值除以当前索引
e += num;
}
System.out.println(”e = ” + e);
}
}

public class Test {
    public static void main(String[] args) {
        double e = 1;
        double num = 1;
        for (int i = 1; i <= 5000000; i++) {
            num /= i;// 当前的值等于上一次的值除以当前索引
            e += num;
        }
        System.out.println("e = " + e);
    }

}

12. 简易日历。

[java] view plain copy

print ?

import javax.swing.JOptionPane;
public class Test {
public static void main(String[] args) {
int year = Integer.parseInt(JOptionPane.showInputDialog(“请输入年份”));
int firstDay = Integer.parseInt(JOptionPane
.showInputDialog(”请输入该年第一日的星期数”));
int numberOfDaysMonth = 0;// 每月的天数
boolean isLeapYear = isLeapYear(year);
for (int month = 1; month <= 12; month++) {
System.out.print(”\t\t” + year + “年”);
switch (month) {
case 1:
System.out.println(”1月”);
numberOfDaysMonth = 31;
break;
case 2:
System.out.println(”2月”);
if (isLeapYear) {
numberOfDaysMonth = 29;
} else {
numberOfDaysMonth = 28;
}
break;
case 3:
System.out.println(”3月”);
numberOfDaysMonth = 31;
break;
case 4:
System.out.println(”4月”);
numberOfDaysMonth = 30;
break;
case 5:
System.out.println(”5月”);
numberOfDaysMonth = 31;
break;
case 6:
System.out.println(”6月”);
numberOfDaysMonth = 30;
break;
case 7:
System.out.println(”7月”);
numberOfDaysMonth = 31;
break;
case 8:
System.out.println(”8月”);
numberOfDaysMonth = 31;
break;
case 9:
System.out.println(”9月”);
numberOfDaysMonth = 30;
break;
case 10:
System.out.println(”10月”);
numberOfDaysMonth = 30;
break;
case 11:
System.out.println(”11月”);
numberOfDaysMonth = 30;
break;
case 12:
System.out.println(”12月”);
numberOfDaysMonth = 31;
break;
default:
break;
}
System.out.println(”——————————————–”);
System.out.println(”日\t一\t二\t三\t四\t五\t六”);
for (int i = 0; i < firstDay; i++) {
System.out.print(’\t’);
}
int i = 0;
for (i = 1; i <= numberOfDaysMonth; i++) {
System.out.print(i + ”\t”);
if ((i + firstDay) % 7 == 0) {
System.out.println();
}
}
System.out.println();
System.out.println();
firstDay = (firstDay + numberOfDaysMonth) % 7;
}
}
private static boolean isLeapYear(int year) {
if (0 == year % 400 || 0 == year % 4 && 0 != year % 100) {
return true;
} else {
return false;
}
}
}

import javax.swing.JOptionPane;

public class Test {

    public static void main(String[] args) {
        int year = Integer.parseInt(JOptionPane.showInputDialog("请输入年份"));
        int firstDay = Integer.parseInt(JOptionPane
                .showInputDialog("请输入该年第一日的星期数"));
        int numberOfDaysMonth = 0;// 每月的天数
        boolean isLeapYear = isLeapYear(year);
        for (int month = 1; month <= 12; month++) {
            System.out.print("\t\t" + year + "年");
            switch (month) {
            case 1:
                System.out.println("1月");
                numberOfDaysMonth = 31;
                break;
            case 2:
                System.out.println("2月");
                if (isLeapYear) {
                    numberOfDaysMonth = 29;
                } else {
                    numberOfDaysMonth = 28;
                }
                break;
            case 3:
                System.out.println("3月");
                numberOfDaysMonth = 31;
                break;
            case 4:
                System.out.println("4月");
                numberOfDaysMonth = 30;
                break;
            case 5:
                System.out.println("5月");
                numberOfDaysMonth = 31;
                break;
            case 6:
                System.out.println("6月");
                numberOfDaysMonth = 30;
                break;
            case 7:
                System.out.println("7月");
                numberOfDaysMonth = 31;
                break;
            case 8:
                System.out.println("8月");
                numberOfDaysMonth = 31;
                break;
            case 9:
                System.out.println("9月");
                numberOfDaysMonth = 30;
                break;
            case 10:
                System.out.println("10月");
                numberOfDaysMonth = 30;
                break;
            case 11:
                System.out.println("11月");
                numberOfDaysMonth = 30;
                break;
            case 12:
                System.out.println("12月");
                numberOfDaysMonth = 31;
                break;
            default:
                break;
            }
            System.out.println("--------------------------------------------");
            System.out.println("日\t一\t二\t三\t四\t五\t六");
            for (int i = 0; i < firstDay; i++) {
                System.out.print('\t');
            }
            int i = 0;
            for (i = 1; i <= numberOfDaysMonth; i++) {
                System.out.print(i + "\t");
                if ((i + firstDay) % 7 == 0) {
                    System.out.println();
                }
            }
            System.out.println();
            System.out.println();
            firstDay = (firstDay + numberOfDaysMonth) % 7;
        }
    }

    private static boolean isLeapYear(int year) {
        if (0 == year % 400 || 0 == year % 4 && 0 != year % 100) {
            return true;
        } else {
            return false;
        }
    }

}

一个真正有用的日历：

[java] view plain copy

print ?

import java.util.Scanner;
public class PrintCalendar {
public static void main(String[] args) {
/* 读取输入 */
Scanner scanner = new Scanner(System.in);
System.out.println(”请输入年份：”);
int year = scanner.nextInt();
if (year < 1900) {
System.out.println(”年份从1900年开始!”);
System.exit(1);
}
System.out.println(”请输入月份：”);
int month = scanner.nextInt();
if (month < 1 || month > 12) {
System.out.println(”月份必须是1~12！”);
System.exit(2);
}
scanner.close();
printMonth(year, month);// 打印日历
}
/** 打印指定年月的日历 */
private static void printMonth(int year, int month) {
printMonthTitle(year, month);
printMonthBody(year, month);
}
/** 打印日历头 */
private static void printMonthTitle(int year, int month) {
System.out.println(” ” + year + “年” + month + “月”);
System.out.println(”———————————————–”);
System.out.println(”日\t一\t二\t三\t四\t五\t六”);
}
/** 打印日历体 */
private static void printMonthBody(int year, int month) {
int startDay = getStartDay(year, month);
int numberOfDaysInMonth = getNumberOfDaysInMonth(year, month);
int i = 0;
for (i = 0; i < startDay; i++) {
System.out.print(”\t”);
}
for (i = 1; i <= numberOfDaysInMonth; i++) {
System.out.print(i + ”\t”);
if ((i + startDay) % 7 == 0) {
System.out.println();
}
}
}
/** 得到这个月的1号是星期几 */
private static int getStartDay(int year, int month) {
final int START_DAY_FOR_1_1_1900 = 1;// 1900-01-01是星期一
int totalNumberOfDays = getTotalNumberOfDays(year, month);
return (totalNumberOfDays + START_DAY_FOR_1_1_1990) % 7;
}
/** 计算距离1900-01-01的天数 */
private static int getTotalNumberOfDays(int year, int month) {
int total = 0;
for (int i = 1900; i < year; i++) {
total += isLeapYear(year) ? 366 : 365;
}
for (int i = 1; i < month; i++) {
total += getNumberOfDaysInMonth(year, i);
}
return total;
}
/** 判断是否是闰年 */
private static boolean isLeapYear(int year) {
return year % 400 == 0 || year % 4 == 0 && year % 100 != 0;
}
/** 得到该月份的天数 */
private static int getNumberOfDaysInMonth(int year, int month) {
if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8
|| month == 10 || month == 12) {
return 31;
} else if (month == 4 || month == 6 || month == 9 || month == 11) {
return 30;
} else {
return isLeapYear(year) ? 29 : 28;
}
}
}

import java.util.Scanner;

public class PrintCalendar {

    public static void main(String[] args) {
        /* 读取输入 */
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入年份：");
        int year = scanner.nextInt();
        if (year < 1900) {
            System.out.println("年份从1900年开始!");
            System.exit(1);
        }
        System.out.println("请输入月份：");
        int month = scanner.nextInt();
        if (month < 1 || month > 12) {
            System.out.println("月份必须是1~12！");
            System.exit(2);
        }
        scanner.close();

        printMonth(year, month);// 打印日历
    }

    /** 打印指定年月的日历 */
    private static void printMonth(int year, int month) {
        printMonthTitle(year, month);
        printMonthBody(year, month);
    }

    /** 打印日历头 */
    private static void printMonthTitle(int year, int month) {
        System.out.println("                   " + year + "年" + month + "月");
        System.out.println("-----------------------------------------------");
        System.out.println("日\t一\t二\t三\t四\t五\t六");
    }

    /** 打印日历体 */
    private static void printMonthBody(int year, int month) {
        int startDay = getStartDay(year, month);
        int numberOfDaysInMonth = getNumberOfDaysInMonth(year, month);
        int i = 0;
        for (i = 0; i < startDay; i++) {
            System.out.print("\t");
        }
        for (i = 1; i <= numberOfDaysInMonth; i++) {
            System.out.print(i + "\t");
            if ((i + startDay) % 7 == 0) {
                System.out.println();
            }
        }
    }

    /** 得到这个月的1号是星期几 */
    private static int getStartDay(int year, int month) {
        final int START_DAY_FOR_1_1_1900 = 1;// 1900-01-01是星期一
        int totalNumberOfDays = getTotalNumberOfDays(year, month);
        return (totalNumberOfDays + START_DAY_FOR_1_1_1990) % 7;
    }

    /** 计算距离1900-01-01的天数 */
    private static int getTotalNumberOfDays(int year, int month) {
        int total = 0;
        for (int i = 1900; i < year; i++) {
            total += isLeapYear(year) ? 366 : 365;
        }
        for (int i = 1; i < month; i++) {
            total += getNumberOfDaysInMonth(year, i);
        }
        return total;
    }

    /** 判断是否是闰年 */
    private static boolean isLeapYear(int year) {
        return year % 400 == 0 || year % 4 == 0 && year % 100 != 0;
    }

    /** 得到该月份的天数 */
    private static int getNumberOfDaysInMonth(int year, int month) {
        if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8
                || month == 10 || month == 12) {
            return 31;
        } else if (month == 4 || month == 6 || month == 9 || month == 11) {
            return 30;
        } else {
            return isLeapYear(year) ? 29 : 28;
        }

    }

}

运行结果：

13. 【完全数】如果一个正整数等于除它本身之外其他所有除数之和，就称之为完全数。例如：6是第一个完全数，因为6 = 1+2+3.下一个完全数是28 = 1+2+4+7+14.10000以下的完全数一共有4个。编写程序，找出这4个完全数。

基本思想是对于一个数找出其所有因子（除本身之外的因子），然后将其所有的因子相加，如果和该数吻合，就代表该数是完全数。实现如下：

[java] view plain copy

print ?

public class Test {
public static void main(String[] args) {
System.out.println(”10000以下的完全数：”);
for (int number = 6; number <= 10000; number++) {
int sum = 0;
for (int divisor = 1; divisor < number; divisor++) {
if (number % divisor == 0) {
sum += divisor;
}
}
if (sum == number) {
System.out.print(number + ”\t”);
}
}
}
}

public class Test {

    public static void main(String[] args) {
        System.out.println("10000以下的完全数：");
        for (int number = 6; number <= 10000; number++) {
            int sum = 0;
            for (int divisor = 1; divisor < number; divisor++) {
                if (number % divisor == 0) {
                    sum += divisor;
                }
            }
            if (sum == number) {
                System.out.print(number + "\t");
            }
        }
    }

}

运行结果：

14. 【十进制转化为二进制】输入一个十进制数输出其对应的二进制（不允许使用Integer.toBinaryString（）方法）。

[java] view plain copy

print ?

import java.util.Scanner;
public class Test {
public static void main(String[] args) {
System.out.println(”请输入十进制整数：”);
String binaryString = ”“;
int num = new Scanner(System.in).nextInt();
do {
// 这一句非常巧妙：将原先的字符串追加到当前字符串的末尾
binaryString = num % 2 + binaryString;
} while ((num /= 2) != 0);
System.out.println(”对应的二进制数是：” + binaryString);
}
}

import java.util.Scanner;

public class Test {

    public static void main(String[] args) {
        System.out.println("请输入十进制整数：");
        String binaryString = "";
        int num = new Scanner(System.in).nextInt();
        do {
            // 这一句非常巧妙：将原先的字符串追加到当前字符串的末尾
            binaryString = num % 2 + binaryString;
        } while ((num /= 2) != 0);
        System.out.println("对应的二进制数是：" + binaryString);
    }

}

同理，可以完成“十进制到十六进制的转换”【关键就是字符串的拼接顺序问题】

[java] view plain copy

print ?

import java.util.Scanner;
public class Test {
public static void main(String[] args) {
System.out.println(”请输入十进制整数：”);
String hexString = ”“;
int num = new Scanner(System.in).nextInt();
do {
int currentNum = num % 16;
switch (currentNum) {
case 10:
hexString = ’A’ + hexString;
break;
case 11:
hexString = ’B’ + hexString;
break;
case 12:
hexString = ’C’ + hexString;
break;
case 13:
hexString = ’D’ + hexString;
break;
case 14:
hexString = ’E’ + hexString;
break;
case 15:
hexString = ’F’ + hexString;
break;
default:
hexString = currentNum + hexString;
break;
}
} while ((num /= 16) != 0);
System.out.println(”对应的十六进制数是：” + hexString);
}
}

import java.util.Scanner;

public class Test {

    public static void main(String[] args) {
        System.out.println("请输入十进制整数：");
        String hexString = "";
        int num = new Scanner(System.in).nextInt();
        do {
            int currentNum = num % 16;

            switch (currentNum) {
            case 10:
                hexString = 'A' + hexString;
                break;
            case 11:
                hexString = 'B' + hexString;
                break;
            case 12:
                hexString = 'C' + hexString;
                break;
            case 13:
                hexString = 'D' + hexString;
                break;
            case 14:
                hexString = 'E' + hexString;
                break;
            case 15:
                hexString = 'F' + hexString;
                break;
            default:
                hexString = currentNum + hexString;
                break;
            }

        } while ((num /= 16) != 0);
        System.out.println("对应的十六进制数是：" + hexString);
    }

}

另一种实现：

[java] view plain copy

print ?

import java.util.Scanner;
public class Decimal2HexConversion {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println(”请输入一个整数：”);
int number = scanner.nextInt();
scanner.close();
System.out.println(number + ”转化为16进制后是：” + decimal2HexString(number));
}
private static String decimal2HexString(int number) {
String hexString = ”“;
do {
int hexValue = number % 16;
hexString = toHexChar(hexValue) + hexString;
} while ((number /= 16) != 0);
return hexString;
}
private static char toHexChar(int hexValue) {
if (hexValue >= 0 && hexValue <= 9) {
return (char) (‘0’ + hexValue);
} else {
return (char) (hexValue - 10 + ‘A’);
}
}
}

import java.util.Scanner;

public class Decimal2HexConversion {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int number = scanner.nextInt();
        scanner.close();
        System.out.println(number + "转化为16进制后是：" + decimal2HexString(number));
    }

    private static String decimal2HexString(int number) {
        String hexString = "";
        do {
            int hexValue = number % 16;
            hexString = toHexChar(hexValue) + hexString;
        } while ((number /= 16) != 0);
        return hexString;
    }

    private static char toHexChar(int hexValue) {
        if (hexValue >= 0 && hexValue <= 9) {
            return (char) ('0' + hexValue);
        } else {
            return (char) (hexValue - 10 + 'A');
        }
    }

}

15. （计算机体系结构方面：比特级的操作）一个int类型的数据需要使用32byte存储。编写程序，提示用户输入一个短整型，然后显示这个整数的32比特形式。

[java] view plain copy

print ?

import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println(”请输入一个整数：”);
int value = scanner.nextInt();
System.out.println(”补码表示：”);
int mask = 1;
int count = 0;
for (int i = 31; i >= 0; i–) {
int temp = value >> i;
int bit = temp & mask;
System.out.print(bit);
if (++count % 4 == 0) {
System.out.print(’,’);
}
}
}
}

import java.util.Scanner;

public class Test {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int value = scanner.nextInt();
        System.out.println("补码表示：");
        int mask = 1;
        int count = 0;
        for (int i = 31; i >= 0; i--) {
            int temp = value >> i;
            int bit = temp & mask;
            System.out.print(bit);
            if (++count % 4 == 0) {
                System.out.print(',');
            }
        }
    }

}

16. 【双素数】双素数是指一对差值为2的素数。例如：3和5是一对双素数，5和7是一对双素数，而11和13也是一对双素数。编写程序找出小于1000的所有双素数。显示结果如下：

(3,5)

(5,7)

……

解析：这个题的难点在于如何保存前一个素数。我们可以采用以下的算法：首先令前一个数p1 = 2，第二个数p2从3开始递增，依次判断p2是否是素数，如果p2是素数那么进一步判断p2与p1的差值是否是2，如果是就打印结果；最后将p2的值赋值给p1（更新p1的值，因为p2是素数那么更新后的p1也就是素数了）。实现如下：

[java] view plain copy

print ?

public class Test {
public static void main(String[] args) {
int p1 = 2;
for (int p2 = 3; p2 <= 1000; p2++)
if (isPrime(p2)) {
if (p2 - p1 == 2) {
System.out.println(”(“ + p1 + “,” + p2 + “)”);
}
p1 = p2;
}
}
private static boolean isPrime(double number) {
for (int i = 2; i <= number / 2; i++) {
if (number % i == 0) {
return false;
}
}
return true;
}
}

public class Test {

    public static void main(String[] args) {
        int p1 = 2;
        for (int p2 = 3; p2 <= 1000; p2++)
            if (isPrime(p2)) {
                if (p2 - p1 == 2) {
                    System.out.println("(" + p1 + "," + p2 + ")");
                }
                p1 = p2;
            }
    }

    private static boolean isPrime(double number) {
        for (int i = 2; i <= number / 2; i++) {
            if (number % i == 0) {
                return false;
            }
        }
        return true;
    }

}

17. 根据currentTimeMillis输出年月日星期。

[java] view plain copy

print ?

public class Test {
public static void main(String[] args) {
System.out.println(getTimeAndDate());
}
private static String getTimeAndDate() {
long totalMillis = System.currentTimeMillis();
int currentMills = (int) (totalMillis % 1000);
long totalSecond = totalMillis / 1000;
int currentSecond = (int) (totalSecond % 60);
int totalMinute = (int) (totalSecond / 60);
int currentMinute = totalMinute % 60;
int totalHour = totalMinute / 60;
int currentHour = (totalHour + 8) % 24;
int totalDay = totalHour / 24 + 1;
int week = (4 + totalDay - 1) % 7;
int year = 0;
for (year = 1970; totalDay > (isLeapYear(year) ? 366 : 365); year++) {
totalDay -= (isLeapYear(year) ? 366 : 365);
}
int month;
for (month = 1; totalDay > getNumberOfDaysInMonth(year, month); month++) {
totalDay -= getNumberOfDaysInMonth(year, month);
}
return “系统时间：” + year + “年” + month + “月” + totalDay + “日 ”
+ currentHour + ”:” + currentMinute + “:” + currentSecond + “.”
+ currentMills + ” ” + getWeekName(week);
}
private static int getNumberOfDaysInMonth(int year, int month) {
if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8
|| month == 10 || month == 12) {
return 31;
} else if (month == 4 || month == 6 || month == 9 || month == 11) {
return 30;
} else {
return isLeapYear(year) ? 29 : 28;
}
}
private static String getWeekName(int week) {
String weekName = null;
switch (week) {
case 0:
weekName = ”星期天”;
break;
case 1:
weekName = ”星期一”;
break;
case 2:
weekName = ”星期二”;
break;
case 3:
weekName = ”星期三”;
break;
case 4:
weekName = ”星期四”;
break;
case 5:
weekName = ”星期五”;
break;
case 6:
weekName = ”星期六”;
break;
default:
break;
}
return weekName;
}
private static boolean isLeapYear(int year) {
return year % 400 == 0 || year % 4 == 0 && year % 100 != 0;
}
}

public class Test {

    public static void main(String[] args) {
        System.out.println(getTimeAndDate());
    }

    private static String getTimeAndDate() {
        long totalMillis = System.currentTimeMillis();
        int currentMills = (int) (totalMillis % 1000);
        long totalSecond = totalMillis / 1000;
        int currentSecond = (int) (totalSecond % 60);
        int totalMinute = (int) (totalSecond / 60);
        int currentMinute = totalMinute % 60;
        int totalHour = totalMinute / 60;
        int currentHour = (totalHour + 8) % 24;
        int totalDay = totalHour / 24 + 1;
        int week = (4 + totalDay - 1) % 7;
        int year = 0;
        for (year = 1970; totalDay > (isLeapYear(year) ? 366 : 365); year++) {
            totalDay -= (isLeapYear(year) ? 366 : 365);
        }
        int month;
        for (month = 1; totalDay > getNumberOfDaysInMonth(year, month); month++) {
            totalDay -= getNumberOfDaysInMonth(year, month);
        }
        return "系统时间：" + year + "年" + month + "月" + totalDay + "日 "
                + currentHour + ":" + currentMinute + ":" + currentSecond + "."
                + currentMills + " " + getWeekName(week);
    }

    private static int getNumberOfDaysInMonth(int year, int month) {
        if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8
                || month == 10 || month == 12) {
            return 31;
        } else if (month == 4 || month == 6 || month == 9 || month == 11) {
            return 30;
        } else {
            return isLeapYear(year) ? 29 : 28;
        }
    }

    private static String getWeekName(int week) {
        String weekName = null;
        switch (week) {
        case 0:
            weekName = "星期天";
            break;
        case 1:
            weekName = "星期一";
            break;
        case 2:
            weekName = "星期二";
            break;
        case 3:
            weekName = "星期三";
            break;
        case 4:
            weekName = "星期四";
            break;
        case 5:
            weekName = "星期五";
            break;
        case 6:
            weekName = "星期六";
            break;
        default:
            break;
        }
        return weekName;
    }

    private static boolean isLeapYear(int year) {
        return year % 400 == 0 || year % 4 == 0 && year % 100 != 0;
    }

}

运行结果：

18.输出原来数组的逆序（注意并不改变原来的数组，仅仅是返回一个新的数组，新的数组中的元素是原来数组的逆序）。

[java] view plain copy

print ?

public class Test {
public static void main(String[] args) {
int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
System.out.println(”原来的数组元素：”);
for (int i : a) {
System.out.print(i + ”\t”);
}
int[] b = reverse(a);
System.out.println(”\n逆序后数组元素：”);
for (int i : b) {
System.out.print(i + ”\t”);
}
}
/** 返回原来数组的逆序 */
private static int[] reverse(int[] a) {
int[] result = new int[a.length];// 开辟和传入数组相同的空间
for (int i = 0, j = a.length - 1; i < a.length; i++, j–) {
result[i] = a[j];// 新数组与传入数组的对应关系(0,length-1)、(1,lenth-2)……
}
return result;
}
}

public class Test {

    public static void main(String[] args) {

        int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        System.out.println("原来的数组元素：");
        for (int i : a) {
            System.out.print(i + "\t");
        }
        int[] b = reverse(a);
        System.out.println("\n逆序后数组元素：");
        for (int i : b) {
            System.out.print(i + "\t");
        }
    }

    /** 返回原来数组的逆序 */
    private static int[] reverse(int[] a) {
        int[] result = new int[a.length];// 开辟和传入数组相同的空间
        for (int i = 0, j = a.length - 1; i < a.length; i++, j--) {
            result[i] = a[j];// 新数组与传入数组的对应关系(0,length-1)、(1,lenth-2)……
        }
        return result;
    }

}

19. 选择排序和插入排序。

选择排序：

插入排序：

[java] view plain copy

print ?

import java.util.Arrays;
public class Test {
public static void main(String[] args) {
double[] a = { 2, 9, 5, 4, 8, 1, 6 };
double[] b = Arrays.copyOf(a, a.length);
System.out.println(”原来的数组：”);
for (double d : a) {
System.out.print(d + ”\t”);
}
selectionSort(a);
System.out.println(”\n选择排序【升序排序】（先找出最小的）：”);
for (double d : a) {
System.out.print(d + ”\t”);
}
insertionSort(b);
System.out.println(”\n插入排序【升序排序】（不断向已经排好序的数组中插入元素）”);
for (double d : b) {
System.out.print(d + ”\t”);
}
}
/** 选择排序 */
private static void selectionSort(double[] list) {
for (int i = 0; i < list.length - 1; i++) {
// 在list[i]~list[list.length-1]之间找出最小值
double currentMin = list[i];
int currentMinIndex = i;
for (int j = i + 1; j < list.length; j++) {
if (currentMin > list[j]) {
currentMin = list[j];
currentMinIndex = j;
}
}
if (currentMinIndex != i) {
list[currentMinIndex] = list[i];
list[i] = currentMin;
}
}
}
/** 插入排序 */
private static void insertionSort(double[] list) {
for (int i = 1; i < list.length; i++) {
double currentElement = list[i];
// 把list[i]插入到list[0]~list[i-1]之间，这样list[0]~list[i]就排好序了
int j;
for (j = i - 1; j >= 0 && list[j] > currentElement; j–) {
list[j + 1] = list[j];
}
// 把当前元素插入到list[j+1]
list[j + 1] = currentElement;
}
}
}

import java.util.Arrays;

public class Test {

    public static void main(String[] args) {
        double[] a = { 2, 9, 5, 4, 8, 1, 6 };
        double[] b = Arrays.copyOf(a, a.length);
        System.out.println("原来的数组：");
        for (double d : a) {
            System.out.print(d + "\t");
        }
        selectionSort(a);
        System.out.println("\n选择排序【升序排序】（先找出最小的）：");
        for (double d : a) {
            System.out.print(d + "\t");
        }
        insertionSort(b);
        System.out.println("\n插入排序【升序排序】（不断向已经排好序的数组中插入元素）");
        for (double d : b) {
            System.out.print(d + "\t");
        }
    }

    /** 选择排序 */
    private static void selectionSort(double[] list) {
        for (int i = 0; i < list.length - 1; i++) {
            // 在list[i]~list[list.length-1]之间找出最小值
            double currentMin = list[i];
            int currentMinIndex = i;

            for (int j = i + 1; j < list.length; j++) {
                if (currentMin > list[j]) {
                    currentMin = list[j];
                    currentMinIndex = j;
                }
            }
            if (currentMinIndex != i) {
                list[currentMinIndex] = list[i];
                list[i] = currentMin;
            }
        }
    }

    /** 插入排序 */
    private static void insertionSort(double[] list) {
        for (int i = 1; i < list.length; i++) {
            double currentElement = list[i];
            // 把list[i]插入到list[0]~list[i-1]之间，这样list[0]~list[i]就排好序了
            int j;
            for (j = i - 1; j >= 0 && list[j] > currentElement; j--) {
                list[j + 1] = list[j];
            }
            // 把当前元素插入到list[j+1]
            list[j + 1] = currentElement;
        }
    }

}

在选择排序中，外层循环迭代执行以寻找list[1]~list[list.length-1]列表中的最小值，然后将它和list[i]互换。变量i的初值是0，最外层的每次迭代完成之后，list[i]都被放置到正确的位置。

在插入排序中，外层循环获取已经排好序的子数列list[0~i-1]，内层循环将list[i]插入到list[0]~list[i-1]的子数列中。为了将list[i]插入list[0]~list[i-1]，需要将list[i]存储在一个名为currentElement的变量中。如果list[i-1]>currentElement，就需要将list[i-1]移到list[i]；如果list[i-2]>currentElement，就需要将list[i-2]移动到list[i-1]，依此类推，直到list[i-k]<=currentElement或者k>i（传递的是排好序的数列的第一个元素）。将currentElement赋值给list[i-k+1]。例如：为了将4插入到{2,5,9}中，因为9>4,需要将list[2]（9）移动到list[3]，又因为5>4，需要将list[1]（5）移动到list[2]，最后将currentElement（4）移动到list[1],如图所示：

20. 【豆机】，也称为梅花瓶或者高尔顿瓶，是一个用来做统计实验的设备，是一个三角形形状的均匀放置钉子（或者钩子）的直立板子，如图所示：

你可能感兴趣的:(java算法,Java算法)

比较好的知识点 hc.Geng java
2023年Java超全面试题及答案解析---https://blog.csdn.net/qq_42301302/article/details/1287852747分钟带你细致解析4个Java算法必刷题---https://blog.csdn.net/hcxy2022/article/details/12796379750道JAVA基础算法编程题【内含分析、程序答案】---https://blog
完成所有工作的最短时间（Java算法每日一题）万家林 leetcode 算法 leetcode
问：给你一个整数数组jobs，其中jobs[i]是完成第i项工作要花费的时间。请你将这些工作分配给k位工人。所有工作都应该分配给工人，且每项工作只能分配给一位工人。工人的工作时间是完成分配给他们的所有工作花费时间的总和。请你设计一套最佳的工作分配方案，使工人的最大工作时间得以最小化。返回分配方案中尽可能最小的最大工作时间。原题链接：https://leetcode.cn/problems/find
Java算法排序之冒泡/插入/选择/快速、二分查找 - 附动图布衣不才Jerry
1.Java排序：冒泡排序-最简单（1）比较前后相邻的二个数据，如果前面数据大于后面的数据，就将这二个数据交换。（2）这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第N-1个位置。（3）N=N-1，如果N不为0就重复前面二步，否则排序完成。Java冒泡排序【逻辑】外层0~array[j+1]){//相邻元素，升序//if(array[j]0;j--){//temp
java算法笔记倔强青铜弟中弟
排序算法冒泡排序冒泡排序是最简单的排序之一了，其大体思想就是通过与相邻元素的比较和交换来把小的数交换到最前面。这个过程类似于水泡向上升一样，因此而得名。举个栗子：对5,3,8,6,4这个无序序列进行冒泡排序。1.首先从后向前冒泡，4和6比较，把4交换到前面，序列变成5,3,8,4,6。2.同理4和8交换，变成5,3,4,8,6,3和4无需交换。3.5和3交换，变成3,5,4,8,6,3.这样一次冒
华为OD机试 - 数组去重和排序（Java）程序员阿甘 Java 华为OD机试AB卷华为od java 算法
题目描述给定一个乱序的数组，删除所有的重复元素，使得每个元素只出现一次，并且按照出现的次数从高到低进行排序，相同出现次数按照第一次出现顺序进行先后排序。输入描述一个数组输出描述去重排序后的数组用例输入1,3,3,3,2,4,4,4,5输出3,4,1,2,5备注数组大小不超过100数组元素值大小不超过100。题目解析简单的排序问题。Java算法源码importjava.util.HashMap;im
CISC 223 java算法分析后端
CISC223-Assignment2(Winter2024)Due:ThursdayFebruary8,2:00PMRegulationsonassignments•Theassignmentsaregradedaccordingtothecorrectness,precisenessandlegibilityofthesolutions.Allhandwrittenparts,includin
Java算法练习4 It_张算法练习 Java java 算法开发语言
Java算法练习41.1[145.二叉树的后序遍历](https://leetcode.cn/problems/binary-tree-postorder-traversal/)1.2[173.二叉搜索树迭代器](https://leetcode.cn/problems/binary-search-tree-iterator/)1.3[98.验证二叉搜索树](https://leetcode.cn
Java算法 leetcode简单刷题记录11 程序媛一枚~ JAVA 算法算法 java leetcode
Java算法leetcode简单刷题记录11删除排序链表中的重复元素：https://leetcode.cn/problems/remove-duplicates-from-sorted-list/合并俩个有序数组：https://leetcode.cn/problems/merge-sorted-array/int[]数组转List:Arrays.stream(arr).collect(Coll
LeetCode题解java算法： 83. 删除排序链表中的重复元素神石石 Leecode 数据结构和算法链表 leetcode java 算法数据结构
存在一个按升序排列的链表，给你这个链表的头节点head，请你删除所有重复的元素，使每个元素只出现一次。返回同样按升序排列的结果链表。示例1：输入：head=[1,1,2]输出：[1,2]示例2：输入：head=[1,1,2,3,3]输出：[1,2,3]链表解题思路：/***Definitionforsingly-linkedlist.*publicclassListNode{*intval;*Li
Java算法 leetcode简单【树的遍历，深度计算及比较】刷题记录程序媛一枚~ JAVA 算法算法 java leetcode
Java算法leetcode简单【树的遍历，深度计算及比较】刷题记录俩数之和：https://leetcode.cn/problems/two-sum/二进制求和：https://leetcode.cn/problems/add-binary/classSolution{publicStringaddBinary(Stringa,Stringb){intnumA=a.length();intnum
2024年Java实战面试题内卷成仙 2024年Java面试题 java 面试 spring cloud 开发语言 Java面试题
高阶篇：2024年Java高阶面试题-CSDN博客算法篇：2024年Java算法面试题-CSDN博客基础篇：2024年Java基础面试题-CSDN博客原理篇：2024年Java原理面试题-CSDN博客搭建篇：2024年Java搭建面试题-CSDN博客
2024年Java算法面试题内卷成仙 2024年Java面试题算法 java 排序算法 Java面试题
2024年Java实战面试题（北京）_java5年面试-CSDN博客一、波菲那契递归System.out.println("banc="+banc(10))publicstaticintbanc(intn){if(n==0){return0;}elseif(n==1){return1;}else{returnbanc(n-1)+banc(n-2);}}二、冒泡排序publicstaticvoids
Java算法 leetcode简单刷题记录9 程序媛一枚~ JAVA 算法算法 java leetcode
Java算法leetcode简单刷题记录9购买俩块巧克力：https://leetcode.cn/problems/buy-two-chocolates/给定数组量并不大，因此也可以不用PriorityQueue，每次输出最小值；可以暴力循环classSolution{publicintbuyChoco(int[]prices,intmoney){intsum=Integer.MAX_VALUE;
Java算法 leetcode简单刷题记录8 程序媛一枚~ JAVA 算法算法 java leetcode
Java算法leetcode简单刷题记录8找出不同元素数目差数组：https://leetcode.cn/problems/find-the-distinct-difference-array/保龄球游戏的获胜者：https://leetcode.cn/problems/determine-the-winner-of-a-bowling-game/计数器II：https://leetcode.cn
Java算法 leetcode简单刷题记录10 程序媛一枚~ JAVA 算法算法 java leetcode
Java算法leetcode简单刷题记录10庆祝一下：大概花费了9天，我把所有leetcodeJava的简单题都刷完了，接下来开始冲刺中等和复杂；简单题里用到的比较多的是字符串的处理，转换，拆分，替换，PriorityQueue依次输出最大最小值；走楼梯等动态规划；charAtstartsWithtoLowerCase()replaceAllsplitindexOf进制转换：Integer.val
Java算法---递归算法基础介绍菜到极致就是渣 Java算法算法 java
目录一、递归算法二、递归算法的典型例子（1）阶乘（2）二分查找（3）冒泡排序（4）插入排序一、递归算法计算机科学中，递归是一种解决计算问题的方法。其中解决方案取决于同一类问题的更小子集。说明如下。（1）自己调用自己，如果说每个函数对应着一种解决方案，自己调用自己意味着解决方案是一样的（有规律的）（2）每次调用，函数处理的数据会较上次缩减（子集），而且最后会缩减至无须继续递归。（3）内层函数调用（子
java算法之简单的矩阵螺旋式遍历Spiral Matrix Tomes_V_White java 算法
转载自：http://blog.csdn.net/ylyg050518/article/details/48547619继续看一个与数组操作相关的算法，这道题目给我们提供了一个遍历二维数组的新方式——螺旋式遍历。问题描述原文：Givenamatrixofm×nelements(mrows,ncolumns),returnallelementsofthematrixinspiralorder.For
Java算法练习题 wsrfsg Java算法练习 java 算法数据结构动态规划
目录有效的数独单词拆分动态规划题型dp难点如果想要将列表中的所有字符串连接成一个单一的字符串，可以使用stream().collect()和joining()方法获取列表中的第一个字符串有效的数独publicclassIsShuDu{publicbooleanisValiduku(char[][]board){boolean[][]rowUsed=newboolean[9][9];boolean[
Java算法 leetcode简单刷题记录6 程序媛一枚~ JAVA 算法算法 java leetcode
Java算法leetcode简单刷题记录6环和杆：https://leetcode.cn/problems/rings-and-rods/统计范围内的元音字符串数：https://leetcode.cn/problems/count-the-number-of-vowel-strings-in-range/最长平衡子字符串：https://leetcode.cn/problems/find-the
Java算法 leetcode简单刷题记录7 程序媛一枚~ 算法 JAVA 算法 java leetcode
Java算法leetcode简单刷题记录7最长奇偶子数组：https://leetcode.cn/problems/longest-even-odd-subarray-with-threshold/有的题看着不难，根据提示往下写，有的case就是死活过不了这道题耗了挺久…classSolution{publicintlongestAlternatingSubarray(int[]nums,intt
JAVA算法API-Arrays 成果、算法 java 排序算法
目录方法演示：针对于最后一个方法：内部逻辑：操作数组的工具类内部方法几乎都是静态修饰的，因此直接类名调用即可方法演示：//1.toStringint[]arr={1,2,5,3,4};System.out.println(Arrays.toString(arr));//[1,2,5,3,4]//2.binarysearch(二分法查找元素)System.out.println(Arrays.bin
JAVA算法-查找成果、 java 算法开发语言
目录基本查找*：二分查找*：数据单调递增：数据单调递减：总结规律：插值查找*：斐波那契查找（了解原理）：以后补分块查找*：特殊情况（无规律的数据）：以上小结：哈希查找（了解原理）：以后补树表查找（涉及数据结构）：以后补基本查找*：也叫线性查找，从头到尾依次遍历示例：需求1：定义一个方法利用基本查找，查询某个元素在数组中是否存在publicstaticvoidmain(String[]args){i
JAVA算法—排序成果、算法 java 排序算法
目录*冒泡排序：*选择排序：插入排序：快速排序：总结：以下全部以升序为例*冒泡排序：引用：在完成升序排序时，最大的元素会经过一轮轮的遍历逐渐被交换到数列的末尾，就像气泡从水底慢慢升到水面的过程。这个过程会重复进行，直到整个序列有序，即没有更多的“气泡”需要“上浮”。步骤（针对于升序）：从0索引开始向后，相邻元素两两相比（索引0和1、1和2），小的放在左，大的放在右。如上面动图，在最大的数放置在最右
Java算法 leetcode简单刷题记录3 程序媛一枚~ JAVA 算法 java leetcode 开发语言
Java算法leetcode简单刷题记录3汇总区间：https://leetcode.cn/problems/summary-ranges/把数据按照是否连续分组输出主要是n
Java算法 leetcode简单刷题记录5 程序媛一枚~ JAVA 算法算法 java leetcode
Java算法leetcode简单刷题记录5老人的数目：https://leetcode.cn/problems/number-of-senior-citizens/substring(a,b)前闭后开统计能整除数字的位数：https://leetcode.cn/problems/count-the-digits-that-divide-a-number/并不复杂，直接写就行从数量最多的堆取走礼物：
Java算法 leetcode简单刷题记录2 程序媛一枚~ JAVA 算法算法 java leetcode
Java算法leetcode刷题记录2最后一个字母长度：https://leetcode.cn/problems/length-of-last-word/str.trim()去掉开头结尾空格；不会去掉中间空格；搜索插入位置（有序的数列，2分查找法）：https://leetcode.cn/problems/search-insert-position/多个数排序可以用PriorityQueue;数
Java算法 leetcode简单刷题记录4 程序媛一枚~ JAVA 算法算法 java leetcode
Java算法leetcode简单刷题记录4买卖股票的最佳时机：https://leetcode.cn/problems/best-time-to-buy-and-sell-stock/笨办法：记录当天的值及之后的最大值，相减得到利润；所有的天都计算下，比较得到利润最大值；会超时记录过程中遇到的最低值，每当有利润大于0及大于上一个利润值的情况，赋值；最小和分割：https://leetcode.cn
java算法讲解_关于java:算法讲解｜贪心算法的理解与分析 steaven lee java算法讲解
贪婪算法Part1贪婪算法简介贪婪算法是从某一个初始状态登程，每次通过选取部分最优解向指标后退，并最终冀望获得整体最优解的一种算法。由这个定义可知，贪婪抉择规范就是抉择“以后最好”的决策，贪婪算法依据这个规范进行决策，将原问题变成一个类似但规模更小的子问题，而后每一步选出来的肯定是原问题整体最优解的一部分。如果一个问题贪婪后只剩下一个子问题且有最优子结构，那么该问题就能够应用贪婪算法。当一个问题的
Java算法题常用API整理总结 Infinity_and_beyond #数据结构与算法 eclipse java 算法数据结构
1.栈和队列LinkedList使用push插入元素时【栈】，头部元素peek为栈顶元素使用addLast插入元素时，头部元素peek为队首元素通常创建一个对象专精一个数据结构，不要串用1.1栈常用方法//栈顶插入元素push(ele)//返回栈顶元素并弹出pop()//返回栈顶元素但不弹出peek()1.2队列常用方法//头插addFirst(ele)//尾插addLast(ele)//获取队列
（十）Java算法：归并排序（详细图解）嘉禾嘉宁papa Java常用算法算法 java 归并排序算法
目录一、前言1.1、概念1.2、算法原理二、maven依赖三、流程解析3.1、整体流程图3.2、合并流程图四、编码实现一、前言1.1、概念归并排序：是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（DivideandConquer）的一个非常典型的应用。1.2、算法原理我们大概讲一下算法的原理。申请一个和原数组同样大小的空间，降低空间复杂度将一个要排序的序列从中间位置（left+
辗转相处求最大公约数沐刃青蛟 C++漏洞
无言面对”江东父老“了，接触编程一年了，今天发现还不会辗转相除法求最大公约数。惭愧惭愧！为此，总结一下以方便日后忘了好查找。 1.输入要比较的两个数a,b 忽略：2.比较大小（因为后面要的是大的数对小的数做%操作） 3.辗转相除（用循环不停的取余，如a%b,直至b=0） 4.最后的a为两数的最大公约数 &
F5负载均衡会话保持技术及原理技术白皮书 bijian1013 F5 负载均衡
一.什么是会话保持？在大多数电子商务的应用系统或者需要进行用户身份认证的在线系统中，一个客户与服务器经常经过好几次的交互过程才能完成一笔交易或者是一个请求的完成。由于这几次交互过程是密切相关的，服务器在进行这些交互过程的某一个交互步骤时，往往需要了解上一次交互过程的处理结果，或者上几步的交互过程结果，服务器进行下
Object.equals方法：重载还是覆盖 Cwind java generics override overload
本文译自StackOverflow上对此问题的讨论。原问题链接在阅读Joshua Bloch的《Effective Java（第二版）》第8条“覆盖equals时请遵守通用约定”时对如下论述有疑问： “不要将equals声明中的Object对象替换为其他的类型。程序员编写出下面这样的equals方法并不鲜见，这会使程序员花上数个小时都搞不清它为什么不能正常工作：” pu
初始线程 15700786134
暑假学习的第一课是讲线程，任务是是界面上的一条线运动起来。既然是在界面上，那必定得先有一个界面，所以第一步就是，自己的类继承JAVA中的JFrame，在新建的类中写一个界面，代码如下： public class ShapeFr
Linux的tcpdump 被触发 tcpdump
用简单的话来定义tcpdump，就是：dump the traffic on a network，根据使用者的定义对网络上的数据包进行截获的包分析工具。 tcpdump可以将网络中传送的数据包的“头”完全截获下来提供分析。它支持针对网络层、协议、主机、网络或端口的过滤，并提供and、or、not等逻辑语句来帮助你去掉无用的信息。实用命令实例默认启动 tcpdump 普通情况下，直
安卓程序listview优化后还是卡顿肆无忌惮_ ListView
最近用eclipse开发一个安卓app，listview使用baseadapter，里面有一个ImageView和两个TextView。使用了Holder内部类进行优化了还是很卡顿。后来发现是图片资源的问题。把一张分辨率高的图片放在了drawable-mdpi文件夹下，当我在每个item中显示，他都要进行缩放，导致很卡顿。解决办法是把这个高分辨率图片放到drawable-xxhdpi下。 &nb
扩展easyUI tab控件，添加加载遮罩效果知了ing jquery
(function () { $.extend($.fn.tabs.methods, { //显示遮罩 loading: function (jq, msg) { return jq.each(function () { var panel = $(this).tabs(&
gradle上传jar到nexus 矮蛋蛋 gradle
原文地址： https://docs.gradle.org/current/userguide/maven_plugin.html configurations { deployerJars } dependencies { deployerJars "org.apache.maven.wagon
千万条数据外网导入数据库的解决方案。 alleni123 sql mysql
从某网上爬了数千万的数据，存在文本中。然后要导入mysql数据库。悲剧的是数据库和我存数据的服务器不在一个内网里面。。 ping了一下， 19ms的延迟。于是下面的代码是没用的。 ps = con.prepareStatement(sql); ps.setString(1, info.getYear())............; ps.exec
JAVA IO InputStreamReader和OutputStreamReader 百合不是茶 JAVA.io操作字符流
这是第三篇关于java.io的文章了，从开始对io的不了解-->熟悉--->模糊，是这几天来对文件操作中最大的感受，本来自己认为的熟悉了的，刚刚在回想起前面学的好像又不是很清晰了，模糊对我现在或许是最好的鼓励我会更加的去学加油！： JAVA的API提供了另外一种数据保存途径，使用字符流来保存的，字符流只能保存字符形式的流字节流和字符的难点：a,怎么将读到的数据
MO、MT解读 bijian1013 GSM
MO= Mobile originate，上行，即用户上发给SP的信息。MT= Mobile Terminate，下行，即SP端下发给用户的信息；上行:mo提交短信到短信中心下行:mt短信中心向特定的用户转发短信，你的短信是这样的，你所提交的短信，投递的地址是短信中心。短信中心收到你的短信后，存储转发，转发的时候就会根据你填写的接收方号码寻找路由，下发。在彩信领域是一样的道理。下行业务：由SP
五个JavaScript基础问题 bijian1013 JavaScript call apply this Hoisting
下面是五个关于前端相关的基础问题，但却很能体现JavaScript的基本功底。问题1：Scope作用范围考虑下面的代码： (function() { var a = b = 5; })(); console.log(b); 什么会被打印在控制台上？回答：上面的代码会打印 5。 &nbs
【Thrift二】Thrift Hello World bit1129 Hello world
本篇，不考虑细节问题和为什么，先照葫芦画瓢写一个Thrift版本的Hello World，了解Thrift RPC服务开发的基本流程 1. 在Intellij中创建一个Maven模块，加入对Thrift的依赖，同时还要加上slf4j依赖，如果不加slf4j依赖，在后面启动Thrift Server时会报错 <dependency>
【Avro一】Avro入门 bit1129 入门
本文的目的主要是总结下基于Avro Schema代码生成，然后进行序列化和反序列化开发的基本流程。需要指出的是，Avro并不要求一定得根据Schema文件生成代码，这对于动态类型语言很有用。 1. 添加Maven依赖 <?xml version="1.0" encoding="UTF-8"?> <proj
安装nginx+ngx_lua支持WAF防护功能 ronin47
需要的软件:LuaJIT-2.0.0.tar.gz nginx-1.4.4.tar.gz &nb
java-5.查找最小的K个元素-使用最大堆 bylijinnan java
import java.util.Arrays; import java.util.Random; public class MinKElement { /** * 5.最小的K个元素 * I would like to use MaxHeap. * using QuickSort is also OK */ public static void
TCP的TIME-WAIT bylijinnan socket
原文连接： http://vincent.bernat.im/en/blog/2014-tcp-time-wait-state-linux.html 以下为对原文的阅读笔记说明：主动关闭的一方称为local end，被动关闭的一方称为remote end 本地IP、本地端口、远端IP、远端端口这一“四元组”称为quadruplet，也称为socket 1、TIME_WA
jquery ajax 序列化表单 coder_xpf Jquery ajax 序列化
checkbox 如果不设定值，默认选中值为on；设定值之后，选中则为设定的值 <input type="checkbox" name="favor" id="favor" checked="checked"/> $("#favor&quo
Apache集群乱码和最高并发控制 cuisuqiang apache tomcat 并发集群乱码
都知道如果使用Http访问，那么在Connector中增加URIEncoding即可，其实使用AJP时也一样，增加useBodyEncodingForURI和URIEncoding即可。最大连接数也是一样的，增加maxThreads属性即可，如下，配置如下： <Connector maxThreads="300" port="8019" prot
websocket dalan_123 websocket
一、低延迟的客户端-服务器和服务器-客户端的连接很多时候所谓的http的请求、响应的模式，都是客户端加载一个网页，直到用户在进行下一次点击的时候，什么都不会发生。并且所有的http的通信都是客户端控制的，这时候就需要用户的互动或定期轮训的，以便从服务器端加载新的数据。通常采用的技术比如推送和comet（使用http长连接、无需安装浏览器安装插件的两种方式：基于ajax的长
菜鸟分析网络执法官 dcj3sjt126com 网络
最近在论坛上看到很多贴子在讨论网络执法官的问题。菜鸟我正好知道这回事情.人道"人之患好为人师" 手里忍不住,就写点东西吧. 我也很忙.又没有MM,又没有MONEY....晕倒有点跑题. OK,闲话少说,切如正题. 要了解网络执法官的原理. 就要先了解局域网的通信的原理. 前面我们看到了.在以太网上传输的都是具有以太网头的数据包.
Android相对布局属性全集 dcj3sjt126com android
RelativeLayout布局android:layout_marginTop="25dip" //顶部距离android:gravity="left" //空间布局位置android:layout_marginLeft="15dip //距离左边距 // 相对于给定ID控件android:layout_above 将该控件的底部置于给定ID的
Tomcat内存设置详解 eksliang jvm tomcat tomcat内存设置
Java内存溢出详解一、常见的Java内存溢出有以下三种： 1. java.lang.OutOfMemoryError: Java heap space ----JVM Heap（堆）溢出JVM在启动的时候会自动设置JVM Heap的值，其初始空间(即-Xms)是物理内存的1/64，最大空间(-Xmx)不可超过物理内存。可以利用JVM提
Java6 JVM参数选项 greatwqs java HotSpot jvm jvm参数 JVM Options
Java 6 JVM参数选项大全（中文版）作者：Ken Wu Email: [email protected] 转载本文档请注明原文链接 http://kenwublog.com/docs/java6-jvm-options-chinese-edition.htm！本文是基于最新的SUN官方文档Java SE 6 Hotspot VM Opt
weblogic创建JMC i5land weblogic jms
进入 weblogic控制太 1.创建持久化存储 --Services--Persistant Stores--new--Create FileStores--name随便起--target默认--Directory写入在本机建立的文件夹的路径--ok 2.创建JMS服务器 --Services--Messaging--JMS Servers--new--name随便起--Pers
基于 DHT 网络的磁力链接和BT种子的搜索引擎架构 justjavac DHT
上周开发了一个磁力链接和 BT 种子的搜索引擎 {Magnet & Torrent}，本文简单介绍一下主要的系统功能和用到的技术。系统包括几个独立的部分：使用 Python 的 Scrapy 框架开发的网络爬虫，用来爬取磁力链接和种子；使用 PHP CI 框架开发的简易网站；搜索引擎目前直接使用的 MySQL，将来可以考虑使
sql添加、删除表中的列 macroli sql
添加没有默认值：alter table Test add BazaarType char(1) 有默认值的添加列：alter table Test add BazaarType char(1) default(0) 删除没有默认值的列：alter table Test drop COLUMN BazaarType 删除有默认值的列：先删除约束（默认值）alter table Test DRO
PHP中二维数组的排序方法 abc123456789cba 排序二维数组 PHP
<?php/*** @package BugFree* @version $Id: FunctionsMain.inc.php,v 1.32 2005/09/24 11:38:37 wwccss Exp $*** Sort an two-dimension array by some level
hive优化之------控制hive任务中的map数和reduce数 superlxw1234 hive hive优化
一、控制hive任务中的map数: 1. 通常情况下，作业会通过input的目录产生一个或者多个map任务。主要的决定因素有： input的文件总个数，input的文件大小，集群设置的文件块大小(目前为128M, 可在hive中通过set dfs.block.size;命令查看到，该参数不能自定义修改)；2.
Spring Boot 1.2.4 发布 wiselyman spring boot
Spring Boot 1.2.4已于6.4日发布，repo.spring.io and Maven Central可以下载(推荐使用maven或者gradle构建下载)。这是一个维护版本，包含了一些修复small number of fixes,建议所有的用户升级。 Spring Boot 1.3的第一个里程碑版本将在几天后发布，包含许多