Java算法小练习——五道经典算法题

练习一：按照要求进行排序

        定义数组并存储一些朋友对象，利用Arrays中sort方法进行排序

        要求1：属性有姓名、年龄、身高。

        要求2：按照年龄的大小进行排序，年龄一样，按身高排序，身高一样安姓名的字母进行排序         （姓名中只能有中文）

代码：

我们先编写朋友类：

朋友类Friend:

public class Friend {
    //属性有姓名、年龄、身高。
    private String name;
    private int age;
    private double height;


    public Friend() {
    }

    public Friend(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return height
     */
    public double getHeight() {
        return height;
    }

    /**
     * 设置
     * @param height
     */
    public void setHeight(double height) {
        this.height = height;
    }

    public String toString() {
        return "Friend{name = " + name + ", age = " + age + ", height = " + height + "}";
    }
}

再编写main方法：

测试类AlgorithmTest1：

public class AlgorithmTest1 {
    public static void main(String[] args) {
        //定义数组并存储一些朋友对象，利用Arrays中sort方法进行排序
        //要求1：属性有姓名、年龄、身高。
        //要求2：按照年龄的大小进行排序，年龄一样，按身高排序，身高一样安姓名的字母进行排序
        //（姓名中只能有中文）

        //创建女朋友对象
        Friend gf1 = new Friend("yang", 21, 170);
        Friend gf2 = new Friend("ye", 20, 168);
        Friend gf3 = new Friend("le", 22, 166);
        //创建数组并存储女朋友对象
        Friend[] friendArr = {gf1,gf2,gf3};
        //进行排序
        Arrays.sort(friendArr, (o1,o2) -> {
                if(o1.getAge() != o2.getAge()){
                    return o1.getAge() - o2.getAge();
                } else if(o1.getHeight() != o2.getHeight()) {
                    return (int) (o1.getHeight() - o2.getHeight());
                } else {
                    return o1.getName().compareTo(o2.getName());
                }
        });

        for (int i = 0; i < friendArr.length; i++) {
            System.out.println(friendArr[i].toString());
        }
    }
}

运行结果：

练习二：不死神兔

        有一个很有名的数学逻辑题叫做不死神兔问题，有一对兔子，从出生后第三个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，加入兔子都不死，问第十二个月的兔子对数为多少？

分析：

        根据题目所述，即兔子出生后第一个月是小兔子，第二个月成长为大兔子，第三个月开始生小兔子，第一个月1只兔子，第二个月1只兔子，第三个月生了小兔子变成2只兔子（一只生兔子，一只小兔子），第四个月3只（一只生兔子，一致大兔子，一致小兔子），第五个月5只（两只生兔子，一只大兔子，两只小兔子），第六个月8只（三只生兔子，两只大兔子，三只小兔子）

        通过上述数据，我们可以推断出，除去第一月第二月，每个月分的兔子个数等于前一个月和前前个月兔子个数之和，我们便可以通过这个特点使用递归方法编写代码。

代码：

public class AlgorithmTest2 {
    public static void main(String[] args) {
        /*有一个很有名的数学逻辑题叫做不死神兔问题，有一对兔子，从出生后第三个月起每个月都生一对兔子，
        小兔子长到第三个月后每个月又生一对兔子，加入兔子都不死，问第十二个月的兔子对数为多少？*/

        //n > 2
        //n月的兔子个数 = （n-1）月的兔子个数 + （n-2）月的兔子个数
        //（n-1）月的兔子个数 = （n-2）月的兔子个数 + （n-3）月的兔子个数
        //……
        int num = getNum(12);
        System.out.println(num);

    }
    //使用递归
    public static int getNum(int month) {
        //出口
        if(month == 1 || month == 2) {
            return 1;
        }
        return getNum(month - 1) + getNum(month - 2);
    }
}

运行结果：

练习三：猴子吃桃子

        有一堆桃子，猴子第一天吃了其中一半，并多吃了一个，以后猴子每天都吃当前剩下来的一般，然后再多吃一个，第10天还没吃的时候，发现已经剩下一个桃子了，请问，最初有多少个桃子？

分析：

        前一天的桃子数 / 2 - 1 = 第二天的桃子数，即前一天桃子数=（后一天的桃子数 + 1）* 2

        第十天的桃子数为1。

        可以通过这两个条件使用递归方法求出第一天有多少个桃子

代码：

public class AlgorithmTest3 {
    public static void main(String[] args) {
        /*有一堆桃子，猴子第一天吃了其中一半，并多吃了一个，以后猴子每天都吃当前剩下来的一般，
        然后再多吃一个，第10天还没吃的时候，发现已经剩下一个桃子了，请问，最初有多少个桃子？*/

        int num = getNum(1);
        System.out.println(num);
    }

    public static int getNum(int day) {
        if(day == 10) {
            return 1;
        }
        return (getNum(day + 1) + 1) * 2;
    }
}

运行结果：

练习四：爬楼梯

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

分析：

        因为一次只可以爬1个台阶或者2个台阶，所以爬到第20个台阶的爬法 = 爬到第18个台阶的爬法 + 爬到第19个台阶的爬法，因为爬到第20个台阶只需要爬到第18爬两个台阶，或者爬到第19个台阶后爬一个台阶。所以我们可以通过这个特点采用递归方法。

代码：

public class AlgorithmTest4 {
    public static void main(String[] args) {
        /*小明特别喜欢爬楼梯，他有时候一次爬一个台阶，有时候一次爬两个台阶，
        如果这个楼梯有20个台阶，小明一个有多少种爬法呢？*/
        int num = getNum(20);
        System.out.println(num);
    }

    public static int getNum(int number) {
        if(number == 1) {
            return 1;
        }
        if(number == 2) {
            return 2;
        }
        return getNum(number - 1) + getNum(number - 2);
    }
}

运行结果：

练习五：爬楼梯进阶版

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

分析：

        其实万变不离其宗，这种情况下第20个台阶的爬法就等于到第17个台阶的爬法加上到第18个台阶的爬法再加上到第19个台阶的爬法.

代码：

public class AlgorithmTest5 {
    public static void main(String[] args) {
        /*小明特别喜欢爬楼梯，他有时候一次爬一个台阶，有时候一次爬两个台阶，有时一次爬三个台阶
        如果这个楼梯有20个台阶，小明一个有多少种爬法呢？*/

        int num = getNum(20);
        System.out.println(num);
    }

    public static int getNum(int num) {
        if(num == 1) {
            return 1;
        }
        if(num == 2) {
            return 2;
        }
        if(num == 3) {
            //3种：1 1 1，1 2 ，2 1，3
            return 4;
        }
        return getNum(num - 1) + getNum(num - 2) + getNum(num - 3);
    }
}

运行结果：