精华内容
下载资源
问答
  • 主要介绍了java递归法求字符串逆序,涉及java递归调用的相关操作技巧,需要的朋友可以参考下
  • Java递归法读取文件目录 20 任意给一个目录(至少有三层子目录),通过递归方法,将目录及所有子目录下的文件都列出来 匿名 | 浏览 3344 次 我有更好的答案 推荐于2016-04-22 20:54:16 ...

    Java递归法读取文件目录 20

    任意给一个目录(至少有三层子目录),通过递归方法,将目录及所有子目录下的文件都列出来
    匿名 | 浏览 3344 次
    我有更好的答案
    推荐于2016-04-22 20:54:16 最佳答案
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    import java.io.File;
     
    public class $ {
     
        public static void main(String[] args) {
     
            String path = "D:/";
     
            test(path);
        }
     
        private static void test(String path) {
            File f = new File(path);
     
            File[] fs = f.listFiles();
     
            if (fs == null) {
                return;
            }
     
            for (File file : fs) {
                if (file.isFile()) {
                    System.out.println(file.getPath());
                else {
                    test(file.getPath());
                }
            }
        }
    }
    展开全文
  • 详解Java递归法实现反转链表(LeetCode 206. 反转链表) /* * 示例: * 输入: 1->2->3->4->5->NULL * 输出: 5->4->3->2->1->NULL * * 链接:...

    详解Java递归法实现反转链表(LeetCode 206. 反转链表)

    /*
     * 示例:
     * 输入: 1->2->3->4->5->NULL
     * 输出: 5->4->3->2->1->NULL
     * 
     * 链接:https://leetcode-cn.com/problems/reverse-linked-list/
     */
    
    // ListNode的数据结构
    class ListNode {
        int val;
        ListNode next;
        ListNode() {}
        ListNode(int val) {this.val = val;}
        ListNode(int val, ListNode next) {
            this.val = val;
            this.next = next;
        }
    }
    
    public class Solution {
    
        // 单链表反转
        public ListNode reverseList(ListNode head) {
            // 递归:
            // node1 -> node2 -> node3 -> node4 -> node5  // 先递归到最内层,并return head, return 后 head 位于 node4
            // node1 -> node2 -> node3 -> node4 <- node5  // node4.next.next = node4, 即node5.next = node4; node4.next = null
            // node1 -> node2 -> node3 <- node4 <- node5  // node3.next.next = node3, 即node4.next = node3; node3.next = null
            // node1 -> node2 <- node3 <- node4 <- node5  // node2.next.next = node2, 即node3.next = node2; node2.next = null
            // node1 <- node2 <- node3 <- node4 <- node5  // node1.next.next = node1, 即node2.next = node1; node1.next = null
            // 此时,node1 成为尾结点, 递归结束
    
            if (head == null || head.next == null) { // 为什么需要这两个判断呢?
                return head;
            }
            ListNode headNode = reverseList(head.next); // 递归到最内层,由内往外,由后往前 计算
            head.next.next = head;  // 因为这里需要 head.next == null 的判断
            head.next = null;       // 因为这里需要 head == null 的判断
            return headNode;
        }
    }
    
    展开全文
  • H(n) = 2*H(n-1)+1 (n>1) 那么我们很快就能得到H(n)的一般式: H(n) = 2^n - 1 (n>0) 2 解决方案 2.1 递归法 1 importjava.util.Scanner;2 3 public classHanoi {4 5 //使用递归法求解含有n个不同大小盘子的汉诺塔...

    1 问题描述

    Simulate the movement of the Towers of Hanoi Puzzle; Bonus is possible for using animation.

    e.g. if n = 2 ; A→B ; A→C ; B→C;

    if n = 3; A→C ; A→B ; C→B ; A→C ; B→A ; B→C ; A→C;

    翻译:模拟汉诺塔问题的移动规则;获得奖励的移动方法还是有可能的。

    相关经典题目延伸:

    引用自百度百科:

    有三根相邻的柱子,标号为A,B,C,A柱子上从下到上按金字塔状叠放着n个不同大小的圆盘,要把所有盘子一个一个移动到柱子C上,并且每次移动同一根柱子上都不能出现大盘子在小盘子上方,请问至少需要多少次移动,设移动次数为H(n)。

    首先我们肯定是把上面n-1个盘子移动到柱子B上,然后把最大的一块放在C上,最后把B上的所有盘子移动到C上,由此我们得出表达式:

    H⑴ = 1          A—>C

    H(2) = 3         A—>B;A—>C;B—>C

    H(3) = 7         ...

    H(4) = 15

    ... ...

    H(n) = 2*H(n-1)+1 (n>1)

    那么我们很快就能得到H(n)的一般式:

    H(n) = 2^n - 1 (n>0)

    2 解决方案

    2.1 递归法

    1 importjava.util.Scanner;2

    3 public classHanoi {4

    5 //使用递归法求解含有n个不同大小盘子的汉诺塔移动路径,参数n为盘子数,把A塔上盘子全部移动到C塔上,B为过渡塔

    6 public static void recursionHanoi(int n,char A,char B,charC){7 if(n == 1){8 System.out.print(A+"——>"+C+"\n");9 }10 else{11 recursionHanoi(n-1,A,C,B); //使用递归先把A塔最上面的n-1个盘子移动到B塔上,C为过渡塔

    12 System.out.print(A+"——>"+C+"\n"); //把A塔中底下最大的圆盘,移动到C塔上

    13 recursionHanoi(n-1,B,A,C); //使用递归把B塔上n-1个盘子移动到C塔上,A为过渡塔

    14 }15 }16

    17 public static voidmain(String[] args){18 System.out.println("请输入盘子总数n:");19 Scanner in = newScanner(System.in);20 int n =in.nextInt();21 recursionHanoi(n,'A','B','C');22 }23 }

    运行结果:

    请输入盘子总数n:2A——>B

    A——>C

    B——>C

    请输入盘子总数n:3A——>C

    A——>B

    C——>B

    A——>C

    B——>A

    B——>C

    A——>C

    2.2 非递归法

    要使用非递归方法,首先要解决的核心问题就是找到汉诺塔的移动规律。现在问题是把n个盘子从A塔全部移动到C塔,那么先看看n = 2,3,4时,其具体盘子的移动路径结果(PS:移动路径前标号是指A塔上原有的第几个盘子,如(1)代表A塔上原有最上面的那个盘子,依次类推...):

    n = 2:

    (1)A—>B

    (2)A—>C

    (1)B—>C

    n= 3:

    (1)A——>C

    (2)A——>B

    (1)C——>B

    (3)A——>C

    (1)B——>A

    (2)B——>C

    (1)A——>C

    n= 4:

    (1)A——>B

    (2)A——>C

    (1)B——>C

    (3)A——>B

    (1)C——>A

    (2)C——>B

    (1)A——>B

    (4)A——>C

    (1)B——>C

    (2)B——>A

    (1)C——>A

    (3)B——>C

    (1)A——>B

    (2)A——>C

    (1)B——>C

    从上我们可以发现,n为偶数2,4时路径前标号为(1)的盘子移动路径依次为A——>B——>C,A——>B——>C——>A——>B——>C。n为偶数2,4时路径前标号为(2)的盘子移动路径依次为A—>C,A—>C——>B——>A—>C。而且发现n = 4其标号为(1)和标号为(3)的移动路径一模一样。n为奇数3时路径前标号为(1)和(2)的盘子移动路径依次为A——>C——>B——>A——>C,A——>B——>C。

    看到这里,我们可以大胆猜测盘子的具体移动路径与盘子的总个数的奇偶性以及盘子标号的奇偶性有关,而且移动的路径是固定又循环的。

    那么现在设定一个二维数组用来存放盘子下次移动的塔:

    char next = new char[2][3];

    二维数组中行char[0]代表数组下标为偶数的盘子下次要移动的塔

    二维数组中行char[1]代表数组下标为奇数的盘子下次要移动的塔

    二维数组重列char[0][0]代表盘子现在在A塔准备进行下次移动

    二维数组重列char[0][1]代表盘子现在在B塔准备进行下次移动

    二维数组重列char[0][2]代表盘子现在在C塔准备进行下次移动

    那么下面我们就来根据盘子现在所在塔,设定其下次移动的目的塔(PS:设共有n的盘子):

    if(n为偶数)

    {//数组下标为偶数的盘子移动目的塔,注意上面示例的标号为(1),其数组下标为0

    next[0][0] = ‘B’; //看n = 4的移动路径中(1)A——>B

    next[0][1] = ‘C’; //看n = 4的移动路径中(1)B——>C

    next[0][2] = ‘A’; //看n = 4的移动路径中(1)C——>A//数组下标为奇数的盘子移动目的塔

    next[1][0] = ‘C’; //看n = 4的移动路径中(2)A——>C

    next[1][1] = ‘A’; //看n = 4的移动路径中(2)B——>A

    next[1][0] = ‘B’; //看n = 4的移动路径中(2)C——>B

    }

    If(n为奇数)

    {//数组下标为偶数的盘子移动目的塔,注意上面示例的标号为(1),其数组下标为0

    Next[0][0] = ‘C’; //看n = 3的移动路径中(1)A——>C

    Next[0][1] = ‘A’; //看n = 3的移动路径中(1)B——>A

    Next[0][2] = ‘B’; //看n = 3的移动路径中(1)C——>B//数组下标为奇数的盘子移动目的塔

    Next[1][0] = ‘B’; //看n = 3的移动路径中(2)A——>B

    Next[1][1] = ‘C’; //看n = 3的移动路径中(2)B——>C

    Next[1][2] = ‘A’; //此处根据观察规律假设的

    }

    到这里,距离使用非递归法解决汉诺塔问题已经有头绪了,此处还有注意一点就是H(n) = 2^n - 1 (n>0),即移动n个盘子需要总次数为2^n - 1 ,即使用非递归法是需要进行循环2^n - 1 次。

    1 packagecom.liuzhen.ex2;2

    3 importjava.util.Scanner;4

    5 public classHanoi {6

    7 //使用递归法求解含有n个不同大小盘子的汉诺塔移动路径,参数n为盘子数,把A塔上盘子全部移动到C塔上,B为过渡塔

    8 public static void recursionHanoi(int n,char A,char B,charC){9 if(n == 1){10 System.out.print(A+"——>"+C+"\n");11 }12 else{13 recursionHanoi(n-1,A,C,B); //使用递归先把A塔最上面的n-1个盘子移动到B塔上,C为过渡塔

    14 System.out.print(A+"——>"+C+"\n"); //把A塔中底下最大的圆盘,移动到C塔上

    15 recursionHanoi(n-1,B,A,C); //使用递归把B塔上n-1个盘子移动到C塔上,A为过渡塔

    16 }17 }18

    19 public static void noRecursionHanoi(intn){20 if(n<=0){21 throw new IllegalArgumentException("n must be >=1");22 }23 char[] hanoiPlate = new char[n]; //记录n个盘子所在的汉诺塔(hanoiPlate[1]='A'意味着第二个盘子现在在A上)

    24 char[][] next = new char [2][3]; //盘子下次会移动到的盘子的可能性分类

    25 int[] index = new int[n];26

    27 //根据奇偶性将盘子分为两类

    28 for(int i=0;i

    35 //一开始所有盘子都在A上

    36 for(int i=0;i

    40 //n的奇偶性对移动方式的影响

    41 if(n%2==0){42 //数组下标为偶数的盘子移动目的塔,注意上面示例的标号为(1),其数组下标为0

    43 next[0][0]='B';44 next[0][1]='C';45 next[0][2]='A';46 //数组下标为奇数的盘子移动目的塔

    47 next[1][0]='C';48 next[1][1]='A';49 next[1][2]='B';50 }51 else

    52 {53 //数组下标为偶数的盘子移动目的塔,注意上面示例的标号为(1),其数组下标为0

    54 next[0][0]='C';55 next[0][1]='A';56 next[0][2]='B';57 //数组下标为奇数的盘子移动目的塔

    58 next[1][0]='B';59 next[1][1]='C';60 next[1][2]='A';61 }62

    63 //开始移动

    64 for(int i=1;i

    65 int m=0; //m代表第m块盘子hanoiPlate[m]66

    67 //根据步骤数i来判断移动哪块盘子以及如何移动

    68 for(int j=i;j>0;j=j/2){69 if(j%2!=0){ //此步骤光看代码代码有点抽象,建议手动写一下n = 2时的具体移动路径的j、m值变化

    70 System.out.println("("+(m+1)+")"+hanoiPlate[m]+"->"+next[index[m]][hanoiPlate[m]-'A']);71 hanoiPlate[m]=next[index[m]][hanoiPlate[m]-'A'];72 break; //移动盘子后则退出这层循环

    73 }74 m++;75 }76 }77 }78

    79 public static voidmain(String[] args){80 System.out.println("请输入盘子总数n:");81 Scanner in = newScanner(System.in);82 int n =in.nextInt();83 recursionHanoi(n,'A','B','C');84 System.out.println("非递归法结果:");85 noRecursionHanoi(n);86 System.out.println();87 }88 }

    运行结果:

    请输入盘子总数n:2A——>B

    A——>C

    B——>C

    非递归法结果:

    (1)A->B

    (2)A->C

    (1)B->C

    请输入盘子总数n:3A——>C

    A——>B

    C——>B

    A——>C

    B——>A

    B——>C

    A——>C

    非递归法结果:

    (1)A->C

    (2)A->B

    (1)C->B

    (3)A->C

    (1)B->A

    (2)B->C

    (1)A->C

    参考资料:

    展开全文
  • 2.1 递归法 2.2 非递归法 1 问题描述 Simulate the movement of the Towers of Hanoi Puzzle; Bonus is possible for using animation. e.g. if n = 2 ; A→B ; A→C ; B→C; if...

    目录

    1 问题描述

    2 解决方案 

    2.1 递归法

    2.2 非递归法

     

     


    1 问题描述

    Simulate the movement of the Towers of Hanoi Puzzle; Bonus is possible for using animation.

    e.g. if n = 2 ; AB ; AC ; BC;

          if n = 3; AC ; AB ; CB ; AC ; BA ; BC ; AC;

    翻译:模拟汉诺塔问题的移动规则;获得奖励的移动方法还是有可能的。

     

    相关经典题目延伸:

    引用自百度百科:

    有三根相邻的柱子,标号为A,B,CA柱子上从下到上按金字塔状叠放着n个不同大小的圆盘,要把所有盘子一个一个移动到柱子C上,并且每次移动同一根柱子上都不能出现大盘子在小盘子上方,请问至少需要多少次移动,设移动次数为H(n)。

     

    首先我们肯定是把上面n-1个盘子移动到柱子B上,然后把最大的一块放在C上,最后把B上的所有盘子移动到C上,由此我们得出表达式:

    H⑴ = 1          A>C

    H(2) = 3         A>BA>CB>C

    H(3) = 7         ...

    H(4) = 15       

    ... ...

    H(n) = 2*H(n-1+1 (n>1

    那么我们很快就能得到H(n)的一般式:

    H(n) = 2^n - 1 (n>0)

     

     


    2 解决方案

    2.1 递归法

     1 import java.util.Scanner;
     2 
     3 public class Hanoi {
     4     
     5     //使用递归法求解含有n个不同大小盘子的汉诺塔移动路径,参数n为盘子数,把A塔上盘子全部移动到C塔上,B为过渡塔
     6     public static void recursionHanoi(int n,char A,char B,char C){
     7         if(n == 1){
     8             System.out.print(A+"——>"+C+"\n");    
     9         }
    10         else{
    11             recursionHanoi(n-1,A,C,B);         //使用递归先把A塔最上面的n-1个盘子移动到B塔上,C为过渡塔
    12             System.out.print(A+"——>"+C+"\n");       //把A塔中底下最大的圆盘,移动到C塔上
    13             recursionHanoi(n-1,B,A,C);         //使用递归把B塔上n-1个盘子移动到C塔上,A为过渡塔
    14         }
    15     }
    16 
    17    public static void main(String[] args){
    18         System.out.println("请输入盘子总数n:");
    19         Scanner in = new Scanner(System.in);
    20         int n = in.nextInt();    
    21         recursionHanoi(n,'A','B','C');    
    22     }
    23 }

     

    运行结果:

    请输入盘子总数n:
    2
    A——>B
    A——>C
    B——>C
    请输入盘子总数n:
    3
    A——>C
    A——>B
    C——>B
    A——>C
    B——>A
    B——>C
    A——>C

     

     

    2.2 非递归法

    要使用非递归方法,首先要解决的核心问题就是找到汉诺塔的移动规律。现在问题是把n个盘子从A塔全部移动到C塔,那么先看看n = 234时,其具体盘子的移动路径结果(PS:移动路径前标号是指A塔上原有的第几个盘子,如(1)代表A塔上原有最上面的那个盘子,依次类推...):

     

    n = 21)A—>B
    
    2)A—>C
    
    1)B—>C
    
    n = 31)A——>C
    
    (2)A——>B
    
    1)C——>B
    
    3)A——>C
    
    1)B——>A
    
    (2)B——>C
    
    1)A——>C
    
    n = 4:
    
    1)A——>B
    
    2)A——>C
    
    1)B——>C
    
    (3)A——>B
    
    1)C——>A
    
    2)C——>B
    
    1)A——>B
    
    4)A——>C
    
    1)B——>C
    
    2)B——>A
    
    1)C——>A
    
    (3)B——>C
    
    1)A——>B
    
    2)A——>C
    
    1)B——>C

     

    从上我们可以发现,n为偶数24时路径前标号为(1)的盘子移动路径依次为A——>B——>C,A——>B——>C——>A——>B——>C。n为偶数24时路径前标号为(2)的盘子移动路径依次为A>C,A>C——>B——>A>C。而且发现n = 4其标号为(1)和标号为(3)的移动路径一模一样。n为奇数3时路径前标号为(1)和(2)的盘子移动路径依次为A——>C——>B——>A——>C,A——>B——>C。

     

    看到这里,我们可以大胆猜测盘子的具体移动路径与盘子的总个数的奇偶性以及盘子标号的奇偶性有关,而且移动的路径是固定又循环的。

     

    那么现在设定一个二维数组用来存放盘子下次移动的塔:

    char next = new char[2][3];

    二维数组中行char[0]代表数组下标为偶数的盘子下次要移动的塔

    二维数组中行char[1]代表数组下标为奇数的盘子下次要移动的塔

    二维数组重列char[0][0]代表盘子现在在A塔准备进行下次移动

    二维数组重列char[0][1]代表盘子现在在B塔准备进行下次移动

    二维数组重列char[0][2]代表盘子现在在C塔准备进行下次移动

     

    那么下面我们就来根据盘子现在所在塔,设定其下次移动的目的塔(PS:设共有n的盘子)

     

    if(n为偶数)
    
    {
    
       //数组下标为偶数的盘子移动目的塔,注意上面示例的标号为(1),其数组下标为0
    
       next[0][0] = ‘B’;   //看n = 4的移动路径中(1)A——>B
    
       next[0][1] = ‘C’;   //看n = 4的移动路径中(1)B——>C
    
       next[0][2] = ‘A’;   //看n = 4的移动路径中(1)C——>A
    
       //数组下标为奇数的盘子移动目的塔
    
       next[1][0] = ‘C’;   //看n = 4的移动路径中(2)A——>C
    
       next[1][1] = ‘A’;   //看n = 4的移动路径中(2)B——>A
    
       next[1][0] = ‘B’;   //看n = 4的移动路径中(2)C——>B
    
    }
    
    If(n为奇数)
    
    {
    
       //数组下标为偶数的盘子移动目的塔,注意上面示例的标号为(1),其数组下标为0
    
       Next[0][0] = ‘C’;   //看n = 3的移动路径中(1)A——>C
    
       Next[0][1] = ‘A’;   //看n = 3的移动路径中(1)B——>A
    
       Next[0][2] = ‘B’;   //看n = 3的移动路径中(1)C——>B
    
       //数组下标为奇数的盘子移动目的塔
    
       Next[1][0] = ‘B’;   //看n = 3的移动路径中(2)A——>B
    
       Next[1][1] = ‘C’;   //看n = 3的移动路径中(2)B——>C
    
       Next[1][2] = ‘A’;   //此处根据观察规律假设的
    
    }

     

    到这里,距离使用非递归法解决汉诺塔问题已经有头绪了,此处还有注意一点就是H(n) = 2^n - 1 (n>0),即移动n个盘子需要总次数为2^n - 1 ,即使用非递归法是需要进行循环2^n - 1 次。

     

     1 package com.liuzhen.ex2;
     2 
     3 import java.util.Scanner;
     4 
     5 public class Hanoi {
     6     
     7     //使用递归法求解含有n个不同大小盘子的汉诺塔移动路径,参数n为盘子数,把A塔上盘子全部移动到C塔上,B为过渡塔
     8     public static void recursionHanoi(int n,char A,char B,char C){
     9         if(n == 1){
    10             System.out.print(A+"——>"+C+"\n");    
    11         }
    12         else{
    13             recursionHanoi(n-1,A,C,B);         //使用递归先把A塔最上面的n-1个盘子移动到B塔上,C为过渡塔
    14             System.out.print(A+"——>"+C+"\n");       //把A塔中底下最大的圆盘,移动到C塔上
    15             recursionHanoi(n-1,B,A,C);         //使用递归把B塔上n-1个盘子移动到C塔上,A为过渡塔
    16         }
    17     }
    18     
    19     public static void noRecursionHanoi(int n){
    20         if(n<=0){
    21             throw new IllegalArgumentException("n must be >=1");
    22         }
    23         char[] hanoiPlate = new char[n];   //记录n个盘子所在的汉诺塔(hanoiPlate[1]='A'意味着第二个盘子现在在A上)
    24         char[][] next = new char [2][3];   //盘子下次会移动到的盘子的可能性分类
    25         int[] index = new int[n];
    26 
    27         //根据奇偶性将盘子分为两类
    28         for(int i=0;i<n;i=i+2){
    29             index[i]=0;
    30         }
    31         for(int i=1;i<n;i=i+2){
    32             index[i]=1;
    33         }
    34 
    35         //一开始所有盘子都在A上
    36         for(int i=0;i<n;i++){
    37             hanoiPlate[i]='A';
    38         }
    39 
    40         //n的奇偶性对移动方式的影响
    41         if(n%2==0){
    42             //数组下标为偶数的盘子移动目的塔,注意上面示例的标号为(1),其数组下标为0
    43             next[0][0]='B';
    44             next[0][1]='C';
    45             next[0][2]='A';
    46             //数组下标为奇数的盘子移动目的塔
    47             next[1][0]='C';
    48             next[1][1]='A';
    49             next[1][2]='B';
    50         }
    51         else
    52         {
    53             //数组下标为偶数的盘子移动目的塔,注意上面示例的标号为(1),其数组下标为0
    54             next[0][0]='C';
    55             next[0][1]='A';
    56             next[0][2]='B';
    57             //数组下标为奇数的盘子移动目的塔
    58             next[1][0]='B';
    59             next[1][1]='C';
    60             next[1][2]='A';
    61         }
    62 
    63         //开始移动
    64         for(int i=1;i<(1<<n);i++){                  //总共要执行2^n-1(1<<n-1)步移动
    65             int m=0;                                //m代表第m块盘子hanoiPlate[m]
    66 
    67             //根据步骤数i来判断移动哪块盘子以及如何移动
    68             for(int j=i;j>0;j=j/2){
    69                 if(j%2!=0){    //此步骤光看代码代码有点抽象,建议手动写一下n = 2时的具体移动路径的j、m值变化
    70                     System.out.println("("+(m+1)+")"+hanoiPlate[m]+"->"+next[index[m]][hanoiPlate[m]-'A']);
    71                     hanoiPlate[m]=next[index[m]][hanoiPlate[m]-'A'];
    72                     break;                           //移动盘子后则退出这层循环
    73                 }
    74                 m++;
    75             }
    76         }
    77     }
    78 
    79     public static void main(String[] args){
    80         System.out.println("请输入盘子总数n:");
    81         Scanner in = new Scanner(System.in);
    82         int n = in.nextInt();    
    83         recursionHanoi(n,'A','B','C');    
    84         System.out.println("非递归法结果:");
    85         noRecursionHanoi(n);    
    86         System.out.println();    
    87     }
    88 }

     

     

    运行结果:

    请输入盘子总数n:
    2
    A——>B
    A——>C
    B——>C
    非递归法结果:
    (1)A->B
    (2)A->C
    (1)B->C
    
    请输入盘子总数n:
    3
    A——>C
    A——>B
    C——>B
    A——>C
    B——>A
    B——>C
    A——>C
    非递归法结果:
    (1)A->C
    (2)A->B
    (1)C->B
    (3)A->C
    (1)B->A
    (2)B->C
    (1)A->C

     

     参考资料:

       1. (原创)Hanoi塔问题的递归方法与非递归方法(java实现)

     

    转载于:https://www.cnblogs.com/liuzhen1995/p/6257945.html

    展开全文
  • Java 采取递归方法求5!的阶乘,递归方法求阶乘之和,输入要阶乘的数字,递归公式:fn=fn_1*4! 具体来看以下代码:  System.out.print("输入要阶乘的数字:");  Scanner scanner = new Scanner(System.in);  int n ...
  • Java递归法解汉诺塔问题,逐步解析

    千次阅读 2020-06-02 21:33:53
    逐步讲解汉诺塔问题,通过递归解汉诺塔,符Java实现代码
  • /*** JSONObject解析方法(可以解析任意层json,采用递归解析的方法)* @param objJson* @param menu 父菜单实体类* @param list List集合* @return*/@SuppressWarnings("rawtypes")public static List analysisJson...
  • 合并二叉树 题目:给定两个二叉树,想象当你将它们中的一个覆盖到另一个上时,两个二叉树的一些节点便会重叠。 你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠,那么将他们的值相加作为节点合并后...
  • 写到这里我发现好像可以用递归来做这道题,而我以前的弱项就正好是递归得调用,所以我尝试着用递归来思考。 可以发现每一天的桃子得数量都是用前一天桃子的数量加上1之后再乘以2。于是可以把式子换成(n+1)*2 ,然后...
  • java"] class Eat { int eatPeach(int time,int peach) { if(time==1) {return peach;} else { time--; peach=(peach+1)*2; return eatPeach(time,peach); ...
  • } } 【采用递归实现】 根据题意,可得到递归式及递归结束条件。 X(n)=2*(X(n+1)+1) (x) X(10)=1 (x=1) #include int func(int n) //返回第n天时的桃子数 { if(n==10) return 1; else return 2*(func(n+1)+1); } int...
  • 通过java递归法解斐波那契数列,有具体实现代码及递归思想的简单介绍
  • 本文实例讲述了Java求解两个非负整数最大公约数算法。分享给大家供大家参考,...3.循环法 以及 递归法两种求解思路;完整源码:/* GCD:Greateast Common Divisor */public class GCD{public static void main(Stri...
  • Java无限级分类递归法

    2021-04-10 15:37:41
    Java无限级分类递归法 递归 一种计算过程,如果其中每一步都要用到前一步或前几步的结果,称为递归的。用递归过程定义的函数,称为递归函数,例如连加、连乘及阶乘等。凡是递归的函数,都是可计算的,即能行的。 ...
  • 主要介绍了Java使用递归法解决汉诺塔问题的代码示例,汉诺塔问题是使用递归解决问题的经典范例,用到的算法非常简单,需要的朋友可以参考下
  • 递归算法​ 在函数或子过程的内部,直接或者间接地调用自己的算法。特点:(1) 递归就是在过程或函数里调用自身。(2) 在使用递归策略时,必须有一个明确的递归结束条件,称为递归出口。(3) 递归算法解题通常显得很...
  • 解法1-递归法 解题思路:递归法的思路比较简单,就是先遍历左子树,然后访问根结点,然后再遍历右子树。 /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * ...
  • 八皇后问题(Eight queens)题目要求如下:在8x8格的国际象棋上摆放8个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列或同一斜线上,问有多少种摆。在西洋棋中的皇后可以在没有限定一步走几格的...
  • java 递归

    2020-02-15 13:58:00
    递归其实是分治的一种实现方式(一种实现思路) 递归就是函数在进栈,进栈的次数多了,势必会占内存,无法避免的 在某些问题上,递归所写的代码要比迭代写的代码少 在某些问题上,迭代是写不出来的,所以只能...
  • 文章目录 题目描述 解法1-递归法 解法2-非递归法 参考资料 题目描述 给定一个二叉树,检查它是否是镜像对称的。 解法1-递归法 解题思路: 首先判断根结点是否为NULL,若为空树,为直接返回true; 调用递归函数,比较...
  • 1.N个台阶的走法递归【这里设为10个台阶】/*** N个台阶的走法递归* * 有个楼梯,台阶有10个,每次可以跳上1阶 或者 2阶 ,那么台阶的走一共有多少种*/@Testpublic voidt() {System.out.println(f(10));}//斐波那契...
  • JAVA递归

    2019-10-12 23:35:30
    递归相当于数学上的 “数学归纳”, 有一个起始条件, 然后有一个递推公式. 例如, 我们求 N! 起始条件: N = 1 的时候, N! 为 1. 这个起始条件相当于递归的结束条件. 递归公式: 求 N! , 直接不好求, 可以把问题转换...
  • java递归

    2016-08-08 14:48:50
    程序设计中的数学归纳 每一个递归都有一个基值(终止)条件 ,以防止无限的递归下去 三角数字:1,3,6,10,15,21,28,。。。。。import java.io.BufferedReader; import java.io.IOException; import java....
  • 递归法java

    2015-01-14 17:19:48
    file文件中递归法可以方便删除软件做一些简单的操作
  • import java.util.*;public class digui {public static int[]data={1,3,5,7,9,11,33,55,77,99};public static void main(String[]args){System.out.println("eter the data you will find:");Scanner sca...
  • import java.util.LinkedList; import java.util.List; public class Test11 { public static void main(String[] args) { System.out.println(permute(new int[]{1, 2, 3,4})); } static List<List<...
  • java代码如下: public class hanoi { public static void main(string[] args) { int disk = 3; //盘子 move(disk, 'a', 'b', 'c'); } /* * 根据题意,从上向下编号 => 1 ~ n */ /** * * @param topn 源塔顶的盘子...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,197
精华内容 878
关键字:

java递归法

java 订阅