LeetCode - 刷题记录（13）

这次练习的是LeetCode上标签为列表为热题Top100、难度为中等的几道题目。题解有官方题解也有个人题解，有的地方意思可能表达得不是很清楚也可能存在错误，有问题请提出，感谢❤

1.每日温度

题目描述：
请根据每日 气温 列表，重新生成一个列表。对应位置的输出为：要想观测到更高的气温，至少需要等待的天数。如果气温在这之后都不会升高，请在该位置用 0 来代替。

例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。

提示：气温 列表长度的范围是 [1, 30000]。每个气温的值的均为华氏度，都是在 [30, 100] 范围内的整数。

题解：
一道可以用单调栈解的题目（当需要找一个数a左边或者右边比a大或者小的第一个数的时候，可以考虑用单调栈）

单调栈-顾名思义就是栈内元素单调按照递增(递减)顺序排列的栈。

class Solution {
    public int[] dailyTemperatures(int[] T) {
        int length = T.length;
        int[] ans = new int[length];
        Deque<Integer> stack = new LinkedList<Integer>(); // 单调栈 栈中存放数组索引
        for (int i = 0; i < length; i++) {
            int temperature = T[i];
            while (!stack.isEmpty() && temperature > T[stack.peek()]) {  // 当前元素比栈顶元素大时，栈顶元素需出栈，当前元素需入栈
                int index = stack.pop();
                ans[index] = i - index;
            }
            stack.push(i); // 元素索引入栈
        }
        return ans;
    }
}

2.组合总和

给定一个无重复元素的数组 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]
]

提示：

1 <= candidates.length <= 30
1 <= candidates[i] <= 200
candidate 中的每个元素都是独一无二的。
1 <= target <= 500

题解：
回溯思想

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Deque;
import java.util.List;

public class Solution {

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> res = new ArrayList<>();
        int len = candidates.length;

        // 排序为了在回溯算法进行中剪枝
        Arrays.sort(candidates);

        dfs(candidates, len, target, 0, new ArrayDeque<>(), res);
        return res;
    }

    /**
     * @param candidates 数组输入
     * @param len        输入数组的长度
     * @param residue    剩余数值
     * @param begin      本轮搜索的起点下标
     * @param path       从根结点到任意结点的路径
     * @param res        结果集变量
     */
    private void dfs(int[] candidates,
                     int len,
                     int residue,
                     int begin,
                     Deque<Integer> path,
                     List<List<Integer>> res) {
        if (residue == 0) {
            // 由于 path 全局只使用一份，到叶子结点的时候需要做一个拷贝
            res.add(new ArrayList<>(path));
            return;
        }

        for (int i = begin; i < len; i++) {

            // 在数组有序的前提下，剪枝
            if (residue - candidates[i] < 0) {
                break;
            }

            path.addLast(candidates[i]);
            dfs(candidates, len, residue - candidates[i], i, path, res);
            path.removeLast();

        }
    }
}

3.二叉树展开为链表

题目描述：
给定一个二叉树，原地将它展开为一个单链表。

例如，给定二叉树

1
/ \
2   5
/ \   \
3   4   6

将其展开为：

1
 \
  2
   \
    3
     \
      4
       \
        5
         \
          6

题解：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public void flatten(TreeNode root) {
        if (root == null) return;
        if (root.left != null) {
        	// 保存当前结点右结点
            TreeNode temp = root.right;
            TreeNode lastRight = findRight(root.left);
            // 置当前结点右结点为其左结点
            root.right = root.left;
            // 将原右结点置于原左结点的最右结点的右结点
            lastRight.right = temp;
            // 记得将每个结点的左结点置NULL
            root.left = null;
        }
        flatten(root.right);
    }

	// 找到当前结点的最右结点
    public TreeNode findRight(TreeNode root) {
        if (root.right == null) return root;
        return findRight(root.right);
        }
}