网站开发 职位晋升路线,深圳网架制作,站长工具2023最新国产,注册建筑劳务公司需要什么条件常见算法
查找算法
1.基本查找
public class BasicSearchDemo01 {public static void main(String[] args) {//基本查找//核心#xff1a;//从0索引开始挨个往后查找//需求#xff1a;定一个方法利用基本查找#xff0c;查询某个元素是否存在//数据如下#xff1a;{131//从0索引开始挨个往后查找//需求定一个方法利用基本查找查询某个元素是否存在//数据如下{1311271478110323779}int[] arr {131,127,147,81,103,23,7,79};int number 82;System.out.println(basicSearch(arr,number));}//参数//一数组//二要查找的元素//返回值//元素是否存在public static boolean basicSearch(int[] arr,int number) {//利用基本查找来查找number在数组中是否存在for (int i 0; i arr.length; i) {if(arr[i] number) {return true;}}return false;}
}public class BasicSearchDemo02 {public static void main(String[] args) {//课堂练习1//需求定义一个方法利用基本查找查询某个元素在数组中的索引//要求不需要考虑数组中元素是否重复int[] arr {131,127,147,81,103,23,7,79};int number 81;System.out.println(basicSearch(arr,number));}private static int basicSearch(int[] arr, int number) {for (int i 0; i arr.length; i) {if(arr[i] number) {return i;}}return -1;}
}public class BasicSearchDemo03 {public static void main(String[] args) {//课堂练习2//需求定义一个方法利用基本查找查询某个元素在数组中的索引//要求需要考虑数组中元素有重复的可能性//{131,127,147,81,103,23,7,7981}//我要查找81想要返回的是所有索引 38int[] arr {131,127,147,81,103,23,7,79,81};int number 81;System.out.println(basicSearch(arr,number));}private static ArrayList basicSearch(int[] arr, int number) {ArrayListInteger index new ArrayList();for (int i 0; i arr.length; i) {if(arr[i] number) {index.add(i);}}return index;}
}2.二分查找/折半查找
前提条件数组中的数据必须是有序的
核心逻辑每次排除一半的查找范围
minleft和maxright表示当前要查找的范围mid是在minleft和maxright中间的如果要查找的元素在mid的左边缩小范围时min不变max等于mid减1 public class BinarySearchDemo01 {public static void main(String[] args) {//二分查找/折半查找//核心//每次排除一半的查找范围//需求定义一个方法利用二分查找查询某个元素在数组中的索引//数据如下{7,23,79,81,103,127,131,147}int[] arr {7,23,79,81,103,127,131,147};System.out.println(binarySearch(arr,3));}public static int binarySearch(int[] arr,int number) {//1.定义两个变量记录要查找的范围int min 0;int max arr.length-1;//2.利用循环不断地去找要查找的数据while(true) {if(min max) {return -1;}//3.找到min和max的中间位置int mid (min max) /2;//4.拿着mid指向的元素跟要查找的元素进行比较//4.3 number跟mid的指向的元素一样if(arr[mid] number) {//4.1 number在mid的左边//min不变,max mid - 1max mid - 1;} else if (arr[mid] number) {//4.2 number在mid的右边//max不变,min mid 1min mid 1;}else {//4.3 number跟mid的指向的元素一样//找到了return mid;}}}
}3.分块查找
分块的原则1前一块中的最大数据小于后一块中所有的数据块内无序块间有序
分块的原则2块数数量一般等于数字的个数开根号。比如16个数字一般分为4块左右
核心思路先确定要查找的元素在哪一块然后在块内挨个查找
public class BlockSearchDemo {public static void main(String[] args) {/*分块查找核心思想块内无序块间有序实现步骤1.创建数组blockArr存放每一个块对象的信息2.先查找blockArr确定要查找的数据属于哪一块3.再单独遍历这一块数据即可*/int[] arr {16,5,9,12,21,18,32,23,37,26,45,34,50,48,61,52,73,66};//创建三个块的对象Block b1 new Block(21, 0, 5);Block b2 new Block(45, 6, 11);Block b3 new Block(73, 12, 17);//定义数组用来管理三个块的对象索引表Block[] blockArr {b1,b2,b3};//定义一个变量用来记录要查找的元素int number 32;//调用方法传递索引表数组要查找的元素int index getIndex(blockArr,arr,number);//打印一下System.out.println(index);}//利用分块查找的原理查询number的索引private static int getIndex(Block[] blockArr, int[] arr, int number) {//1.确定number在哪一块中int indexBlock findIndexBlock(blockArr, number);if(indexBlock -1) {//表示number不在数组当中return -1;}//2.获取这一块的起始索引和终止索引int startIndex blockArr[indexBlock].getStartIndex();int endIndex blockArr[indexBlock].getEndIndex();//3.遍历for (int i startIndex; i endIndex; i) {if(arr[i] number) {return i;}}return -1;}//定义一个方法用来确定number在哪一块当中public static int findIndexBlock(Block[] blockArr,int number) {//从0索引开始遍历blockArr,如果number小于max那么就表示number是在这一块当中的for (int i 0; i blockArr.length; i) {if(number blockArr[i].getMax()) {return i;}}return -1;}
}class Block {private int max;//最大值private int startIndex;//起始索引private int endIndex;//终止索引public Block() {}public Block(int max, int startIndex, int endIndex) {this.max max;this.startIndex startIndex;this.endIndex endIndex;}/*** 获取* return max*/public int getMax() {return max;}/*** 设置* param max*/public void setMax(int max) {this.max max;}/*** 获取* return startIndex*/public int getStartIndex() {return startIndex;}/*** 设置* param startIndex*/public void setStartIndex(int startIndex) {this.startIndex startIndex;}/*** 获取* return endIndex*/public int getEndIndex() {return endIndex;}/*** 设置* param endIndex*/public void setEndIndex(int endIndex) {this.endIndex endIndex;}public String toString() {return Block{max max , startIndex startIndex , endIndex endIndex };}
}//分块查找扩展做到分组后每组数据无交集
public class BlockSearchDemo01 {public static void main(String[] args) {//做到分组后每组数据无交集//{27,22,30,40,36,13,19,16,20,7,10,43,50,48}int[] arr {27,22,30,40,36,//22~3613,19,16,20,//13~207,10,//7~1043,50,48};//43~50Block01 b1 new Block01(22, 36, 0, 4);Block01 b2 new Block01(13, 20, 5, 8);Block01 b3 new Block01(7, 10, 9, 10);Block01 b4 new Block01(43, 50, 11, 13);Block01[] blockArr {b1,b2,b3,b4};int number 1;int index getIndex(blockArr,arr,number);System.out.println(index);}private static int getIndex(Block01[] blockArr, int[] arr, int number) {int indexBlock findIndexBlock(blockArr, number);if(indexBlock -1) {return -1;}int startIndex blockArr[indexBlock].getStartIndex();int endIndex blockArr[indexBlock].getEndIndex();for (int i startIndex; i endIndex; i) {if(arr[i] number) {return i;}}return -1;}public static int findIndexBlock(Block01[] blockArr,int number) {for (int i 0; i blockArr.length; i) {if(number blockArr[i].getMin() number blockArr[i].getMax()) {return i;}}return -1;}
}class Block01{private int min;private int max;private int startIndex;private int endIndex;public Block01() {}public Block01(int min, int max, int startIndex, int endIndex) {this.min min;this.max max;this.startIndex startIndex;this.endIndex endIndex;}/*** 获取* return min*/public int getMin() {return min;}/*** 设置* param min*/public void setMin(int min) {this.min min;}/*** 获取* return max*/public int getMax() {return max;}/*** 设置* param max*/public void setMax(int max) {this.max max;}/*** 获取* return startIndex*/public int getStartIndex() {return startIndex;}/*** 设置* param startIndex*/public void setStartIndex(int startIndex) {this.startIndex startIndex;}/*** 获取* return endIndex*/public int getEndIndex() {return endIndex;}/*** 设置* param endIndex*/public void setEndIndex(int endIndex) {this.endIndex endIndex;}public String toString() {return Block01{min min , max max , startIndex startIndex , endIndex endIndex };}
}排序算法
1.冒泡排序
相邻的元素两两比较大的放右边小的放左边每一轮循环结束后都确定了一个元素的位置故下一轮排序范围限定0~(length-1-i)
2.选择排序
从0索引开始跟后面的元素一一比较每一轮排序结束都确定了一个元素的位置故下一轮排序范围
for(int i0;i length-1;i) {for(int j i1;j length; j) {if(arr[j] arr[i]) {int temp arr[j];arr[j] arr[i];arr[i] temp;}}//第一轮排序结束最小的元素索引为0
}3.插入排序
将0索引的元素到N索引的元素看做是有序的把N1索引的元素到最后一个当成是无序的。遍历无序的数据将遍历到的元素插入有序序列中适当的位置如遇到相同数据插在后面。N的范围0~最大索引
public class SelectionDemo {public static void main(String[] args) {int[] arr {3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};//1.找到无序的那一组数据是从哪个索引开始的int startIndex -1;for (int i 0; i arr.length-1; i) {if(arr[i1] arr[i]){startIndex i1;break;}}//2.从startIndex开始遍历无序数组中的元素for (int i startIndex; i arr.length; i) {//问题如何把遍历到的数据插入到前面有序的这一组当中//记录当前要插入数据的索引int j i;while(j 0 arr[j] arr[j-1]) {//交换位置int temp arr[j];arr[j] arr[j-1];arr[j-1] temp;j--;}}for (int i 0; i arr.length; i) {System.out.print(arr[i] );}}
}4.快速排序 递归算法递归指的是方法中调用方法本身的现象。 递归的注意点递归一定要有出口否则就会出现内存溢出。 递归算法的作用把一个复杂的问题层层转化为一个与原问题相似的规模较小的的问题来求解。递归策略只需要少量的程序就可描述出解题过程所需要的多少次重复计算。 书写递归的两个核心 找出口什么时候不再调用方法找规则如何把大问题变成规模较小的问题 练习1——递归求和 需求求1~100之间的和 public class RecursionDemo01 {public static void main(String[] args) {//大问题拆成小问题//1~100之间的和 100 1~99之间的和//1~99之间的和 99 1~98之间的和//...//1~1之间的和 1递归的出口System.out.println(getSum(100));}public static int getSum(int number) {if(number 1) {return 1;}//如果number不是1则return number getSum(number-1);}
}练习2——递归求阶乘 需求用递归求5的阶乘并把结果在控制台输出 public class RecursionDemo02 {public static void main(String[] args) {//需求用递归求5的阶乘并把结果在控制台输出System.out.println(getfactorialRecursion(5));}public static int getfactorialRecursion(int number) {if(number 1) {return 1;}return number * getfactorialRecursion(number-1);}
}快速排序 第一轮把0索引的数字作为基准数确定基准数在数组中正确的位置。比基准数小的全部在左边比基准数大的全部在右边。 public class QuickSortDemo {public static void main(String[] args) {/*快速排序第一轮把0索引的数字作为基准数确定基准数在数组中正确的位置。比基准数小的全部在左边比基准数大的全部在右边。后面以此类推*///int[] arr {6,1,2,7,9,3,4,5,10,8};int[] arr new int[1000000];Random random new Random();for (int i 0; i arr.length; i) {arr[i] random.nextInt();}long startTime System.currentTimeMillis();quickSort(arr,0,arr.length-1);long endTime System.currentTimeMillis();System.out.println(endTime-startTime);//课堂练习//可以利用相同的方法去测试一下选择排序冒泡排序以及插入排序运行的效率//得到一个结论快速排序真的非常快// for (int i 0; i arr.length; i) {
// System.out.print(arr[i] );
// }}/*** 参数一我们要排序的数组* 参数二要排序数组的起始索引* 参数三要排序数组的结束索引*/public static void quickSort(int[] arr,int i,int j) {//定义两个变量记录要查找的范围int start i;int end j;if(end start) {//递归的出口return;}//记录基准数int baseNumber arr[i];//利用循环找到要交换的数字while(start ! end) {//利用end从后面往前开始找找比基准数小的数字while(true) {if(end start || arr[end] baseNumber) {break;}end--;}//利用start从前面往后开始找找比基准数大的数字while(true) {if(end start || arr[start] baseNumber) {break;}start;}//把end和start指向的元素进行交换int temp arr[end];arr[end] arr[start];arr[start] temp;}//当end和start指向了同一个元素的时候那么上面的循环就会结束//表示已经找到了基准数在数组中应存入的位置//基准数归为//就是拿着这个范围中的第一个数字跟start指向的元素进行交换int temp arr[i];arr[i] arr[start];arr[start] temp;//确定6左边的范围重复刚刚做的事情quickSort(arr,i,start-1);//确定6右边的范围重复刚刚做的事情quickSort(arr,start1,j);}
}Arrays
操作数组的工具类
方法名说明public static String toString(数组)把数组拼接成一个字符串public static int binarySearch(数组查找的元素)二分查找法查找元素public static int[] copyOf(原数组新数组长度)拷贝数组public static int[] copyOfRange(原数组起始索引结束索引)拷贝数组指定范围public static void fill(数组元素)填充数组public static void sort(数组)按照默认方式进行数组排序public static void sort(数组排序规则)按照指定的规则排序
public class MyArraysDemo01 {public static void main(String[] args) {/*public static String toString(数组) 把数组拼接成一个字符串public static int binarySearch(数组查找的元素) 二分查找法查找元素public static int[] copyOf(原数组新数组长度) 拷贝数组public static int[] copyOfRange(原数组起始索引结束索引) 拷贝数组指定范围public static void fill(数组元素) 填充数组public static void sort(数组) 按照默认方式进行数组排序public static void sort(数组排序规则) 按照指定的规则排序*///toString:将数组变成字符串System.out.println(-----------toString----------);int[] arr {1,2,3,4,5,6,7,8,9,10};System.out.println(Arrays.toString(arr));//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]//binarySearch:二分查找法查找元素System.out.println(-----------binarySearch----------);System.out.println(Arrays.binarySearch(arr,10));//9System.out.println(Arrays.binarySearch(arr,2));//1System.out.println(Arrays.binarySearch(arr,20));//-11//copyOf:拷贝数组System.out.println(-----------copyOf----------);int[] newArr1 Arrays.copyOf(arr,10);System.out.println(Arrays.toString(newArr1));//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]//copyOfRange:拷贝数组指定范围// 细节包头不包围包左不包右System.out.println(-----------copyOfRange----------);int[] newArr2 Arrays.copyOfRange(arr,0,9);System.out.println(Arrays.toString(newArr2));//[1, 2, 3, 4, 5, 6, 7, 8, 9]//fill:填充数组System.out.println(-----------fill----------);Arrays.fill(arr,100);System.out.println(Arrays.toString(arr));//[100, 100, 100, 100, 100, 100, 100, 100, 100, 100]//sort:排序默认情况下给基本数据类型进行升序排列底层使用的是快速排序System.out.println(-----------sort----------);int[] arr2 {10,2,3,5,6,1,7,8,4,9};Arrays.sort(arr2);System.out.println(Arrays.toString(arr2));//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]}
}public class MyArraysDemo02 {public static void main(String[] args) {/*public static void sort(数组排序规则) 按照指定的规则排序参数一要排序的数组参数二排序的规则细节只能给引用数据类型的数组进行排序如果数组是基本数据类型的需要变成其对应的包装类*/Integer[] arr {2,3,1,5,6,7,8,4,9};//第二个参数是一个接口所以我们在调用方法的时候需要传递这个接口的实现类对象作为排序的规则//但是这个实现类我只要使用一次所以就没有必要去单独的写一个类直接采取匿名内部类的方式就可以了//底层原理//利用插入排序二分查找的方式进行排序的//默认吧0索引的数据当做是有序的序列1索引到最后认为是无序的序列//遍历无序序列得到里面的每一个元素假设当前遍历得到的元素是A元素//把A往有序序列中进行插入在插入的时候是利用二分查找确定A元素的插入点//拿着A元素跟插入点的元素进行比较比较的规则就是compare方法的方法体//如果方法的返回值是负数拿着A继续跟前面的数据进行比较//如果方法的返回值是正数拿着A继续跟后面的数据进行比较//如果方法的返回值是0也拿着A跟后面的数据进行比较//直到能确定A的最终位置为止//compare方法的形式参数//参数一 o1表示在无序序列中遍历得到的每一个元素//参数二 o2有序序列中的元素//返回值//负数表示当前要插入的元素是小的放在前面//正数表示当前要插入的元素是大的放在后面//0表示当前要插入的元素跟现在元素比是一样的也会放在后面//简单理解//o1-o2:升序//o2-o1:降序Arrays.sort(arr, new ComparatorInteger() {Overridepublic int compare(Integer o1, Integer o2) {System.out.println(----------------);System.out.println(o1 o1);System.out.println(o2 o2);return o1 - o2;}});System.out.println(Arrays.toString(arr));}
}Lambda表达式
1.函数式编程
函数式编程Functional programming是一种思想特点。
函数式编程思想忽略面向对象的复杂语法强调做什么而不是谁去做。
而所要学习的Lambda表达式就是函数式思想的体现。
2.Lambda表达式的标准格式
Lambda表达式是JDK8开始后的一种新语法形式。
() - {//
}
//() 对应着方法的形参
//- 固定格式
//{} 对应着方法的方法体注意点
Lambda表达式可以用来简化匿名内部类的书写Lambda表达式只能简化函数式接口的匿名内部类的写法函数式接口有且仅有一个抽象方法的接口叫做函数式接口接口上方可以加FunctionalInterface注解
public class LambdaDemo01 {public static void main(String[] args) {/*注意点Lambda表达式可以用来简化匿名内部类的书写Lambda表达式只能简化函数式接口的匿名内部类的写法函数式接口有且仅有一个抽象方法的接口叫做函数式接口接口上方可以加FunctionalInterface注解*///1.利用匿名内部类的形式去调用下面的方法//调用一个方法的时候如果方法的形参是一个接口那么我们要传递这个接口的实现类对象//如果实现类对象只要用到一次就可以用匿名内部类的形式进行书写// method(new Swim() {
// Override
// public void swimming() {
// System.out.println(正在游泳~~);
// }
// });//2.利用lambda表达式进行改写method(() - {System.out.println(正在游泳~~);});}public static void method(Swim s) {s.swimming();}
}FunctionalInterface
interface Swim{public abstract void swimming();
}3.Lambda表达式的省略写法
省略核心可推导可省略
public class LambdaDemo02 {public static void main(String[] args) {/*lambda的省略规则1.参数类型可以省略不写2.如果只有一个参数参数类型可以省略同时()也可以省略3.如果Lambda表达式的方法体只有一行大括号分号return可以省略不写需要同时省略*/Integer[] arr {2,3,1,5,6,7,8,4,9};// Arrays.sort(arr, new ComparatorInteger() {
// Override
// public int compare(Integer o1, Integer o2) {
// return o1 - o2;
// }
// });
//
// //lambda完整格式
// Arrays.sort(arr, (Integer o1, Integer o2) - {
// return o1 - o2;
// }
// );//lambda省略写法Arrays.sort(arr, (o1, o2) - o1 - o2);System.out.println(Arrays.toString(arr));}
}4.练习
Lambda表达式简化Comparator接口的匿名形式
定义数组并存储一些字符串利用Arrays中的sort方法进行排序
要求按照字符串的长度进行排序短的在前面长的在后面。
暂时不比较字符串里面的内容
public class LambdaDemo04 {public static void main(String[] args) {/*定义数组并存储一些字符串利用Arrays中的sort方法进行排序要求按照字符串的长度进行排序短的在前面长的在后面。暂时不比较字符串里面的内容*/String[] arr {a,aaaa,aaa,aa};//如果以后要把数组中的数据按照指定的方法排序就需要用到sort方法// 而且要指定排序的规则//写法1匿名内部类
// Arrays.sort(arr, new ComparatorString() {
// Override
// public int compare(String o1, String o2) {
// //按照字符串的长度进行排序
//
// return o1.length() - o2.length();
// }
// });//写法2Lambda表达式完整格式/*Arrays.sort(arr, (String o1, String o2) - {//按照字符串的长度进行排序return o1.length() - o2.length();});*///写法3Lambda表达式简写格式Arrays.sort(arr, (o1, o2) - o1.length() - o2.length());//[a, aa, aaa, aaaa]//打印数组System.out.println(Arrays.toString(arr));}
}综合练习 按照要求进行排序 定义数组并存储一些男朋友对象利用Arrays中的sort方法进行排序 要求1属性有姓名、年龄、身高。 要求2按照年龄的大小进行排序年龄一样按照身高排序身高一样按照姓名的字母进行排序。姓名中不要有中文或特殊字符会涉及到后面的知识 public class Test01 {public static void main(String[] args) {/*定义数组并存储一些男朋友对象利用Arrays中的sort方法进行排序要求1属性有姓名、年龄、身高。要求2按照年龄的大小进行排序年龄一样按照身高排序身高一样按照姓名的字母进行排序。姓名中不要有中文或特殊字符会涉及到后面的知识*///1.创建三个男朋友的对象BoyFriend bf1 new BoyFriend(lan, 18, 1.85);BoyFriend bf2 new BoyFriend(yu, 19, 1.80);BoyFriend bf3 new BoyFriend(ce, 19, 1.87);//2.定义数组存储男朋友的信息BoyFriend[] arr {bf1,bf2,bf3};//3.利用Arrays中的sort方法进行排序//匿名内部类/*Arrays.sort(arr, new ComparatorBoyFriend() {Overridepublic int compare(BoyFriend o1, BoyFriend 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 Test02 {public static void main(String[] args) {/*有一个很有名的数学逻辑叫做不死神兔问题有一对兔子从出生后第三个月起每个月都生一对兔子小兔子长到第三个月后每个月又生一对兔子假如兔子都不死问第十二个月的兔子对数为多少1月12月13月24月35月56月8特点从第三个数据开始是前两个数据的和斐波那契数列*///求解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];}//4.获取最大索引上的数据即可System.out.println(arr[arr.length-1]);//144*///求解2//递归的方式去完成//1.递归的出口//2.找到递归的规律//Fn(12) Fn(11) Fn(10)//Fn(11) Fn(10) Fn(9)//...//Fn(3) Fn(1) Fn(2)//Fn(2) 1//Fn(1) 1System.out.println(getSum(12));//144}public static int getSum(int month) {if(month 1 || month 2) {return 1;}else {return getSum(month-1) getSum(month-2);}}
}猴子吃桃子 有一堆桃子猴子第一天吃了其中的一半并多吃了一个以后每天猴子都吃当前剩下来的一半然后再多吃一个第10天的时候还没吃发现只剩下一个桃子了请问最初总共多少个桃子 public class Test03 {public static void main(String[] args) {/*有一堆桃子猴子第一天吃了其中的一半并多吃了一个以后每天猴子都吃当前剩下来的一半然后再多吃一个第10天的时候还没吃发现只剩下一个桃子了请问最初总共多少个桃子day10: 1day9: (day10 1) * 2 4day8: (day9 1) * 2 10每一天的桃子数量都是后一天数量加1乘以2day7: (day8 1) * 2 22*/System.out.println(getCount(1));//1534}public static int getCount(int day) {if(day 0 || day 11) {System.out.println(当前时间错误);return -1;}//递归的出口if(day 10) {return 1;}//书写规律//每一天的桃子数量都是后一天数量加1乘以2return (getCount(day1) 1) * 2;}
}爬楼梯 可爱的小明特别喜欢爬楼梯他有的时候一次爬一个台阶有的时候一次爬两个台阶。如果这个楼梯有20个台阶小明一共有多少种爬法呢 运算结果 1层台阶 1种爬法 2层台阶 2种爬法 7层台阶 21种爬法 public class Test04 {public static void main(String[] args) {/*可爱的小明特别喜欢爬楼梯他有的时候一次爬一个台阶有的时候一次爬两个台阶。如果这个楼梯有20个台阶小明一共有多少种爬法呢运算结果1层台阶 1种爬法2层台阶 2种爬法7层台阶 21种爬法*/System.out.println(getCount(20));//10946}public static int getCount(int n) {if(n 1) {return 1;}if(n 2) {return 2;}return getCount(n-1) getCount(n-2);}
}可爱的小明特别喜欢爬楼梯他有的时候一次爬一个台阶有的时候一次爬两个台阶,有的时候一次爬三个台阶。如果这个楼梯有20个台阶小明一共有多少种爬法呢 运算结果 1层台阶 1种爬法 2层台阶 2种爬法 3层台阶 4种爬法 4层台阶 7种爬法 public class Test05 {public static void main(String[] args) {/*可爱的小明特别喜欢爬楼梯他有的时候一次爬一个台阶有的时候一次爬两个台阶,有的时候一次爬三个台阶如果这个楼梯有20个台阶小明一共有多少种爬法呢1层 1种2层 2种3层 4种4层 7种*/System.out.println(getCount(20));//121415}public static int getCount(int n) {if(n 1) {return 1;} else if (n 2) {return 2;} else if (n 3) {return 4;}else {return getCount(n-1) getCount(n-2) getCount(n-3);}}
}说明
以上笔记学习是学习b站黑马程序员时记下的笔记仅限于帮助理解学习不做任何其他商业用途。
黑马程序员
