Java学习第二十四天＜克隆对象＞＜递归＞

克隆对象

package chapter06.D4克隆对象;
​
public class MethodExercise {
    public static void main(String[] args) {
        Per p = new Per();
        p.name="milan";
        p.age=100;
        MyTools tools = new MyTools();
        Per p2=tools.copyPerson(p);//到此p和p2是per类两个独立的对象，属性相同
        System.out.println("p的属性 age="+p.age +"名字="+p.name);
        System.out.println("p2的属性 age="+p2.age +"名字="+p2.name);
        System.out.println(p==p2);
​
    }
}
class Per{
    String name;
    int age;
}
class MyTools{
    public Per copyPerson(Per p){
        Per p2=new Per();
        p2.name= p.name;
        p2.age= p.age;
        return p2;
    }
}

递归

package chapter06.D5递归;
​
public class Recursion01 {
    public static void main(String[] args) {
        T t1 = new T();
        t1.test(4);
        int res=t1.factorial(5);
        System.out.println("res="+res);
​
    }
}
class T{
    public void test(int n){
        if(n>2){
            test(n-1);
        }
        System.out.println("n="+n);//加else后变2
    }
    public int factorial(int n){//阶层
        if (n == 1) {
            return 1;
        }else {
            return factorial(n-1)*n;
        }
    }
}

斐波那契数列

package chapter06.D5递归;
​
import java.util.Scanner;
​
//1，1，2，3，5，8，13....
public class RecursionExercise01 {
    public static void main(String[] args) {
        T2 t1 = new T2();
        Scanner s = new Scanner(System.in);
        System.out.println("请输入整数");
        System.out.println("斐波那契数="+t1.fibonacci(s.nextInt()));
​
    }
}
class T2{
    public int fibonacci(int n){
        if (n >=1) {
            if (n == 1||n==2) {
                return 1;
            }else {
                return fibonacci(n-1)+fibonacci(n-2);
            }
        }else {
            System.out.println("要求出入的n>=1的整数");
            return -1;
        }
​
    }
}

猴子吃桃

package chapter06.D5递归;
/*
1 day=10天 1个桃子
2 day=9天  （day10+1）*2=4
3 day=8天  （day9+1）*2=10
4 规律     前一天桃子=（后一天桃子+1）*2
5 递归
 */
public class RecursionExercise02 {
    public static void main(String[] args) {
        P p = new P();
        int day=0;
        int peachNum =p.peach(day);
        if (peachNum!=-1){
            System.out.println("第"+day+"天有"+peachNum+"个桃子");
        }
​
​
    }
}
class P{
    public int peach(int day){
        if (day==10){
            return 1;
        }else if (day>=1&&day<=9){
            return (peach(day+1)+1)*2;//（后一天桃子+1）*2
        }else {
            System.out.println("day在1-10天");
            return -1;
        }
    }
}

老鼠出迷宫

package chapter06.D5递归;
​
public class MiGong {
    public static void main(String[] args) {
        /*
        1 二维数组创建迷宫 8*7
        2 规定map数组元素值 0可以走  1障碍物
        3 最上面一行，最下面一行全为1
        4 最右面一列和最左面一列设为1
         */
        int [][]map=new int[8][7];
        for (int i = 0; i <7 ; i++) {
            map[0][i]=1;
            map[7][i]=1;
        }
        for (int i = 0; i <7 ; i++) {
            map[i][0]=1;
            map[i][6]=1;
        }
        map [3][1]=1;
        map [3][2]=1;
        map [2][2]=1;//测试回溯
​
        System.out.println("====当前地图情况====");
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j <map[i].length ; j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }
        //使用findway给老鼠找路
        T1 t1 = new T1();
       t1.findWay(map,1,1);
        System.out.println("\n========策略一找路的情况如下=======");
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j <map[i].length ; j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }
        /*
        t1.findWay2(map,1,1);
​
        System.out.println("\n========策略二找路的情况如下=======");
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j <map[i].length ; j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }*/
    }
}
​
class T1{
    /*
      使用递归回溯的思想解决老鼠出迷宫
    1 findway找迷宫路径
    2 找到返回true 否则返回false
    3 map二维数组 表迷宫
    4 i，j老鼠的位置 初始化（1，1）
    5 递归找路 0可以走 1障碍物 2走通 3走过，但走不通是死路
    6 当map[6][5]=2 就说明找到通路，就可以结束，否则继续找
    7 先确定老鼠找路策略 下>右>上>左
     */
​
​
   public boolean findWay(int [][]map,int i,int j){
      if (map[6][5]==2){//说明已经找到
          return true;
      }else{
          if (map[i][j]==0){//当前位置0，说明可以走
              map[i][j]=2;//假定可以走通
              if (findWay(map,i+1,j)){//先走下
                  return true;
              }else if (findWay(map, i, j+1)){//右
                  return true;
              }else if (findWay(map, i-1, j)){//上
                  return true;
              }else if (findWay(map, i, j-1)){//左
                  return true;
              }else{
                  map[i][j]=3;//走过但不通
                  return false;
              }
          }else {//map[i][j]=1，2，3
              return false;
          }
      }
    }
    /*
    //改变策略 上>右>下>左
    public boolean findWay2(int [][]map,int i,int j){
        if (map[6][5]==2){//说明已经找到
            return true;
        }else{
            if (map[i][j]==0){//当前位置0，说明可以走
                map[i][j]=2;//假定可以走通
                if (findWay2(map,i-1,j)){//先走上
                    return true;
                }else if (findWay2(map, i, j+1)){//右
                    return true;
                }else if (findWay2(map, i+1, j)){//下
                    return true;
                }else if (findWay2(map, i, j-1)){//左
                    return true;
                }else{
                    map[i][j]=3;//走过但不通
                    return false;
                }
            }else {//map[i][j]=1，2，3
                return false;
            }
        }
    }*/
}

汉诺塔

package chapter06.D5递归;
​
public class HanoiTower {
    public static void main(String[] args) {
        Tower tower = new Tower();
        tower.move(3,'A','B','C');
​
    }
}
class Tower{
    public void move(int num,char a,char b,char c){//A塔 B塔 C塔
        if (num==1){
            System.out.println(a+"->"+c);
        }else {
            //如果有多个盘，可以看成两个，最下面和最上面所有盘（num-1）
            move(num-1,a,c,b);//先移动上面所有盘到b，借助c
            System.out.println(a+"->"+c);//把最下面的盘移动到c
            move(num-1,b,a,c);//b塔所有盘移动到c，借助a
        }
    }
}