【每日力扣】108. 将有序数组转换为二叉搜索树与78. 子集

🔥 个人主页: 黑洞晓威
😀你不必等到非常厉害，才敢开始，你需要开始，才会变的非常厉害。

108. 将有序数组转换为二叉搜索树

给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵

平衡二叉搜索树。

思路

1. 中序遍历思想：对于已排序的数组，我们可以利用中序遍历的方式构建平衡二叉搜索树。具体方法是选择数组中间的元素作为根节点，然后递归地将左半部分和右半部分的数组分别作为左子树和右子树构建平衡BST。
2. 二分思想：利用二分法的思想，选择数组的中间元素作为根节点，然后递归地构建左子树和右子树，保证树的高度平衡。

代码

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int val) {
        this.val = val;
    }
}

public class SortedArrayToBST {

    public TreeNode sortedArrayToBST(int[] nums) {
        if (nums == null || nums.length == 0) {
            return null;
        }
        return buildBST(nums, 0, nums.length - 1);
    }

    private TreeNode buildBST(int[] nums, int left, int right) {
        if (left > right) {
            return null;
        }
        int mid = left + (right - left) / 2;
        TreeNode root = new TreeNode(nums[mid]);
        root.left = buildBST(nums, left, mid - 1);
        root.right = buildBST(nums, mid + 1, right);
        return root;
    }

    public static void main(String[] args) {
        int[] nums = {-10, -3, 0, 5, 9};

        SortedArrayToBST solution = new SortedArrayToBST();
        TreeNode result = solution.sortedArrayToBST(nums);
        // 输出结果
        System.out.println(result);
    }
}

78. 子集

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的

子集（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

示例 2：

输入：nums = [0]
输出：[[],[0]]

解题思路

递归法：递归地生成子集，每次递归的过程中，可以选择当前元素加入子集或者不加入子集，然后继续递归处理下一个元素。

代码

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

public class Subsets {

    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        generateSubsets(nums, 0, new ArrayList<>(), result);
        return result;
    }

    private void generateSubsets(int[] nums, int index, List<Integer> subset, List<List<Integer>> result) {
        if (index == nums.length) {
            result.add(new ArrayList<>(subset));
            return;
        }
        subset.add(nums[index]);
        generateSubsets(nums, index + 1, subset, result);
        subset.remove(subset.size() - 1);
        generateSubsets(nums, index + 1, subset, result);
    }

    public static void main(String[] args) {
        int[] nums = {1, 2, 3};
        Subsets solution = new Subsets();
        List<List<Integer>> result = solution.subsets(nums);
        System.out.println(result);
    }
}