算法26：暴力递归

已于 2023-05-22 10:04:41 修改
阅读量537 收藏
点赞数
分类专栏： 算法 文章标签： 算法 数据结构
于 2023-05-20 18:20:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chen_yao_kerr/article/details/130783178
版权

目录

题目1：给你一个字符串，要求打印打印出这个字符串的全部子序列（子序列不能重复）

题目2：打印一个字符串的全部排列。

题目3：针对题目2，要求去除重复元素

题目4：给定一个字符串，要求打印这个字符串中字符能够能够组成的全部子集，子集无重复值。

题目5：给你一个栈，请你逆序这个栈，不能申请额外的数据结构， 只能使用递归函数。 

递归是一个过渡，为动态规划做准备。递归写好了，可以大量的优化代码结构，但是缺点是逻辑不好懂。一个好的递归，参数设计尤为重要。

题目1：给你一个字符串，要求打印打印出这个字符串的全部子序列（子序列不能重复）

这一题需要注意的是，给定了一个字符串，而字符串肯定是有顺序的，比如字符串为abc, 那么他的子序肯定不会出现cba。因为这样的顺序完全被颠倒了。所有，子序是不能改变原字符串的整体顺序的，在保持整体顺序的情况下自由组合。

package code03.递归_06;

import java.util.ArrayList;
import java.util.List;

/**
 * 给你一个字符串，要求打印打印出这个字符串的全部子序列（子序列不能重复）
 */
public class StringSequence_02
{

    public static List<String> getChildSuquence(String str)
    {
        char[]  chars = str.toCharArray();
        List<String> result = new ArrayList<>();
        //path这个参数很重要，它就是一个逐层拼接完整的字符串
        //根据递归遍历的层数，组成不同的字符串，非常灵巧
        String path = "";
        func(chars, result, 0, path);
        return result;
    }

    /**
     * 字符串是有序的，所以子序列必须要按照字符串的整体序列进行。 比如abc, 子序列肯定不能
     * 出现ba或者ca这种情况。
     *
     * 当前递归的逻辑是从后往前，就是找到最后一个元素。 下标依次是：
     *  N-2... N
     *  N-3...N
     *  N-4...N
     *  0...N
     *  N代表的是数组最后一个元素的下标。 而 N+1 就是代表的是数组的长度，
     *  此时，已经没有对应的下标了，所以认为是出口
     *
     *  假设字符串为abc, 那么它的子集为
     *  1.空字符串
     *  2.c
     *  3.b
     *  4.bc
     *  5.a
     *  6. 52组合得到ac,53z组合河道ab，54组合得到abc
     */
    static void func (char[] chars, List<String> list, int index, String path)
    {
        /**
         * 递归的出口。
         * index是最后一个字符的下标。而index+1就是数组的长度
         * 所以就需要跳出递归了
         */
        if (index == chars.length) {
            //排除重复元素
            if (!list.contains(path)) {
                list.add(path);
            }
            return;
        }
        //一直往下找，直到数组的尽头，默认给个空字符串
        func(chars, list, index + 1, path); //此处index+1用的很灵巧，因为index值本身是没有改变的

        //此处会改变path的值，用的很灵巧
        //每一个方法对弈一个方法栈，而变量path存在本地变量表，方法结束，本地变量表销毁
        //因此，此处改变的path只是在当前方法中生效。不会影响其他方法中相同名称的path值
        path = path + String.valueOf(chars[index]);

        //此处开始根据路径进行拼接。
        func(chars, list, index + 1, path);
    }

    public static void main(String[] args) {
        String test = "abc";
        //String test = "abcc";
        List<String>  result = getChildSuquence(test);

        for (String str : result) {
            System.out.println(str);
        }
    }
}

这一题解释一下：

设计思路是根据数组的下标索引进行的，而递归是一直找到下标最后一个元素为止。

此时，如果最后一个元素为c。如果c不被包括，那么path为空字符串，func搜集到空字符串。如果c被包括，那就 func 搜集到的就是 空字符串与c的拼接。 即c。递归结束，返回上一层

此时，返回到元素b处，此时不包括b的元素搜集完毕。即搜集到空字符串和c。path重新组合。 此时path为空字符串和b的组合。再次func操作。而func内部又分为不包含path和包含path两种逻辑，此时针对的是c。如果不包含c，那就搜集到b。如果包含c，那就收集到了b和c的组合，即bc

以此类推.......

整个流程图如下：

搜集结果为： 空字符串、c、b、bc、a、ac、ab、abc 

题目2：打印一个字符串的全部排列。

这个字符串的排序指的是可以任意变换字符串的顺序，而不是子字符串。 比如： abc 其中一个就是cba 但是ab a ac等都不属于全部排序

package code03.递归_06;

import java.util.ArrayList;
import java.util.List;

/**
 * 给定一个字符串，要求打印这个字符串的全部排序。
 * 注意：这个字符串的排序指的是可以任意变换字符串的顺序，而不是子字符串
 * 比如： abc 其中一个就是cba   但是ab a ac等都不属于全部排序
 */
public class PrintAllFullStr_03
{
    public static List<String> getAllStr(String str)
    {
        List<String> result = new ArrayList<>();
        String path = "";
        char[] chars = str.toCharArray();
        List<Character> list = new ArrayList<>();
        for (char cha : chars) {
            list.add(cha);
        }
        func(list, result, path);
        return result;
    }

    static void func (List<Character> chars, List<String> result, String path)
    {
        if (chars.isEmpty()) {
            result.add(path);
        }
        else {
            for (int i = 0; i < chars.size(); i++) {
                char cur = chars.get(i);
                //清除现场
                chars.remove(i);
                func(chars, result,  path + cur);
                //恢复现场
                chars.add(i, cur);
            }
        }
    }

    public static void main(String[] args) {
        String test = "abc";
        //String test = "acc";
        List<String> result = getAllStr(test);
        for (String str : result) {
            System.out.println(str);
        }
    }
}

其实，这一道题，还有另一种比较通用的解法,思路与题目1基本一样。

package code03.递归_06;

import java.util.ArrayList;
import java.util.List;

/**
 * 给定一个字符串，要求打印这个字符串的全部排序。
 * 注意：这个字符串的排序指的是可以任意变换字符串的顺序，而不是子字符串
 * 比如： abc 其中一个就是cba   但是ab a ac等都不属于全部排序
 */
public class PrintAllFullStr_03_opt
{
    public static List<String> getAllStr(String str)
    {
        char[] chars = str.toCharArray();
        List<String> result = new ArrayList<>();
        String path = "";
        func(chars, result, 0, path);
        return result;
    }

    static void func (char[]  chars, List<String> result, int index, String path)
    {
        if (index == chars.length) {
            result.add(path);
        }
        else {
            for (int i = index; i < chars.length; i++) {
                swap(chars, index, i);
                func(chars, result, index + 1, path + chars[index]);
                swap(chars, index, i);
            }
        }
    }

    public static void swap(char[] chs, int i, int j) {
        char tmp = chs[i];
        chs[i] = chs[j];
        chs[j] = tmp;
    }

    public static void main(String[] args) {
        String test = "abc";
        //String test = "acc";
        List<String> result = getAllStr(test);
        for (String str : result) {
            System.out.println(str);
        }
    }
}

针对通用解法，我们发现，既然chs始终是动态排序的，但是内部元素并不会减少。因此，可以稍微优化一下参数：

package code03.递归_06;

import java.util.ArrayList;
import java.util.List;

/**
 * 给定一个字符串，要求打印这个字符串的全部排序。
 * 注意：这个字符串的排序指的是可以任意变换字符串的顺序，而不是子字符串
 * 比如： abc 其中一个就是cba   但是ab a ac等都不属于全部排序
 */
public class PrintAllFullStr_03_opt2
{
    public static List<String> getAllStr(String str)
    {
        char[] chars = str.toCharArray();
        List<String> result = new ArrayList<>();
        func(chars, result, 0);
        return result;
    }

    static void func (char[]  chars, List<String> result, int index)
    {
        if (index == chars.length) {
            result.add(String.valueOf(chars));
        }
        else {
            for (int i = index; i < chars.length; i++) {
                swap(chars, index, i);
                func(chars, result, index + 1);
                swap(chars, index, i);
            }
        }
    }

    public static void swap(char[] chs, int i, int j) {
        char tmp = chs[i];
        chs[i] = chs[j];
        chs[j] = tmp;
    }

    public static void main(String[] args) {
        String test = "abc";
        //String test = "acc";
        List<String> result = getAllStr(test);
        for (String str : result) {
            System.out.println(str);
        }
    }
}

其实，这一道题的解题思路就是逐步确定每个位置，而记录位置的参数是index。然后for循环，把剩余的数组元素，依次填补当前位置。以此类推，典型的深度优先遍历算法。流程图如下：

题目3：针对题目2，要求去除重复元素

 去除重复元素，其实分为结果过滤和条件过滤。结果过滤就是走完所有的流程，到最后搜集结果的时候通过结果集去重。而条件过滤则是从源头排除，性能更高。以题目2为例。如果字符串为acc. 下标为1的时候，c出现一次，下一个c再次出现的时候，直接排除掉。

结果过滤：

package code03.递归_06;

import java.util.ArrayList;
import java.util.List;

/**
 * 给定一个字符串，要求打印这个字符串的全部排序, 并且
 * 这些排完序的字符串无重复数据
 *
 * 结果过滤： 执行完流程，待放入集合中时判断是否重复进行过滤。
 * 缺点很明显, 不管是否重复，所有流程都会走一遍，性能低
 *
 */
public class PrintAllFullStrNoRepeat_04
{
    public static List<String> getAllStr(String str)
    {
        char[] chars = str.toCharArray();
        List<String> result = new ArrayList<>();
        String path = "";
        func(chars, result, 0);
        return result;
    }

    static void func (char[]  chars, List<String> result, int index)
    {
        if (index == chars.length) {
            /**
             * 结果过滤,可以直接使用set
             * 此处使用的是list，需要判断集合是否存在重复元素
             */
            if (!result.contains(String.valueOf(chars))) {
                result.add(String.valueOf(chars));
            }
        }
        else {
            /**
             * index代表当前位置开头。
             * 比如index为0， 就是锁定0位置的开头数组。 for循环
             * 是找到 a b c 分别占据0的位置作为开头。 比如 a**. b**, c**
             *
             * 当index为1时，代表分别找到所有数据作为1下标位置开头。 即*a*, *b*, *c*
             *
             */
            for (int i = index; i < chars.length; i++) {
                swap(chars, index, i);
                func(chars, result, index + 1);
                swap(chars, index, i);
            }
        }
    }

    public static void swap(char[] chs, int i, int j) {
        char tmp = chs[i];
        chs[i] = chs[j];
        chs[j] = tmp;
    }

    public static void main(String[] args) {
        //String test = "abc";
        String test = "acc";
        List<String> result = getAllStr(test);
        for (String str : result) {
            System.out.println(str);
        }
    }
}

条件过滤：

package code03.递归_06;

import java.util.ArrayList;
import java.util.List;

/**
 * 给定一个字符串，要求打印这个字符串的全部排序, 并且
 * 这些排完序的字符串无重复数据
 *
 * 结果过滤： 执行完流程，待放入集合中时判断是否重复进行过滤。
 * 缺点很明显, 不管是否重复，所有流程都会走一遍，性能低
 *
 */
public class PrintAllFullStrNoRepeat_04_opt
{
    public static List<String> getAllStr(String str)
    {
        char[] chars = str.toCharArray();
        List<String> result = new ArrayList<>();
        String path = "";
        func(chars, result, 0);
        return result;
    }

    static void func (char[]  chars, List<String> result, int index)
    {
        if (index == chars.length) {
            result.add(String.valueOf(chars));
        }
        else {
            //ASCII码的范围是0-255, 它可以表示所有的字符
            //每一次递归都new一个，用的很巧妙。需要仔细揣摩
            boolean[] visited = new boolean[256];
            for (int i = index; i < chars.length; i++) {
                /**
                 * index是当前位置。第一次进入肯定是通过的。占据当前位置
                 *
                 * 原始字符数组为 a b c        原始数组为acc
                 * 1. a b c                   a c c   原始的c c位置没变。 也就是说第二个位置被第一个c占据了一遍
                 * 2. a c b                   a c c 此时的 c c是交换后的位置。也就是第二c想要再次来占据第二个位置作为后续数组的开头，重复占领该位置，直接pass掉
                 * 3. b a c                   c a c
                 * 4. b c a                   c c a
                 * 5. c a b                   c a c  同理
                 * 6  c b a                   c c a  同理
                 */
                if (!visited[chars[i]]) {
                    visited[chars[i]] = true;
                    swap(chars, index, i);
                    func(chars, result, index + 1);
                    swap(chars, index, i);
                }
            }
        }
    }

    public static void swap(char[] chs, int i, int j) {
        char tmp = chs[i];
        chs[i] = chs[j];
        chs[j] = tmp;
    }

    public static void main(String[] args) {
        //String test = "abc";
        String test = "accb";
        List<String> result = getAllStr(test);
        for (String str : result) {
            System.out.println(str);
        }
    }
}

题目4：给定一个字符串，要求打印这个字符串中字符能够能够组成的全部子集，子集无重复值。

弄懂了题目2，这一题其实就很简单了。

package code03.递归_06;

import java.util.ArrayList;
import java.util.List;

/**
 * 给定一个字符串，要求打印这个字符串的全部排序。
 * 注意：这个字符串的排序指的是可以任意变换字符串的顺序，而不是子字符串
 * 比如： abc 其中一个就是cba   但是ab a ac等都不属于全部排序
 */
public class PrintAllStr_05_opt
{
    public static List<String> getAllStr(String str)
    {
        char[] chars = str.toCharArray();
        List<String> result = new ArrayList<>();
        String path = "";
        func(chars, result, 0, path);
        return result;
    }

    static void func (char[]  chars, List<String> result, int index, String path)
    {
        if (index == chars.length) {
            result.add(path);
        }
        else {
            boolean[] visited = new boolean[256];
            for (int i = index; i < chars.length; i++) {
                visited[chars[i]] = true;
                swap(chars, index, i);
                func(chars, result, index + 1, path + chars[index]);
                if (index < chars.length-1) {
                    result.add(path + chars[index]);
                }
                swap(chars, index, i);
            }
        }
    }

    public static void swap(char[] chs, int i, int j) {
        char tmp = chs[i];
        chs[i] = chs[j];
        chs[j] = tmp;
    }

    public static void main(String[] args) {
        String test = "abc";
        //String test = "acc";
        List<String> result = getAllStr(test);
        System.out.println("length is " + result.size());
        for (String str : result) {
            System.out.println(str);
        }
    }
}

题目5：给你一个栈，请你逆序这个栈，不能申请额外的数据结构， 只能使用递归函数。 

package code03.递归_06;

import java.util.Stack;

/**
 * 题目：
 * 给你一个栈，请你逆序这个栈，
 * 不能申请额外的数据结构，
 * 只能使用递归函数。 如何实现?
 */
public class StackReverse_06 {

    public static void reverse (Stack<Integer> stack)
    {
        if (stack == null || stack.isEmpty()) {
            return;
        }
        //获取栈底元素
        int result = func(stack);
        /**
         * 继续逆转栈中剩余的元素
         * 例如栈中从上到下为 3 2 1
         * 第一次 获取result 1
         * 第二次 获取result 2
         * 第三次 获取result 3
         */
        reverse(stack);
        /**
         * 那么最后一次递归结束后，放入元素
         * 顺序是 放入 1 2 3. 顺序变为  1  2 3
         */
        stack.push(result);
    }

    /**
     * 当前递归，每次结束的时候找到的都是栈底元素
     * @param stack
     * @return
     */
    public static int func(Stack<Integer> stack)
    {
        //如果cur是栈底元素，那么当前pop以后栈就空了
        //直接返回cur
        int cur = stack.pop();
        if (stack.isEmpty()) {
            return cur;
        }
        else {
            //栈底元素
            int last = func(stack);
            //倒数第二个放入栈底
            stack.push(cur);
            return last;
        }
    }


    public static void main(String[] args) {
        Stack<Integer> test = new Stack<Integer>();
        test.push(1);
        test.push(2);
        test.push(3);
        test.push(4);
        test.push(5);
        System.out.println("逆转前顺序为： 5 4 3 2 1");
        reverse(test);
        System.out.print("逆转后顺序为： ");
        while (!test.isEmpty()) {
            System.out.print(test.pop());
            System.out.print(" ");
        }

    }
}

这一题很难，难在不允许使用其他的结构来辅助。只能在栈中自己折腾。既然是逆序，那么放置的顺序就是要反过来，栈的特性是先进后出，这就复杂了起来，下面看下整个流程：

适合java程序员的算法
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法与数据结构笔记四（暴力递归）
prague6695的博客
03-10 584
这里写目录标题8. 暴力递归8.1 汉诺塔问题8.2 打印全部子序列8.3 打印字符串的全部排列8.4 打印字符串的不重复全部排列8.5 纸牌8.6 逆序栈 8. 暴力递归 暴力递归就是尝试 1，把问题转化为规模缩小了的同类问题的子问题 2, 有明确的不需要继续进行递归的条件（base case) 3，有当得到了子问题的结果之后的决策过程 4，不记录每一个子问题的解 一定要学会怎么去尝试，因为这是动态规划的基础，这一内容我们将在提升班讲述 8.1 汉诺塔问题 0：45：0 三个杆，大的不能压小的， p
暴力递归
leigh的博客
04-10 753
暴力递归是动态规划的基础。 暴力递归其实就是尝试。 暴力递归的过程： 1. 把问题转化为规模缩小了的同类问题的子问题； 2. 有明确的不需要继续递归的条件（base case）； 3. 有当得到子问题的结果后的决策过程； 4. 不记录每一个子问题的解。 例题： 1. 汉诺塔问题：打印n层汉诺塔从最左边移动到最右边的全部过程。 void func(int rest,int...
[算法入门笔记] 8. 暴力递归
欢迎光临~
09-30 356
暴力递归入门~
【算法学习笔记】暴力递归
qq_40296661的博客
04-02 140
暴力递归的关键点在于尝试的思路，思路对了，尝试自然就能成功。而且优秀的尝试，或者说递归思路是之后用动态规划优化递归的前置条件，递归思路越优秀——可变参数形式越简单、数量越少，越容易用动态规划来优化。
递归算法.zip
04-24
常见的字符串匹配算法包括暴力匹配、KMP算法、Boyer-Moore算法等。 这些是计算机科学中常见的算法类型，每种算法都有不同的应用场景和解决问题的方法。在实际编程中，选择合适的算法对于提高程序效率和性能至关重要...
AlgoritmoDeBuscaPorForcaBruta:暴力搜索算法的简化实现
04-26
在C#中，实现暴力搜索算法可以使用递归或迭代的方法。递归方法通常更直观，但可能导致堆栈溢出，尤其是在解空间非常大的情况下。迭代方法则可以通过维护一个状态集合来避免这种情况，但代码可能更复杂一些。 1. **...
暴力、递归与分治、动态规划、贪心算法、回溯经典习题
03-13
暴力、递归与分治、动态规划、贪心算法和回溯是算法设计中常见的几种思路和方法,经典习题是帮助我们更好掌握这些算法思想的重要途径。以下是对这些经典习题的详细说明: 1. 暴力解法习题 暴力解法往往是最直观、最...
暴力求解算法讲解.doc
05-12
在本文档中，我们将讨论三种常见的暴力求解算法：枚举法、递归法和增量构造法。 1. 枚举法 枚举法是一种简单的暴力求解算法，通过枚举所有可能的解来找到问题的解答。例如，在数字迷宫问题中，我们可以枚举所有...
基础算法与数据结构汇总，包括排序、链表、二叉树、图、暴力递归、贪心算法等相关内容.zip
最新发布
04-25
贪心算法 一般来说，贪婪算法有五个组成部分: 一个候选集：从中创建一个解决方案 一个选择函数：用于选择要添加到解决方案中的最佳候选项 一个可行性函数：用于确定候选项是否可以为解决方案做出贡献 一个目标函数...
12.暴力递归
Harrison的学习博客
11-12 705
暴力递归 暴力递归就是尝试 1）把问题转化为规模缩小了的同类问题的子问题 2）有明确的不需要继续进行递归的条件(basecase) 3）有当得到了子问题的结果之后的决策过程 4）不记录每一个子问题的解 熟悉什么叫尝试? 打印n层汉诺塔从最左边移动到最右边的全部过程 打印一个字符串的全部子序列 打印一个字符串的全部子序列，要求不要出现重复字面值的子序列 打印一个字符串的全部排列 打印一个字符串的全部排列，要求不要出现重复的排列 汉诺塔 打印n层汉诺塔从最左边移动到最右边的全部过程 package co
详解暴力递归
weixin_73936404的博客
06-12 219
给定两个长度都为N的数组weights和values，weights[i]和values[i] 分别表示 i 号 物品的 重量和 价值。给定一个正数bag，表示一个载重为bag的袋子，你装的的物品不能超过这个重量。给你一个栈，请你逆序这个栈，不能申请额外的数据结构，只能使用递归函数。// 暴力递归时的原则：找到可变参数形式最简单，可变参数个数最少的方法。打印字符串的全部排列： （不能出现重复的排列）但是每个玩家每次只能拿走最左或最右的纸牌。返回你能装下的的最大价值是多少？规定玩家A先拿，玩家B后拿。
入门—暴力递归
Ljj262420的博客
11-30 156
对于暴力递归的题目的注意点 一、要注意base。不同题目要求不同。 （1）、对于求有多少种方法的题目，往往是返回1，然后递归累加所有可能性。 （2）、对于求最值的题目，往往是返回0、 （3）、 二、递归过程中，要注意分清楚，不同条件的状态转换，注意当前状态发生转换时，是否要受到前一状态的转换（例如n皇后问题） 三、暴力递归过程中是，默认后一状态的结果是已经可知的，不许要太在一后过程的细节 四-、递归过程有点理解苦难时，应该借助于递归i树，进行辅助...
算法-暴力递归
qq_42373007的博客
04-25 182
暴力递归 public class HanNuoTa { public static void hannuo(int n) { if(n>0) { function(n,"左","右","中"); } } public static void function(int i, String start, String end, String other) { if(i==1) { System.out.println("Move 1 from"+start+"t
暴力递归的理解
qq_43224197的博客
08-30 365
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 递归是程序中很接近于数学语言的一种写法，使用递归编程在阅读代码易于理解，但是往往会带来效率低下的问题，效率问题暂且按下不表，本章主要讲讲对于递归的理解 提示：以下是本篇文章正文内容，下面案例可供参考 一、递归是什么？ 百度解释：程序调用自身的编程技巧称为递归（ recursion）。在百度还有更细致的解释，我
算法数据结构（十五）----暴力递归
u011624267的博客
08-05 202
暴力递归就是尝试 1，把问题转化为规模缩小了的同类问题的子问题 2，有明确的不需要继续进行递归的条件(base case) 3，有当得到了子问题的结果之后的决策过程 4，不记录每一个子问题的解 熟悉什么叫尝试？ 打印n层汉诺塔从最左边移动到最右边的全部过程 简单版本，规定6个函数，相互调用 public static void hanoi1(int n) { leftToRight(n); } // 请把1~N层圆盘 从左 -> 右 public static.
算法基础——暴力递归（C++实现）
Sebastian_Nova的博客
10-19 251
相传在古印度圣庙中，有一种被称为汉诺塔(Hanoi)的游戏。该游戏是在一块铜板装置上，有三根杆(编号A、B、C)，在A杆自下而上、由大到小按顺序放置n个金盘。游戏的目标：把A杆上的金盘全部移到C杆上，并仍保持原有顺序叠好。打印n层汉诺塔从最左边移动到最右边的全部过程。操作规则：每次只能移动一个盘子，并且在移动过程中三根杆上都始终保持大盘在下，小盘在上，操作过程中盘子可以置于A、B、C任一杆上。题目给出一个字符串，要求打印出它所包含的所有子序列，包括空字符串。
左神算法笔记06：暴力递归
upset_poor的博客
11-21 1056
暴力递归 暴力递归就是尝试 把问题转化为规模缩小了的同类问题的子问题 有明确的不需要继续进行递归的条件（base case） 有当得到了子问题的结果之后的决策过程 不记录每一个子问题的解 一定要学会怎么去尝试，因为这是动态规划的基础 汉诺塔问题 打印n层汉诺塔从最左边移动到最右边的全部过程 public class Hanoi { public static void hanoi(int n){ if(n > 0){ func(n,"左","右","中"); } } //1
算法入门篇九 暴力递归
CHYabc123456hh的博客
06-16 777
牛客网左程云老师的算法入门课 暴力递归 原则 汉诺塔问题 问题 打印n层汉诺塔从左边移动到最右边的过程 思想 一共六个过程，左到右、左到中，中到左，中到右，右到左，右到中，互相嵌套使用 左到右 将1-》N-1移动到中间的那个杆上 将N从最左边移动到最右边 将1》-N-1移动到最右边的那个杆上 左到中 将1-N-1从左移动到右 N从左移动到中 将1-》N-1从右移动到中 。。。。。。 代码 package class08; public class Code01_Ha...
LeetCode算法资料：迭代与递归解题技巧解析
在更高级的部分，LeetCode提供了如计算N以内素数的算法练习，其中暴力算法涉及从2开始遍历并检查整除性，而递归方法则通过分治策略，从根节点开始，逐步向叶节点推进，确保链表不断并正确反转。 LeetCode算法资料是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值