Java—— 四道算法经典题-CSDN博客

本文链接：https://blog.csdn.net/zjy_ccccc/article/details/147618269

1.按照要求进行排序

需求：

定义数组并存储一些学生对象，利用Arrays中的sort方法进行排序
要求1:属性有姓名、年龄、身高。
要求2:按照年龄的大小进行排序，年龄一样，按照身高排序，身高一样按照姓名的字母进行排序。从小到大。

(姓名中不要有中文或特殊字符)

代码实现：

import java.util.Arrays;
import java.util.Comparator;

public class Test1 {
    public static void main(String[] args) {
       
        Student s1 = new Student("zhangsan", 23, 1.78);
        Student s2 = new Student("lisi", 23, 1.83);
        Student s3 = new Student("wangwu", 23, 1.78);
        Student s4 = new Student("zhaoliu", 24, 1.78);

        Student[] stuArr = {s1, s2, s3, s4};

        Arrays.sort(stuArr, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //按照年龄的升序排列
                double temp = o1.getAge() - o2.getAge();
                //判断temp是否是0
                //如果temp值不为0，证明年龄不同，就按照年龄排
                //如果temp值为0，证明年龄相同，按照身高升序排列
                temp = temp == 0 ? o1.getHeight() - o2.getHeight() : temp;
                //判断temp是否是0
                //如果temp值不为0，证明身高不同，就按照身高排
                //如果temp值为0，证明身高相同，按照姓名的字母升序排列
                temp = temp == 0 ? o1.getName().compareTo(o2.getName()) : temp;

                //方法返回的是int类型的值，temp是double类型的
                //强制转化可能有误，而该方法只看返回的值是正数还是负数还是0
                //所以进行判断，temp是正数就直接返回1，同理负数返回-1，0值返回0
                if (temp > 0) {
                    return 1;
                } else if (temp < 0) {
                    return -1;
                } else {
                    return 0;
                }
            }
        });
        System.out.println(Arrays.toString(stuArr));
        //[Student{name='wangwu', age=23, height=1.78},
        //Student{name='zhangsan', age=23, height=1.78},
        //Student{name='lisi', age=23, height=1.83},
        //Student{name='zhaoliu', age=24, height=1.78}]

        //Lambda表达式
        Arrays.sort(stuArr, (Student o1, Student o2) -> {
                    double temp = o1.getAge() - o2.getAge();
                    temp = temp == 0 ? o1.getHeight() - o2.getHeight() : temp;
                    temp = temp == 0 ? o1.getName().compareTo(o2.getName()) : temp;

                    if (temp > 0) {
                        return 1;
                    } else if (temp < 0) {
                        return -1;
                    } else {
                        return 0;
                    }
                }
        );
        System.out.println(Arrays.toString(stuArr));
        //[Student{name='wangwu', age=23, height=1.78},
        //Student{name='zhangsan', age=23, height=1.78},
        //Student{name='lisi', age=23, height=1.83},
        //Student{name='zhaoliu', age=24, height=1.78}]
    }
}

2.不死神兔（递归）

需求：

有一个很有名的数学逻辑题叫做不死神兔问题，有一对兔子，出生后需要生长一个月，之后每个月都生一对兔子，兔子生长一个月后每个月又生一对兔子，假如兔子都不死，问第十二个月的兔子对数为多少?

分析：

列表发现规律

月份	兔子的对数
1月	1
2月	1
3月	2
4月	3
5月	5
6月	8

1月和2月都是1对兔子，其余各月兔子的对数都是前两个月兔子的对数之和

（这种规律的数列在数学上称为斐波那契数列）

代码实现：

public class Test2 {
    public static void main(String[] args) {

        //第十二个月的兔子对数为多少?
        int num = getNum(12);
        System.out.println(num);//144

    }

    //定义递归方法
    public static int getNum(int month) {
        //1月和2月都是1对兔子
        if (month == 1 || month == 2) {
            return 1;
        }

        //其余各月兔子的对数都是前两个月兔子的对数之和
        return getNum(month - 1) + getNum(month - 2);
    }
}

3.猴子吃桃子（递归）

需求：

有一堆桃子，猴子第一天吃了其中的一半，并多吃了一个，以后每天猴子都吃当前剩下来的一半，然后再多吃一个，第10天的时候(还没吃)，发现只剩下一个桃子了，请问，最初总共多少个桃子（第一天）?

分析:

列表发现规律

天数	个数
10	1
9	（1+1）*2 = 4
8	（4+1）*2 = 10
7	（10+1）*2 = 22

某天剩余的桃子个数是后一天剩余桃子个数的加1乘2

代码实现：

public class Test3 {
    public static void main(String[] args) {

        //最初总共多少个桃子（第一天）
        int num = getNum(1);
        System.out.println(num);//1534

    }

    //定义递归方法
    public static int getNum(int day) {
        //第10天剩余1个桃子
        if (day == 10) {
            return 1;
        }
        //某天剩余的桃子个数是后一天剩余桃子个数的加1乘2
        return (getNum(day + 1) + 1) * 2;
    }
}

4.爬楼梯（递归）

需求：

小明特别喜欢爬楼梯，他有的时候一次爬一个台阶，有的时候一次爬两个台阶。
如果这个楼梯有20个台阶，小明一共有多少种爬法呢?

例如：

1层台阶：1种爬法，爬一个台阶1次
2层台阶：2种爬法，爬一个台阶2次或爬两个台阶1次
7层台阶：21种爬法......

分析：

引理：

从A到B有3种爬法，从B到C有2种爬法，则从A到C一共3*2=6种爬法

20个台阶的爬法：

假设经过x种爬法从第1个台阶爬到了第19个台阶，而19到20，1层台阶只有1种爬法，所以从1到20一共x*1=x种爬法，也就是19个台阶的爬法。

假设经过y种爬法从第1个台阶爬到了第18个台阶，而18到20，2层台阶有2种爬法，但是从18爬一个台阶到19这种爬法包含在x中，18到20只剩下了1种爬法，所以从1到20一共y*1=y种爬法，也就是18个台阶的爬法。

假设经过z种爬法从第1个台阶爬到了第17个台阶，但下一步不管是爬一个台阶还是爬两个台阶到达18或19，这种爬法都包含在了x和y中，其余16，15等等同理。

所以 20个台阶的爬法等于19个台阶的爬法x加18个台阶的爬法y。

结论：

某个台阶的爬法等于少1个台阶的爬法加少2个台阶的爬法。

代码实现：

public class Test4 {
    public static void main(String[] args) {

        //20个台阶，一共有多少种爬法
        int num = getNum(20);
        System.out.println(num);//10946

    }

    //定义递归方法
    public static int getNum(int n) {
        //1层台阶：1种爬法
        if (n == 1) {
            return 1;
        }
        //2层台阶：2种爬法
        if (n == 2) {
            return 2;
        }
        //其余某个台阶的爬法等于少1个台阶的爬法加少2个台阶的爬法。
        return getNum(n - 1) + getNum(n - 2);
    }
}