public void test(){}没然后了...现在有个人在看我的文章,如果没有这个出口,那么递归会引发程序错误,递归就好像这样的
百度百科:程序调用自身的编程技巧称为递归(recursion):递归，就是在运行的过程中调用自己
如下一段代码
//便于理解什么是自己调用自己
public void function(int i){
if (i == 1) {
System.out.println(i);
}else {
function(i - 1); //自己调用自己
System.out.println(i);
}
}
弹栈:就是你的某个方法执行结束了,他就要从方法栈移除
public void test() {
one();
}
private void one() {
two();
}
private void two() {
three();
}
private void three() {
four();
}
private void four() {
System.out.println("4");
}
总结规律:n的阶乘为:n!=n*n(n-1)*n(n-2)..
public int factorial(int n) {
int sum = 0;
//如果成立,代表了n==1了
if (n <= 1) { //出口
return 1;
}
//总结的公式 : n * (n-1)
return n * factorial(n - 1);
}比如输入ABC#输出CBA
public void reverseStr(Scanner scan) {
System.out.println("input :");
String s = scan.nextLine();
if ("#".equals(s)){
return;
}else {
reverseStr(scan);
System.out.println(s);
}
}结果
input :
A
input :
B
input :
C
input :
#
C
B
Apublic void recursionFolder(String initPath) {
//创建目录对象
File file = new File(initPath);
//创建的时候File类并不判断路径是否存在,在这判断
if (file.exists()) {
//列出文件夹下所有文件和文件夹
File[] files = file.listFiles();
for (File f : files) {
if (f.isDirectory()){
//如果是文件夹,输出这个路径
System.out.println(f.getAbsolutePath());
//然后再去递归调用,遍历此文件夹
recursionFolder(f.getAbsolutePath());
}else {
//代表是文件,直接输出
System.out.println(f.getAbsolutePath());
}
}
}
}
我们要求第n月有多少兔子=(n-1)+(n-2)= 前一个月的兔子加上前两个月的兔子总数
private int rabbit(int month) {
if (month <= 2){ //前两个月不能生兔子,所以返回只有一对兔子
return 1;
}else {
//之后就是公式:本月就等于前两个月兔子之和
return rabbit(month - 1) + rabbit(month - 2);
}
}
我们知道了原理,就用代码实现一下
//循环实现
/**
* @param nums 指定有序数据集
* @param n 需要查找的数据
*/
void searchNum(int[] nums,int n){
//由于数据集是有序的,所以如果超过了数据集的最大值和最小值或者长度为0,直接返回
if (nums[0]>n || nums[nums.length -1] < n || nums.length == 0){
System.out.println("需要查找的数据不在指定数据范围内");
return;
}
int start = 0; //起始位置
int end = nums.length - 1; // 结束位置
int mid = end / 2; //中间位置
//折半查找正式开始
while (start <= end){
if (nums[mid] == n){
//如果是等于,那么就输出
System.out.println(mid + " -> " + nums[mid]);
return;
}else if (nums[mid] < n){
//代表中间值小于指定数的情况
start = mid + 1; // 将开始位置的指针赋值为中间索引
mid = (start+end) /2 ; //赋值中间索引为开始和结束索引中间位置
}else if (nums[mid] > n){
//代表中间值大于指定数的情况
end = mid - 1;
mid = (start+end) /2 ;
}
}
System.out.println("需要查找的数据不在指定数据范围内");
}
//递归实现
/**
* @param nums 指定有序数据集
* @param start 开始查找位置
* @param end 查找结束位置
* @param n 需要查找的数据
*/
private void searchNum(int[] nums, int start, int end, int n) {
//由于数据集是有序的,所以如果超过了数据集的最大值和最小值或者长度为0,直接返回
if (nums[start]>n || nums[end] < n || nums.length == 0){
System.out.println("需要查找的数据不在指定数据范围内");
return;
}
int mid = (start + end) / 2;
if (nums[mid] == n ){
System.out.println(mid + " -> " + nums[mid]);
return;
}else if (nums[mid] < n){
searchNum(nums,mid + 1,end,n);
}else if (nums[mid] > n){
searchNum(nums,start,mid - 1,n);
}
}
这是初始的状态,我们要在保证游戏规则的情况下,完成将一个柱子上的块移动到另一个柱子上,并保持块是从小到大的,那么移动的步骤就应该是
n-1:X->Z->Y X->Z n-1:Y->X->Z 
上面这种情况,是不是就是上面中废话的第二步已经完成的状态,那么我们现在可以忽略那个绿色的最大块,忽略后是不是就成了Y上有三个块,然后移动到Z上?那么Y上的三个怎么移动到Z上呢?
n-1-1:Y->Z->X Y->Z n-1-1:X->Y->Z ,如图,所以呢你现在是不是发现,如果忽略掉Z上已经移动上去的两个块,现在就剩下了把两个块移动到Z上的问题~~~!!!
都说到这里了,那么X上的两个怎么移动呢?
X->Y n-1-1-1:X->Y->Z 当块为1 所以总结一下,汉诺塔问题就是借助一个柱子,将N-1个块移动到另一个柱子上,排除出来的那一个最大块,可以暂时忽略,因为现在任何一个块都可以放到最大块上,然后现在就剩一下了一个n-1个块的移动问题,重复再重复,当块为1的时候,就是递归要退出的出口了
/**
* @param n 汉诺塔的层数
* @param x 第一个柱子的名字
* @param y 第二个柱子的名字
* @param z 第三个柱子的名字
*/
private void hanoi(int n, char x, char y, char z) {
if (n == 1){
//如果块只剩下一个了,那么肯定是最小的块还没有移动,所有的块已经按顺序移动到了Z上,
//所以剩下的就是将x 移动到 z
System.out.println(x + "->" + z);
}else {
//一共n个块,首先必须将n-1个块从x借助z移动到y,然后现在的情况就是x剩下最大的块,y有n-1个块
//z为空柱子
hanoi(n - 1, x , z , y);
//代表将x上剩下的最大的块移动到Z
System.out.println(x + "->" + z);
//现在的情况剩下的就是将y上的n-1个块借助x移动到z
hanoi(n - 1, y , x , z);
}
}
比如我们需要模拟三个位置:[3,6],[2,1],[0,4],那么就可以转换成
[3,6] = {arrs[6]=3}
[2,1] = {arrs[1]=2}
[0,4] = {arrs[4]=0}
arr[n]==arr[m],n和m代表两个不同列Math.abs(arr[n]-arr[m] == (Math.abs(n-m))) 好了到这我们把棋盘,皇后位置如何表示,皇后如何判断周围有没有其他人这些问题都讲了一遍,下面就是代码时间
public class MyQueen {
//代表你在第几行上放置了皇后,下标为列,所以就构成了皇后的坐标[下标,值] = [列,行]
private static int[] chess = new int[8];
/**
* 设置皇后的核心方法
* @param col 从第几列开始设置
*/
static void setQueen(int col){
// System.out.println("**********************");
boolean danger; //代表皇后试探的这个位置是否可以落脚
//如果到8了,那么就说嘛八个皇后已经安排好了
if (8 == col){
//打印棋盘
printChess();
//如果只想要一个方案,那么把return注释掉,打开System.exit(0)即可
return;
// System.exit(0);
}
//一列上八个位置,所以循环八次,皇后需要逐个试探
for (int i = 0; i < 8; i++) {
//每次将皇后放入每一列的第一个位置即[col,i]
chess[col] = i;
// System.out.println("皇后试探位置:["+i+","+col+"]");
danger = true;
//chess中保存了已经安排好的皇后,既然遍历到col个了,那么肯定是col-1个皇后已经安排好了
for (int j = 0; j < col; j++) {
//判断同行是否有皇后,此条件文章中已经推导出来
if (chess[j] == chess[col]){
// System.out.println("皇后比较行==位置"+"["+chess[j]+","+j+"] <-> "+"["+chess[col]+","+col+"]");
//有的话就赋值false
danger = false;
//如果此行有别人了,那么就没必须再往下判断了
break;
//判断斜行是否有皇后,此条件文章中已经推导出来
}else if (Math.abs(chess[j] - chess[col]) == (col - j)){
// System.out.println("皇后比较行Math位置"+"["+chess[j]+","+j+"] <-> "+"["+chess[col]+","+col+"]");
//同上
danger = false;
//同上
break;
}
}
if (danger){
//danger赋值false,也隐含着皇后位置不合适,需要重新选择,所以不会进入这
//如果是true,那么就是安排舒服了,然后继续往下一列找寻下一个皇后的位置
setQueen(col +1);
}
//如果到这还都是false即没执行下一列的递归,那么就表示了这一列是没有满足条件的位置的,所以也隐含着此方法出栈,再次执行栈顶方法
//到达栈顶也就是上一列从新开始寻找位置
}
}
//打印棋盘
private static void printChess() {
for (int i = 0; i < 8; i++) {
System.out.print(chess[i]);
}
System.out.println();
}
public static void main(String[] args) {
setQueen(0);
}
}
微信关注我们
转载内容版权归作者及来源网站所有！
低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。
马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。
为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。
Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。
Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。
扫码在手机上查看文章
扫描二维码，手机阅读更方便
有任何问题或合作意向欢迎联系我们
Email: 99873273@qq.com
QQ: 99873273