数据结构与算法-递归-leetcode练习

关注

原创最新推荐文章于 2026-05-12 07:59:22 发布 428 阅读 AI 写同款· GEO 优化 ›

数据结构与算法——LeetCode编码练习01 本文总结了几种链表常见问题的解法，包括环形链表检测（141/142题）、快乐数判断（202题）、链表反转（206/92/25题）、旋转链表（61题）、节点交换（24题）和节点删除（19/83题）。主要使用了哈希表法和快慢指针法两种技术：哈希表法通过存储访问过的节点判断重复；快慢指针法则利用双指针不同步长检测环或定位特定位置。链表反转问题展示了迭代法的通用解法，而分组反转和删除问题则体现了对边界条件的处理技巧。这些解法涵盖了链表操作的核心模式，具有较高的实用价值。阅读详情

递归

编写递归要决，千万不要用人脑去递和归每一层，正确的做法是找到如何分解为子问题，然后几个子问题的关系是什么。然后翻译成代码。

leetcode17

题目描述:

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

示例:

输入："23"

输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].

说明:

尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

先说最简单的，对应数字与字符的对应关系，我们可以用数组来记录，下标为代表0到9的数字，值即为每个字符串，由于0和1都没有字符，为了使用方便，还是使用空字符来占用。即可表示为

String[] dict = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};

再来说如何组合所有可能性，还不能重复。比如输入23

类比我们人脑来处理的过程就是这样：

先取2的第一个字符与后面每个字符组合，然后再取出3的每个字符与后面组合即可得到所有可能性。

使用递归还求解，需定能定义出来递推公式，可我数学公式基本已经还给老师了，实在是对不起老师呀，还是来想想处理过程吧。

递归需要我们将问题分解为多个子问题。那我们如何分解呢？

刚刚人脑的处理过程就取出数字对应的字符串，然后一个一个的遍历，与之前的字符进行组合，这是递归的处理逻辑，当我们遍历到输入数字最后一个时，就需要将每个数字组合进行记录。这是递归的终止条件。

然后我们此翻译成代码：

解题实现

public class RecurstionSolution {

private static final String[] STAT_CODE =
      new String[] {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};

public List<String> letterCombinations(String digits) {

    List<String> result = new ArrayList<>();
    if (digits == null || digits.isEmpty()) {
      return result;
    }

    String inputData = digits.trim();
    // 1,将输入的字符转化为数字
    int[] dataNum = new int[inputData.length()];

    for (int i = 0; i < inputData.length(); i++) {
      dataNum[i] = inputData.charAt(i) - '0';
    }

    String dataChar = "";

    this.recurstionData(dataNum, 0, result, dataChar);
    return result;
}

/**
   * 进行递归的求解
   *
   * @param dataNum 输入字符
   * @param index 索引号
   * @param list 数据集合
   * @param dataChar 当前的字符
   */
private void recurstionData(int[] dataNum, int index, List<String> list, String dataChar) {
    // 1，递归的终止条件
    if (index == dataNum.length) {
      list.add(new String(dataChar));
      return;
    }

    // 进行递归的求解
    for (int i = 0; i < STAT_CODE[dataNum[index]].length(); i++) {
      dataChar = dataChar + STAT_CODE[dataNum[index]].charAt(i);
      // 当取出一个字符后继续进行遍历
      this.recurstionData(dataNum, index + 1, list, dataChar);
      // 当遍历完成后，需要删除当前的最后一个字符,以可以与其他进行组合
      dataChar = dataChar.substring(0, dataChar.length() - 1);
    }
}
}

leetcod22

题目描述:

22. 括号生成
给出 n 代表生成括号的对数，请你写出一个函数，
使其能够生成所有可能的并且有效的括号组合。

例如，给出 n = 3，生成结果为：

[
"((()))",
"(()())",
"(())()",
"()(())",
"()()()"
]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/generate-parentheses
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路：

这个题目说实话我也做错了，我开始的解题思路是以成对的括号为单位，我想的是在括号的左边，右边，还有中间，依次的插入号位，递归这样就可以求解了，但当我实现的时候，我发现，我的思路是错误的，因为当遍历到多层时，这个中间括号已经无法再明确的定义，需要寻找其他解法。

我又来参照了其他的方案，终于理解了这个递归的求解方法：

这个问题的求解可以分为两部分，添加左括号、和添加右括号，添加的个数正好是输入的数字，例如3，就是可以添加3个左括号和3个右括号。

那现在就是如何添加左括号和右括号的问题：

先说左括号，最大左括号不就是输入的数字么，所以需要一个左括号的索引来记录当前是第几个左括号，需要小于最大左括号。添加一个括号即可

当左括号添加了，那右括号嗯，是否和左括号一样，这个还是有点不一样呢，右括号需要与左括号成对出现，就不能出现右括号比左括号还多的情况，这样最大右括号需要小于当前的左括号数了。

递归终止条件是什么呢，当然是当前括号数满足了输入的括号数*2，例如输入3，就是6个，左路输入左右括号数，一样要是6个。现在来翻译成代码吧.

递归代码实现

public class SolutionParthese2 {

public static final String PARENTHESE_LEFT = "(";
public static final String PARENTHESE_RIGHT = ")";

public List<String> generateParenthesis(int num) {
    List<String> result = new ArrayList<>();

    if (num == 1) {
      result.add(PARENTHESE_LEFT + PARENTHESE_RIGHT);
      return result;
    }

    if (num == 0) {
      return result;
    }

    this.recurstion(num, 0, 0, result, "");

    return result;
}

/**
   * 递归求最大括号的组合
   *
   * @param maxNum 最大索引号
   * @param left 左索引号
   * @param right 右索引号
   * @param resultLst 存储的结果数
   * @param data 当前已经得到的括号组合
   */
public void recurstion(int maxNum, int left, int right, List<String> resultLst, String data) {
    // 1,首先写递归的终止条件
    if (data.length() == maxNum * 2) {
      resultLst.add(data);
      return;
    }

    // 添加左括号
    if (left < maxNum) {
      this.recurstion(maxNum, left + 1, right, resultLst, data + PARENTHESE_LEFT);
    }

    // 添加右括号，右括号，需要小于左括号，否则不对成对了
    if (right < left) {
      this.recurstion(maxNum, left, right + 1, resultLst, data + PARENTHESE_RIGHT);
    }
}
}

leetcode39

题目描述:

39. 组合总和
给定一个无重复元素的数组 candidates 和一个目标数 target ，
找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的数字可以无限制重复被选取。

说明：

所有数字（包括 target）都是正整数。
解集不能包含重复的组合。
示例 1:

输入: candidates = [2,3,6,7], target = 7,
所求解集为:
[
[7],
[2,2,3]
]
示例 2:

输入: candidates = [2,3,5], target = 8,
所求解集为:
[
[2,2,2,2],
[2,3,3],
[3,5]
]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/combination-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路:

这个是一个求组合的问题，我的求解思路是这样子的，将数组中的每个元素，从当前自己开始，依次与一个元素相加，如果超过了，说明符不合，如果与预期值相同，则记录下来，未到达退出条件则继续递归。为了确保无重复的数据，可使用set来进行存储

编码实现

public class SolutionMySelf {

public List<List<Integer>> combinationSum(int[] inputSrc, int target) {

    if (inputSrc == null || inputSrc.length == 0) {
      return null;
    }

    List<Integer> currList = new ArrayList<>();
    Set<List<Integer>> collect = new HashSet<>();

    this.recurstion(inputSrc, target, 0, 0, currList, collect);

    List<List<Integer>> result = new ArrayList<>(collect);

    return result;
}

/**
   * 进行问题的递归求解,对于重复的数据项，即通过起始值来操作，当已经遍历过的数据，将不再遍历。
   *
   * @param inputSrc 输入数组
   * @param target 目标值
   * @param value 当前的值
   * @param startIndex 开始的索引号，小技巧，这样可以避免重复的计算。只需要从当前向后推进即可
   * @param collect 当前已经记录的集合
   * @param resultList 记录下已经求解的数据集
   */
private void recurstion(
      int[] inputSrc,
      int target,
      int value,
      int startIndex,
      List<Integer> collect,
      Set<List<Integer>> resultList) {

    // 1,递归的终止条件
    if (value == target) {
      resultList.add(new ArrayList<>(collect));
      return;
    }
    // 2,超过出说明不符合直接退出
    if (value > target) {
      return;
    }

    for (int i = startIndex; i < inputSrc.length; i++) {
      value = value + inputSrc[i];
      collect.add(inputSrc[i]);
      this.recurstion(inputSrc, target, value, i, collect, resultList);
      // 当结束后，需要移除最后一个元素
      collect.remove(collect.size() - 1);
      value = value - inputSrc[i];
    }
}
}

leetcode46

题目描述:

给定一个没有重复数字的序列，返回其所有可能的全排列。

示例:

输入: [1,2,3]
输出:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/permutations
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路:

我的解题思路就是将数组中的每个元素与剩下的两个元素进行组合，当给合的大小与数组大小一致就放入到结果集中。那如何表示剩余下元素呢，我的办法是将已经遍历过程下标通过一个boolean数组记录下来，这样就能知道了

代码实现

public class SolutionPermute {

public List<List<Integer>> permute(int[] nums) {

    Set<List<Integer>> data = new HashSet<>();
    List<Integer> currdata = new ArrayList<>();

    boolean[] exists = new boolean[nums.length];

    this.recurstion(nums, data, currdata, exists);

    List<List<Integer>> result = new ArrayList<>(data);

    return result;
}

private void recurstion(
      int[] nums, Set<List<Integer>> data, List<Integer> currdata, boolean[] exists) {

    // 如果当前组合到达组合的结果大小，则加入到结果集中
    if (currdata.size() == nums.length) {
      data.add(new ArrayList<>(currdata));
      return;
    }

    for (int i = 0; i < nums.length; i++) {
      // 仅对未遍历过元素进行遍历
      if (!exists[i]) {
        exists[i] = true;

        currdata.add(nums[i]);

        this.recurstion(nums, data, currdata, exists);
        currdata.remove(currdata.size() - 1);

        exists[i] = false;
      }
    }
}
}

leetcode79

题目描述:

79. 单词搜索

给定一个二维网格和一个单词，找出该单词是否存在于网格中。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

示例:

board =
[
['A','B','C','E'],
['S','F','C','S'],
['A','D','E','E']
]

给定 word = "ABCCED", 返回 true.
给定 word = "SEE", 返回 true.
给定 word = "ABCB", 返回 false.

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/word-search
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

针对此单词搜索，因为存在4种匹配的情况：

情况1，横坐标+1可匹配

情况2，横坐标-1可匹配

情况3，纵坐标+1可匹配

情况4，纵坐标-1可匹配

递归的终止条件呢？当发生字符不匹配，搜索终止，或者搜索到匹配字符，搜索终止，那过有其他条件吗？当然有，那就是横纵坐标，必须在字符的下标范围以内

代码实现

public class SolutionRectustionMySelf {

public boolean exist(char[][] src, String data) {

    boolean[][] exists = new boolean[src.length][src[0].length];

    boolean existsResult = false;

    String srcvalue = null;

    //搜索开始的字符位置
    for (int i = 0; i < src.length; i++) {
      for (int j = 0; j < src[i].length; j++) {
        srcvalue = String.valueOf(src[i][j]);
        if (data.startsWith(srcvalue)) {
        existsResult = this.exist(src, "", data, i, j, exists);

          if (existsResult) {
            return true;
          }
        }
      }
    }

    return false;
}

/**
   * 每个字符的匹配可以看作是当前字符与其他字体的一个匹配
   *
   * @param src 原始的匹配字符数组
   * @param currData 当前的字符
   * @param targetData 匹配的目标字符
   * @param rowindex 行索引
   * @param cellindex 列索引
   * @return
   */
public boolean exist(
      char[][] src,
      String currData,
      String targetData,
      int rowindex,
      int cellindex,
      boolean[][] exists) {

    if (currData.equals(targetData)) {
      return true;
    }

    if (rowindex < 0 || rowindex >= src.length) {
      return false;
    }

    if (cellindex < 0 || cellindex >= src[rowindex].length) {
      return false;
   }

    // 节点已经访问，则标识为false
    if (exists[rowindex][cellindex]) {
      return false;
    }

    currData = currData + src[rowindex][cellindex];

    if (currData.length() > targetData.length()) {
      return false;
    }

    // 在进入时标识已经访问
    exists[rowindex][cellindex] = true;

    // 当字符匹配的时，可能存在4个方向的情况
    if (targetData.startsWith(currData)) {
      if (exist(src, currData, targetData, rowindex + 1, cellindex, exists)
          || exist(src, currData, targetData, rowindex, cellindex + 1, exists)
          || exist(src, currData, targetData, rowindex - 1, cellindex, exists)
          || exist(src, currData, targetData, rowindex, cellindex - 1, exists)) {
        return true;
      }
    }
    // 退出时还需要标识出未访问
    exists[rowindex][cellindex] = false;

    return false;
}
}