代码随想录 回溯算法-组合

已于 2024-04-12 18:42:19 修改
阅读量903 收藏 26
点赞数 23
分类专栏： 代码随想录 文章标签： 算法 数据结构 leetcode java 开发语言
于 2024-03-06 15:42:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74267125/article/details/136500319
版权

目录

77.组合 

216.组合总和||| 

17.电话号码的字母组合

39.组合总和 

40.组合总和||

77.组合 

77. 组合

中等

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

示例 1：

输入：n = 4, k = 2
输出：
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

示例 2：

输入：n = 1, k = 1
输出：[[1]]

提示：

  • 1 <= n <= 20
  • 1 <= k <= n

 通过这张图可以对递归的过程有清晰的认识。

class Solution {  
    // 存储所有可能组合的结果列表  
    List<List<Integer>> result = new ArrayList<>();  
    // 存储当前正在构建的组合路径  
    List<Integer> path = new ArrayList<>();  
  
    // 主方法，接收两个参数n和k，返回从n个数中选取k个数的所有组合  
    public List<List<Integer>> combine(int n, int k) {  
        // 从第1个数开始回溯  
        backtracking(n, k, 1);  
        // 返回所有组合的结果  
        return result;  
    }  
  
    // 回溯方法，接收三个参数：n表示可选数字的上限，k表示需要选择的数字个数，begin表示从哪个数字开始选择  
    public void backtracking(int n, int k, int begin) {  
        // 如果当前路径上的数字个数等于k，则找到了一个有效组合  
        if (path.size() == k) {  
            // 将当前路径添加到结果列表中（注意这里需要添加path的副本，因为path在后续会被修改）  
            result.add(new ArrayList<>(path));  
            return;  
        }  
  
        // 遍历从begin开始到n的所有数字  
        for (int i = begin; i <= n; i++) {  
            // 将当前数字添加到路径中  
            path.add(i);  
            // 递归调用，继续选择下一个数字，起始数字为当前数字的下一个（避免重复）  
            backtracking(n, k, i + 1);  
            // 回溯，移除路径中最后添加的数字，尝试其他可能性  
            path.removeLast();  
        }  
    }  
}

剪枝操作：

来举一个例子，n = 4，k = 4的话，那么第一层for循环的时候，从元素2开始的遍历都没有意义了。 在第二层for循环，从元素3开始的遍历都没有意义了。

图中每一个节点（图中为矩形），就代表本层的一个for循环，那么每一层的for循环从第二个数开始遍历的话，都没有意义，都是无效遍历。

所以，可以剪枝的地方就在递归中每一层的for循环所选择的起始位置。

如果for循环选择的起始位置之后的元素个数 已经不足 我们需要的元素个数了，那么就没有必要搜索了。

class Solution {  
    // 存储所有可能组合的结果列表  
    List<List<Integer>> result = new ArrayList<>();  
    // 存储当前正在构建的组合路径  
    List<Integer> path = new ArrayList<>();  
  
    // 主方法，接收两个参数n和k，返回从n个数中选取k个数的所有组合  
    public List<List<Integer>> combine(int n, int k) {  
        // 从第1个数开始回溯  
        backtracking(n, k, 1);  
        // 返回所有组合的结果  
        return result;  
    }  
  
    // 回溯方法，接收三个参数：n表示可选数字的上限，k表示需要选择的数字个数，begin表示从哪个数字开始选择  
    public void backtracking(int n, int k, int begin) {  
        // 如果当前路径上的数字个数等于k，则找到了一个有效组合  
        if (path.size() == k) {  
            // 将当前路径添加到结果列表中（注意这里需要添加path的副本，因为path在后续会被修改）  
            result.add(new ArrayList<>(path));  
            return;  
        }  
  
        // 遍历从begin开始到极限情况下的数字
        //这里执行了剪枝操作
        for (int i = begin; i <= n - (k - path.size()) + 1; i++) {  
            // 将当前数字添加到路径中  
            path.add(i);  
            // 递归调用，继续选择下一个数字，起始数字为当前数字的下一个（避免重复）  
            backtracking(n, k, i + 1);  
            // 回溯，移除路径中最后添加的数字，尝试其他可能性  
            path.removeLast();  
        }  
    }  
}

优化过程如下：

  1. 已经选择的元素个数：path.size();

  2. 还需要的元素个数为: k - path.size();

  3. 在集合n中至多要从该起始位置 : n - (k - path.size()) + 1，开始遍历

为什么有个+1呢，因为包括起始位置，我们要是一个左闭的集合。

举个例子，n = 4，k = 3， 目前已经选取的元素为0（path.size为0），n - (k - 0) + 1 即 4 - ( 3 - 0) + 1 = 2。

从2开始搜索都是合理的，可以是组合[2, 3, 4]。

这里想不懂的话，建议也举一个例子，就知道是不是要+1了。

216.组合总和||| 

216. 组合总和 III

中等

找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：

  • 只使用数字1到9
  • 每个数字 最多使用一次 

返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。

示例 1:

输入: k = 3, n = 7
输出: [[1,2,4]]
解释:
1 + 2 + 4 = 7
没有其他符合的组合了。

示例 2:

输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]
解释:
1 + 2 + 6 = 9
1 + 3 + 5 = 9
2 + 3 + 4 = 9
没有其他符合的组合了。

示例 3:

输入: k = 4, n = 1
输出: []
解释: 不存在有效的组合。
在[1,9]范围内使用4个不同的数字，我们可以得到的最小和是1+2+3+4 = 10，因为10 > 1，没有有效的组合。

提示:

  • 2 <= k <= 9
  • 1 <= n <= 60

// Solution类，用于实现组合数的生成  
class Solution {  
  
    // 存储所有可能组合的结果列表  
    List<List<Integer>> result = new ArrayList<>();  
    // 存储当前正在构建的组合路径  
    List<Integer> path = new ArrayList<>();  
    // 存储当前组合路径的和  
    int sum = 0;  
  
    // 主方法，接收两个参数k和n，返回和为n且长度为k的所有组合  
    public List<List<Integer>> combinationSum3(int k, int n) {  
        // 从1开始回溯  
        backtracking(k, n, 1);  
        // 返回所有组合的结果  
        return result;  
    }  
  
    // 回溯方法，接收三个参数：k表示需要选择的数字个数，n表示目标和，begin表示从哪个数字开始选择  
    public void backtracking(int k, int n, int begin) {  
        // 如果当前路径的和等于n且路径的长度等于k，则找到了一个有效组合  
        if (sum == n && path.size() == k) {  
            // 将当前路径添加到结果列表中（注意这里需要添加path的副本，因为path在后续会被修改）  
            result.add(new ArrayList<>(path));  
            return;  
        }  
        // 如果路径的长度已经达到k或者当前路径的和已经大于n，则终止递归  
        if (path.size() == k || sum > n) {  
            return;  
        }  
        // 从begin开始遍历到9 - (k - path.size()) + 1，确保剩余的数字能够组成长度为k的组合  
        for (int i = begin; i <= 9 - (k - path.size()) + 1; i++) {  
            // 将当前数字添加到路径中  
            path.add(i);  
            // 更新当前路径的和  
            sum += i;  
            // 递归调用，继续选择下一个数字，起始数字为当前数字的下一个  
            backtracking(k, n, i + 1);  
            // 回溯，移除路径中最后添加的数字，尝试其他可能性  
            path.removeLast();  
            // 回溯，更新当前路径的和  
            sum -= i;  
        }  
    }  
}

 剪枝操作：

// Solution类，用于实现组合数的生成  
class Solution {  
  
    // 存储所有可能组合的结果列表  
    List<List<Integer>> result = new ArrayList<>();  
    // 存储当前正在构建的组合路径  
    List<Integer> path = new ArrayList<>();  
    // 存储当前组合路径的和  
    int sum = 0;  
  
    // 主方法，接收两个参数k和n，返回和为n且长度为k的所有组合  
    public List<List<Integer>> combinationSum3(int k, int n) {  
        // 从1开始回溯  
        backtracking(k, n, 1);  
        // 返回所有组合的结果  
        return result;  
    }  
  
    // 回溯方法，接收三个参数：k表示需要选择的数字个数，n表示目标和，begin表示从哪个数字开始选择  
    public void backtracking(int k, int n, int begin) {  
        // 如果当前路径的和等于n且路径的长度等于k，则找到了一个有效组合  
        if (sum == n && path.size() == k) {  
            // 将当前路径添加到结果列表中（注意这里需要添加path的副本，因为path在后续会被修改）  
            result.add(new ArrayList<>(path));  
            return;  
        }  
        // 如果路径的长度已经达到k或者当前路径的和已经大于n，则终止递归  
        if (path.size() == k || sum > n) {  
            return;  
        }  
        // 从begin开始遍历到9 - (k - path.size()) + 1，确保剩余的数字能够组成长度为k的组合
        //这里采用剪枝操作  
        for (int i = begin; i <= 9 - (k - path.size()) + 1; i++) {
            //已选元素总和如果已经大于n了，那么往后遍历就没有意义了
            if(sum + i > n){
                break;
            }  
            // 将当前数字添加到路径中  
            path.add(i);  
            // 更新当前路径的和  
            sum += i;  
            // 递归调用，继续选择下一个数字，起始数字为当前数字的下一个  
            backtracking(k, n, i + 1);  
            // 回溯，移除路径中最后添加的数字，尝试其他可能性  
            path.removeLast();  
            // 回溯，更新当前路径的和  
            sum -= i;  
        }  
    }  
}

17.电话号码的字母组合

17. 电话号码的字母组合

中等

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

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

示例 1：

输入：digits = "23"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]

示例 2：

输入：digits = ""
输出：[]

示例 3：

输入：digits = "2"
输出：["a","b","c"]

提示：

  • 0 <= digits.length <= 4
  • digits[i] 是范围 ['2', '9'] 的一个数字。

// Solution类，用于实现电话号码字母映射问题的解决方案  
class Solution {  
    // 数字对应的字母映射数组  
    String[] numString = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};  
    // 存储所有可能字母组合的结果列表  
    List<String> result = new ArrayList<>();  
    // StringBuilder对象，用于构建当前组合的字符串  
    StringBuilder builder = new StringBuilder();  
  
    // 主方法，接收一个包含数字 2-9 的字符串，返回所有可能的字母组合  
    public List<String> letterCombinations(String digits) {  
        // 如果输入的数字字符串为空，则直接返回空的结果列表  
        if (digits.length() == 0) {  
            return result;  
        }  
        // 从第一个数字开始回溯  
        backtracking(digits, 0);  
        // 返回所有可能的字母组合  
        return result;  
    }  
  
    // 回溯方法，递归地构建所有可能的字母组合  
    public void backtracking(String digits, int num) {  
        // 如果当前构建的字符串长度等于输入的数字字符串长度，说明已经构建完一个完整的组合  
        if (builder.length() == digits.length()) {  
            // 将当前构建的字符串添加到结果列表中  
            result.add(builder.toString());  
            return;  
        }  
        // 获取当前数字对应的字母字符串  
        String str = numString[digits.charAt(num) - '0'];  
        // 遍历当前数字对应的所有字母  
        for (int i = 0; i < str.length(); i++) {  
            // 将当前字母添加到构建字符串中  
            builder.append(str.charAt(i));  
            // 递归处理下一个数字  
            backtracking(digits, num + 1);  
            // 回溯，移除刚刚添加的字母，尝试下一个字母  
            builder.deleteCharAt(builder.length() - 1);  
        }  
    }  
}

39.组合总和 

39. 组合总和

中等

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。 

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

示例 1：

输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

示例 2：

输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]

示例 3：

输入: candidates = [2], target = 1
输出: []

提示：

  • 1 <= candidates.length <= 30
  • 2 <= candidates[i] <= 40
  • candidates 的所有元素 互不相同
  • 1 <= target <= 40

// Solution类，用于解决组合和问题  
class Solution {  
    // 用于存储所有可能组合的结果列表  
    List<List<Integer>> result = new ArrayList<>();  
    // 用于存储当前正在构建的组合路径  
    List<Integer> path = new ArrayList<>();  
    // 用于存储当前组合路径的数字和  
    int sum = 0;  
  
    // 组合和问题的主方法，接收一个整数数组candidates和目标值target  
    public List<List<Integer>> combinationSum(int[] candidates, int target) {  
        // 从数组的第一个元素开始回溯  
        backtracking(candidates, target, 0);  
        // 返回所有可能的组合结果  
        return result;  
    }  
  
    // 回溯方法，用于递归地生成所有可能的组合  
    public void backtracking(int[] candidates, int target, int begin) {  
        // 如果当前路径的数字和等于目标值target，则找到了一个有效组合  
        if (sum == target) {  
            // 将当前路径添加到结果列表中（注意这里需要添加path的副本，因为path在后续会被修改）  
            result.add(new ArrayList<>(path));  
            return;  
        }  
        // 如果当前路径的数字和大于目标值target，则剪枝，不再继续递归  
        if (sum > target) {  
            return;  
        }  
        // 遍历数组candidates，从begin开始，避免重复使用同一个数字  
        for (int i = begin; i < candidates.length; i++) {  
            // 将当前数字添加到路径中  
            path.add(candidates[i]);  
            // 更新当前路径的数字和  
            sum += candidates[i];  
            // 递归调用，继续选择下一个数字，起始位置可以从当前位置开始，允许重复使用数字  
            backtracking(candidates, target, i); // 注意这里不是i+1，因为可以重复使用同一个数字  
            // 回溯，移除路径中最后添加的数字，尝试其他可能性  
            path.removeLast();  
            // 回溯，更新当前路径的数字和  
            sum -= candidates[i];  
        }  
    }  
}

 剪枝操作：

// Solution类，用于解决组合和问题  
class Solution {  
    // 用于存储所有可能组合的结果列表  
    List<List<Integer>> result = new ArrayList<>();  
    // 用于存储当前正在构建的组合路径  
    List<Integer> path = new ArrayList<>();  
    // 用于存储当前组合路径的数字和  
    int sum = 0;  
  
    // 组合和问题的主方法，接收一个整数数组candidates和目标值target  
    public List<List<Integer>> combinationSum(int[] candidates, int target) {  
        // 从数组的第一个元素开始回溯  
        backtracking(candidates, target, 0);  
        // 返回所有可能的组合结果  
        return result;  
    }  
  
    // 回溯方法，用于递归地生成所有可能的组合  
    public void backtracking(int[] candidates, int target, int begin) {  
        // 如果当前路径的数字和等于目标值target，则找到了一个有效组合  
        if (sum == target) {  
            // 将当前路径添加到结果列表中（注意这里需要添加path的副本，因为path在后续会被修改）  
            result.add(new ArrayList<>(path));  
            return;  
        }  
        // 如果当前路径的数字和大于目标值target，则剪枝，不再继续递归  
        if (sum > target) {  
            return;  
        }  
        // 遍历数组candidates，从begin开始，避免重复使用同一个数字  
        for (int i = begin; i < candidates.length; i++) {
            //已选元素总和如果已经大于target了，那么往后遍历就没有意义了
            if(sum + candidates[i] > target){
                continue;
            }  
            // 将当前数字添加到路径中  
            path.add(candidates[i]);  
            // 更新当前路径的数字和  
            sum += candidates[i];  
            // 递归调用，继续选择下一个数字，起始位置可以从当前位置开始，允许重复使用数字  
            backtracking(candidates, target, i); // 注意这里不是i+1，因为可以重复使用同一个数字  
            // 回溯，移除路径中最后添加的数字，尝试其他可能性  
            path.removeLast();  
            // 回溯，更新当前路径的数字和  
            sum -= candidates[i];  
        }  
    }  
}

40.组合总和||

40. 组合总和 II

中等

给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用 一次 。

注意：解集不能包含重复的组合。 

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

示例 2:

输入: candidates = [2,5,2,1,2], target = 5,
输出:
[
[1,2,2],
[5]
]

提示:

  • 1 <= candidates.length <= 100
  • 1 <= candidates[i] <= 50
  • 1 <= target <= 30

 

这里我们放弃use数组的用法 ，重点读：

同一树枝上相同两个重复元素可以重复取1，即不同层可用重复元素

同一树层上两个重复元素不可以重复选取1，即同层不可用重复元素

那么我们就只需要去掉同层间的重复元素

如下，当i > begin的时候，如果一个元素和它的前一个元素相等的情况下，那么前一个元素一定被使用过了，需要跳过当前元素

// Solution类，用于解决组合和问题的第二种实现  
class Solution {  
    // 存储所有可能组合的结果列表  
    List<List<Integer>> result = new ArrayList<>();  
    // 存储当前正在构建的组合路径  
    List<Integer> path = new ArrayList<>();  
    // 存储当前组合路径的数字和  
    int sum = 0;  
  
    // 组合和问题的主方法，接收一个整数数组candidates和目标值target  
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {  
        // 对候选数字数组进行排序，这有助于剪枝和提高效率  
        Arrays.sort(candidates);  
        // 开始回溯搜索  
        backtracking(candidates, target, 0);  
        // 返回所有可能的组合结果  
        return result;  
    }  
  
    // 回溯方法，用于递归地生成所有可能的组合  
    public void backtracking(int[] candidates, int target, int begin) {  
        // 如果当前路径的数字和等于目标值target，则找到了一个有效组合  
        if (sum == target) {  
            // 将当前路径添加到结果列表中（注意需要添加path的副本）  
            result.add(new ArrayList<>(path));  
            return;  
        }  
        // 如果当前路径的数字和大于目标值target，则剪枝，不再继续递归  
        if (sum > target) {  
            return;  
        }  
        // 遍历数组candidates，从begin开始  
        for (int i = begin; i < candidates.length; i++) {  
            // 如果当前数字加上sum已经大于target，则剪枝，不再继续探索  
            if (sum + candidates[i] > target) {  
                break;  
            }  
            // 跳过同一树层使用过的相同元素 
            //i > begin说明假如存在相同元素，那么它一定在该数层中使用过了
            if (i > begin && candidates[i] == candidates[i - 1]) {  
                continue;  
            }  
            // 将当前数字添加到路径中  
            path.add(candidates[i]);  
            // 更新当前路径的数字和  
            sum += candidates[i];  
            // 递归调用，继续选择下一个数字，起始位置为i + 1（避免重复使用同一个数字）  
            backtracking(candidates, target, i + 1);  
            // 回溯，移除路径中最后添加的数字，尝试其他可能性  
            path.removeLast();  
            // 回溯，更新当前路径的数字和  
            sum -= candidates[i];  
        }  
    }  
}

22.括号生成 

22. 括号生成

中等

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

示例 1：

输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]

示例 2：

输入：n = 1
输出：["()"]

提示：

  • 1 <= n <= 8

先放置左括号的原因是为了确保生成的括号序列是有效的。

有效的括号序列满足以下条件之一：

  1. 左括号的数量等于右括号的数量。
  2. 在任何位置，左括号的数量都不应该小于右括号的数量。

因此，在生成括号序列时，我们首先考虑放置左括号的情况，然后再考虑放置右括号。具体来说：

  1. 如果当前放置的左括号数量小于总括号对数，则可以放置一个左括号。
  2. 如果当前放置的右括号数量小于左括号数量，则可以放置一个右括号。

通过这种方式，我们可以确保在生成括号序列时，每个位置都符合有效括号序列的条件，从而生成的所有括号序列都是有效的。

class Solution {

    StringBuilder cur = new StringBuilder(); // 用于构建当前正在生成的括号组合的StringBuilder

    List<String> ans = new LinkedList<>(); // 存储生成的括号组合的列表

    // 生成括号组合的方法，输入参数为括号对数目n
    public List<String> generateParenthesis(int n) {
        backtrack(0, 0, n); // 调用backtrack方法开始生成括号组合
        return ans; // 返回生成的括号组合列表
    }

    // 递归生成括号组合的方法，输入参数为已放置的左括号数量open、已放置的右括号数量close和总括号对数目max
    public void backtrack(int open, int close, int max) {
        // 当已放置的括号数量等于总括号对数目的两倍时，说明当前括号组合已经完成，将其添加到结果列表中
        if (cur.length() == max * 2) {
            ans.add(cur.toString());
            return;
        }
        // 如果已放置的左括号数量小于总括号对数目，可以继续放置左括号
        if (open < max) {
            cur.append('('); // 放置一个左括号
            backtrack(open + 1, close, max); // 递归调用backtrack方法，放置下一个括号
            cur.deleteCharAt(cur.length() - 1); // 回溯，删除刚刚放置的左括号
        }
        // 如果已放置的右括号数量小于已放置的左括号数量，可以继续放置右括号
        if (close < open) {
            cur.append(')'); // 放置一个右括号
            backtrack(open, close + 1, max); // 递归调用backtrack方法，放置下一个括号
            cur.deleteCharAt(cur.length() - 1); // 回溯，删除刚刚放置的右括号
        }
    }
}

 

XiaoMing_Coder
关注
  • 23
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
代码随想录-八股文 pdf
04-25
代码随想录-八股文 PDF 是一个涵盖了程序员学习必备的内容的知识星球精华，总结了包括 C++、Java、Go 在内的多种编程语言，数据结构和算法、操作系统、数据库、计算机网络、设计模式、Linux 等高频考点。该 PDF 由...
leetcode-master（代码随想录出品）-算法题资源
07-03
LeetCode 20060w50C++JavaPythonGoJavaScript
回溯算法解决组合问题抽象树形结构以及原理解析
fjf_666的博客
04-28 709
回溯算法解决组合问题抽象树形结构以及回溯原理去重原理解析
代码随想录-大厂八股文-面试
04-25
代码随想录的大厂八股文面试相关知识点非常广泛，包括了编程基础、算法设计、代码组织、问题解决等多方面的知识点。为了通过面试，考察者需要具备扎实的编程基础和实践经验，能够熟练掌握多种编程语言和技术，能够写...
代码随想录算法PDF.rar
08-06
《代码随想录》是一本深受程序员喜爱的算法学习书籍，尤其对于初学者来说，它提供了深入浅出的讲解和实战演练。这本书的核心是通过实际编程来帮助读者理解和掌握算法，提升编程技能，特别是C++语言的应用。在C++这个...
代码随想录算法PDF.zip
05-29
《代码随想录》是一本深受程序员喜爱的算法学习书籍，其PDF版本为读者提供了方便的电子阅读体验。这本书主要针对准备参加编程面试或者想要提升自己算法能力的开发者，通过实例解析和实战演练，帮助读者深入理解算法...
排序算法(4)之快速排序(1)
wer24_25的博客
07-17 1095
排序算法(4)之快速排序(1),快速排序的概念和快速排序的三种实现方式.
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 205
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 244
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
插入和选择排序
c23856的博客
07-20 291
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
算法刷题笔记 排列数字（C++实现）
hanmo22357的博客
07-17 278
一道简单的深度优先搜索（DFS）模板题，给出了DFS问题的一般思路以及C++代码实现
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 246
完全二叉树的节点个数-递归
python实现图像缩放算法
最新发布
qq_42568323的博客
07-20 273
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
(算法)区间调度问题
2202_75519246的博客
07-17 223
此外,参与工作的时间段不能重复(即使是开始的瞬间和结束的瞬间的重叠也是不允许的). 你的目标是参与尽王多的工作,那么最多能参与多少项工作呢?有n项工作,每项工作分别在s时间开始,在t时间结束. 对于每项工作,你都可以选择参与与否,如果选择了参与,那么自始至终都必须全程参与.
拆分整数 java
laocooon的博客
07-16 682
输入: n = 10输出: 36解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。输入: n = 2输出: 1解释: 2 = 1 + 1, 1 × 1 = 1。），并使这些整数的乘积最大化。你可以获得的最大乘积。
面试题 27. 二叉树的镜像
weixin_51332735的博客
07-16 478
请完成一个函数，输入一个二叉树，该函数输出它的镜像。
算法力扣刷题记录 五十【106.从中序与后序遍历序列构造二叉树】和【105.从前序与中序遍历序列构造二叉树】
danaaaa的博客
07-17 1072
构造二叉树
《算法笔记》总结No.8——双指针
前端，算法，MATLAB，统计学爱好者，目前主攻Web全栈+考研内容
07-17 1047
去年发表过较简单的双指针案例，建议先行阅读~C++实现双指针算法_c++ 双指针排序-CSDN博客文章浏览阅读154次。本贴介绍双指针的入门典例~_c++ 双指针排序https://jslhyh32.blog.csdn.net/article/details/129829790相比说双指针是一种算法，他更倾向是一种编程技巧，话不多说直接看一个引例：如下，给定递增序列【1,3,5,7,9】，寻找到两个相加为16的元素。如果使用暴力的思想，相当于是一个双层循环：外层下标i对应的A[i]和内层下标为j的A[j]之
前缀和算法——部分OJ题详解
aaqq800520的博客
07-17 982
（文章的题目解释可能存在一些问题，欢迎各位小伙伴私信或评论指点（双手合十））
《代码随想录知识星球-学习手册PDF：精华八股文，实用知识全覆盖》
《代码随想录-八股文 PDF》是一份全面总结了《代码随想录知识星球》的精华内容的PDF文件。该文件涵盖了几乎每位程序员在学习过程中必备的知识点。录友们在知识星球中的每日总结对于准备求职的程序员来说是必备的学习...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值