四个算法小题

排序问题

题目要求： 定义数组并存储一些女朋友对象 利用Arrays中的sort方法进行排序
要求： 1 属性有姓名、年龄、身高
2 按照年龄的大小进行排序 年龄一样 按照身高排序 身高一样按照姓名的字母进行排序

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

        //创建三个女朋友的对象
        Test08_GirlFriend gf1 = new Test08_GirlFriend("xiaoshishi",18,1.67);
        Test08_GirlFriend gf2 = new Test08_GirlFriend("xiaodandan",19,1.72);
        Test08_GirlFriend gf3 = new Test08_GirlFriend("xiaohuihui",19,1.78);

        //2.定义数组存储女朋友的信息
        Test08_GirlFriend[] arr ={gf1,gf2,gf3};
        //3.利用Arrays中的sort方法进行排序
        //匿名内部类,lambda表达式
        /*
        Arrays.sort(arr, new Comparator<Test08_GirlFriend>() {
            @Override
            public int compare(Test08_GirlFriend o1, Test08_GirlFriend 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;
               }

            }
        });
        */
        //lambda表达式
        //() -> {}
        //():对应着抽象方法的形参
        //{}: 方法体
        Arrays.sort(arr, ( o1,  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;
                }
        });
        //4.展示一下数组中的内容
        System.out.println(Arrays.toString(arr));

    }
}

public class Test08_GirlFriend {
    //要求一  属性有姓名、年龄、身高
    private String name;
    private  int age;
    private double height;


    public Test08_GirlFriend() {
    }

    public Test08_GirlFriend(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;
    }

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

不死神兔–递归

题目要求:有一个很有名的数学逻辑题叫做不死神兔，有一对兔子，从出生后第三个月起每个月都生一对兔子，
小兔子长到第三个月后每个月又生一对兔子，加入兔子都不死，问第十二个月兔子对数是多少
特点：从第三个数开始，是前两个数据和（斐波那契数列）

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

        特点：从第三个数开始，是前两个数据和（斐波那契数列）
         */

        //求解1
        /*
        //1.创建一个长度为12的数组
        int[] arr = new int[12];
        //2.手动给0索引和1索引的数据进行赋值
        arr[0] = 1;
        arr[1] = 1;
        //3.利用循环给剩余的数据进行赋值
        for (int i = 2; i < arr.length; i++) {
            arr[i] = arr[i-1]  + arr[i-2];
        }
        //1 1 2 3 5 8 ...

        //获取最大索引上的数据
        System.out.println(arr[11]);*/

        //求解2：
        //递归的方式去完成
        //1.递归的出口
        //2.递归的规律

         System.out.println(getSum(12));
    }


    public static  int getSum(int month){
        if(month == 1 || month == 2){
            return 1;
        }
        return getSum(month-1)+getSum(month-2);
    }
}

猴子吃桃子 — 递归

题目要求： 有一堆桃子,猴子第一天吃了一半 并多吃一个
以后每天猴子都吃当前剩下的一半，然后再多吃一个
第10天的时候发现只剩下一个桃子了，请问最初总共多少桃子

public class test10 {
    public static void main(String[] args) {
        /*
        猴子吃桃子
        有一堆桃子,猴子第一天吃了一半 并多吃一个
        以后每天猴子都吃当前剩下的一半，然后再多吃一个
        第10天的时候发现只剩下一个桃子了，请问最初总共多少桃子

        出口
          day == 10 剩下 1
        规律
         每一天的桃子数量都是后一天数量加1，乘以2
        */

        System.out.println(getCount(1));
    }

    public static int getCount(int day){
        if(day<=0 || day >= 11){
            System.out.println("当前时间错误");
            return -1;
        }
        //递归的出口
        if(day == 10){
            return 1;
        }
        //书写规律
        //每一天的桃子数量都是后一天数量加1，乘以2
        return (getCount(day+1)+1)*2;
    }
}

爬楼梯–递归

题目要求:小明爬楼梯有的时候一次爬一个台阶有的时候一次爬两个台阶
如果这个楼梯有20阶 小明一共多少种爬法

public class test11 {
    public static void main(String[] args) {
        /*
        爬楼梯
        小明爬楼梯有的时候一次爬一个台阶有的时候一次爬两个台阶
        如果这个楼梯有20阶 小明一共多少种爬法
         */
        System.out.println(getCount(20));
    }

    public static int getCount(int n){
        if(n==1){
            return 1;
        }
        if(n==2){
            return 2;
        }
        return getCount(n-1)+getCount(n-2);
    }
}