1
class Solution:
2
  def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
3
    groups = {}
4
    for s in strs:
5
      key = ''.join(sorted(s))
6
      if key in groups:
7
        groups[key].append(s)
8
      else:
9
        groups[key] = [s]
10
    return list(groups.values())

1
class Solution:
2
    def lengthOfLongestSubstring(self, s: str) -> int:
3
        char_dict = {}  # 存储字符最后一次出现的索引
4
        max_len = 0     # 记录最长子串的长度
5
        left = 0        # 滑动窗口的左指针
6

7
        for right in range(len(s)):
8
            current_char = s[right]
9

10
            # 如果当前字符已存在且在窗口内，则更新左指针
11
            if current_char in char_dict and char_dict[current_char] >= left:
12
                left = char_dict[current_char] + 1
13

14
            # 更新当前字符的位置
15
            char_dict[current_char] = right
16

17
            # 计算当前窗口长度并更新最大值
18
            current_len = right - left + 1
19
            if current_len > max_len:
20
                max_len = current_len
21

22
        return max_len

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
18
        // 如果root1为空，则直接返回root2，表示第一棵树已经被完全合并到第二棵树中
19
        if (root1 == null) {
20
            return root2;
21
        }
22
        // 如果root2为空，则直接返回root1，表示第二棵树已经被完全合并到第一棵树中
23
        if (root2 == null) {
24
            return root1;
25
        }
26
        // 创建一个新的节点，其值为root1和root2的值之和，然后递归合并左右子树
27
        return new TreeNode( root1.val + root2.val ,
28
                mergeTrees(root1.left,root2.left),
29
                mergeTrees(root1.right,root2.right));
30

31
    }
32
}

1
class Solution {
2
    public int[] nextGreaterElements(int[] nums) {
3

4
    // 数组长度
5
        int n = nums.length;
6
        // 结果数组，初始化为-1，表示没有下一个更大元素
7
        int[] result = new int[n];
8
        Arrays.fill(result, -1);
9
        // 使用栈来辅助寻找下一个更大元素
10
        Stack<Integer> stack = new Stack<>();
11

12
        // 遍历数组两次，以处理环形数组的特性
13
        for (int i = 0; i < 2 * n; i++) {
14
            // 当前遍历到的元素
15
            int num = nums[i % n];
16
            // 如果栈不为空且栈顶元素小于当前元素，则栈顶元素的下一个更大元素为当前元素
17
            while (!stack.isEmpty() && nums[stack.peek()] < num) {
18
                result[stack.pop()] = num;
19
            }
20
            // 如果当前遍历位置小于原数组长度，则将位置入栈，用于后续寻找下一个更大元素
21
            if (i < n) {
22
                stack.push(i);
23
            }
24
        }
25

26
        // 返回结果数组
27
        return result;
28
    }
29
}

1
class Solution {
2
    public boolean find132pattern(int[] nums) {
3
        if (nums == null || nums.length < 3) {
4
            return false;
5
        }
6

7
        Stack<Integer> stack = new Stack<>();
8
        int third = Integer.MIN_VALUE;
9

10
        // 从后往前遍历数组
11
        for (int i = nums.length - 1; i >= 0; i--) {
12
            if (nums[i] < third) {
13
                return true;
14
            }
15
            // 维护单调递减栈
16
            while (!stack.isEmpty() && nums[i] > stack.peek()) {
17
                third = stack.pop();
18
            }
19
            stack.push(nums[i]);
20
        }
21

22
        return false;
23
    }
24
}