LeetCode 面试题 01.02. 判定是否互为字符重排 01

三春去后诸芳尽

已于 2022-07-08 17:29:54 修改

阅读量3.5k

点赞数 8

分类专栏： LeetCode 文章标签： java 后端 leetcode 数据结构算法

于 2021-11-28 15:53:32 首次发布

本文链接：https://blog.csdn.net/qq_56884023/article/details/121592628

版权

LeetCode 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

本篇博客深入探讨了链表处理的各种高级技巧，包括如何合并零间节点、从链表中移除非零和序列、以及通过前缀和进行特定操作。同时，提供了详细算法实现，如利用哈希表优化查找过程、采用双指针技巧移动零，以及通过递归和迭代方法解决链表问题。

摘要由CSDN通过智能技术生成

599. 两个列表的最小索引总和

添加链接描述
假设 Andy 和 Doris 想在晚餐时选择一家餐厅，并且他们都有一个表示最喜爱餐厅的列表，每个餐厅的名字用字符串表示。

你需要帮助他们用最少的索引和找出他们共同喜爱的餐厅。如果答案不止一个，则输出所有答案并且不考虑顺序。你可以假设答案总是存在。

示例 1:
输入: list1 = [“Shogun”, “Tapioca Express”, “Burger King”, “KFC”]，list2 = [“Piatti”, “The Grill at Torrey Pines”, “Hungry Hunter Steakhouse”, “Shogun”]
输出: [“Shogun”]
解释: 他们唯一共同喜爱的餐厅是“Shogun”。

class Solution {
    public String[] findRestaurant(String[] list1, String[] list2) {
        Map<String, Integer> map = new HashMap<>();
        for (int i = 0; i < list1.length; i++) {
            map.put(list1[i], i);
        }
        int minIndexSum = Integer.MAX_VALUE;
        List<String> list = new ArrayList<>();
        for (int i = 0; i < list2.length; i++) {
            if(map.containsKey(list2[i])) {
                int j = map.get(list2[i]);
                if(i + j < minIndexSum) {
                    list.clear();
                    list.add(list2[i]);
                    minIndexSum = i + j;
                } else if (i + j == minIndexSum) {
                    list.add(list2[i]);
                }
            }
        }
        return list.toArray(new String[0]);
    }
}

2181. 合并零之间的节点

添加链接描述
给你一个链表的头节点 head ，该链表包含由 0 分隔开的一连串整数。链表的开端和末尾的节点都满足 Node.val == 0 。

对于每两个相邻的 0 ，请你将它们之间的所有节点合并成一个节点，其值是所有已合并节点的值之和。然后将所有 0 移除，修改后的链表不应该含有任何 0 。

返回修改后链表的头节点 head 。

示例 1：
在这里插入图片描述

输入：head = [0,3,1,0,4,5,2,0]
输出：[4,11]
解释：
上图表示输入的链表。修改后的链表包含：

标记为绿色的节点之和：3 + 1 = 4
标记为红色的节点之和：4 + 5 + 2 = 11

class Solution {
    public ListNode mergeNodes(ListNode head) {
        ListNode newHead = new ListNode(-1);
        ListNode tmp = newHead;

        ListNode cur = head;
        int val = 0;
        while(cur != null) {
            if(cur != head && cur.val == 0) { // 第一个头节点不加入
                tmp.next = new ListNode(val);
                tmp = tmp.next;
                val = 0; // 下一个
            } else {
                val += cur.val;
            }
            cur = cur.next;
        }

        return newHead.next;
    }
}

69. x 的平方根

添加链接描述
给你一个非负整数 x ，计算并返回 x 的算术平方根。

由于返回类型是整数，结果只保留整数部分，小数部分将被舍去。

注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

示例 1：
输入：x = 4
输出：2

class Solution {
    // 二分
    public int mySqrt(int x) {
        if(x == 1) return 1;
        int left = 1;
        int right = x / 2; //
        while(left <= right) {
            int mid = left + (right - left) / 2;
            if(x / mid > mid) { //不用x > mid * mid 防溢出
                left = mid + 1;
            } else if (x / mid < mid) {
                right = mid - 1;
            } else {
                return mid;
            }
        }
        return right; // -1->-1   0->1
    }
    
    // 2、根据平方数的性质——连续n个奇数相加的结果一定是平方数
    public int mySqrt2(int x) {
        if(x < 0) return 0;
        int i = 1;
        int ans = 0;
        while(x >= 0) {
            x -= i;
            i += 2;
            ans++;
        }
        return ans - 1;
    }

    public int mySqrt1(int x) {
        double mul = Math.sqrt(x);
        return (int)Math.floor(mul);
    }
}

917. 仅仅反转字母

添加链接描述
给你一个字符串 s ，根据下述规则反转字符串：

所有非英文字母保留在原有位置。
所有英文字母（小写或大写）位置反转。
返回反转后的 s 。

示例 1：
输入：s = “ab-cd”
输出：“dc-ba”

class Solution {
    public String reverseOnlyLetters(String s) {
        char[] ret = s.toCharArray();
        int left = 0;
        int right = ret.length - 1; // 
        while(left < right) {
            while(left < right && !Character.isLetter(ret[left])) {
                left++;
            }
            while(left < right && !Character.isLetter(ret[right])) {
                right--;
            }
            if(left < right) {
                char tmp = ret[left];
                ret[left] = ret[right];
                ret[right] = tmp;
            }
            left++; //
            right--; //
        }
        return new String(ret);
    }
}

剑指 Offer 54. 二叉搜索树的第k大节点

添加链接描述
给定一棵二叉搜索树，请找出其中第 k 大的节点的值。
示例 1:

输入: root = [3,1,4,null,2], k = 1
3
/
1 4

2
输出: 4

class Solution {
    // 中序遍历 保存的list中是从小到大排序的
    public void inorder(TreeNode root, List<Integer> list) {
        if(root == null) {
            return;
        }
        inorder(root.left, list);
        list.add(root.val);
        inorder(root.right, list);
    }

    public int kthLargest(TreeNode root, int k) {
        List<Integer> list = new ArrayList<>();
        inorder(root, list);
        return list.get(list.size() - k); // 获取
    }
}

496. 下一个更大元素 I

添加链接描述
nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置右侧的第一个比 x 大的元素。

给你两个没有重复元素的数组 nums1 和 nums2 ，下标从 0 开始计数，其中nums1 是 nums2 的子集。

对于每个 0 <= i < nums1.length ，找出满足 nums1[i] == nums2[j] 的下标 j ，并且在 nums2 确定 nums2[j] 的下一个更大元素。如果不存在下一个更大元素，那么本次查询的答案是 -1 。

返回一个长度为 nums1.length 的数组 ans 作为答案，满足 ans[i] 是如上所述的下一个更大元素。

示例 1：
输入：nums1 = [4,1,2], nums2 = [1,3,4,2].
输出：[-1,3,-1]
解释：nums1 中每个值的下一个更大元素如下所述：

4 ，用加粗斜体标识，nums2 = [1,3,4,2]。不存在下一个更大元素，所以答案是 -1 。
1 ，用加粗斜体标识，nums2 = [1,3,4,2]。下一个更大元素是 3 。
2 ，用加粗斜体标识，nums2 = [1,3,4,2]。不存在下一个更大元素，所以答案是 -1 。

class Solution {
    // 单调栈 + map
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        Deque<Integer> stack = new ArrayDeque<>(); // 从小到大
        Map<Integer, Integer> map = new HashMap<>(); // 记录映射关系
        for (int i = nums2.length - 1; i >= 0; i--) { // 从后往前 记录nums2中向左第一个最大值
            int num = nums2[i];
            while(!stack.isEmpty() && num >= stack.peek()) {
                stack.pop(); // 比栈顶大或等于 出栈 判断下一个
            }
            // 空-> 右边无比之大的数 存储-1    不为空 -> 存储
            map.put(num, stack.isEmpty() ? -1 : stack.peek());
            stack.push(num); // 入栈
        }
        int[] ans = new int[nums1.length];
        for (int i = 0; i < nums1.length; i++) {
            ans[i] = map.get(nums1[i]); // 数组元素不重复 通过map找到当前数据对应的第一个最大值
        }
        return ans;
    }
    
    // 暴力算法 O(n*m)
    // 找在nums2中的位置->j  往后找第一个大的k  判断是否<n  若存在加入数组
    public int[] nextGreaterElement1(int[] nums1, int[] nums2) {
        int m = nums1.length;
        int n = nums2.length;
        int[] ans = new int[m];
        for (int i = 0; i < m; i++) {
            int j = 0;
            while(j < n && nums2[j] != nums1[i]) {
                j++;
            }
            int k = j + 1;
            while(k < n && nums2[k] < nums1[i]) {
                k++;
            }
            ans[i] = k < n ? nums2[k] : -1;
        }
        return ans;
    }
}

1441. 用栈操作构建数组

添加链接描述
给你一个目标数组 target 和一个整数 n。每次迭代，需要从 list = {1,2,3…, n} 中依序读取一个数字。

请使用下述操作来构建目标数组 target ：

Push：从 list 中读取一个新元素，并将其推入数组中。
Pop：删除数组中的最后一个元素。
如果目标数组构建完成，就停止读取更多元素。
题目数据保证目标数组严格递增，并且只包含 1 到 n 之间的数字。

请返回构建目标数组所用的操作序列。

题目数据保证答案是唯一的。

示例 1：
输入：target = [1,3], n = 3
输出：[“Push”,“Push”,“Pop”,“Push”]
解释：
读取 1 并自动推入数组 -> [1]
读取 2 并自动推入数组，然后删除它 -> [1]
读取 3 并自动推入数组 -> [1,3]

class Solution {
    public List<String> buildArray(int[] target, int n) {
        List<String> list = new ArrayList<>();
        int index = 0;
        for(int j = 1; j <= n && index < target.length; j++) {
            if(j == target[index]) { // 一个匹配 到 下一个元素
                list.add("Push");
                index++;
            } else {
                list.add("Push");
                list.add("Pop");
            }
        }
        return list;
    }
}

328. 奇偶链表

添加链接描述
给定单链表的头节点 head ，将所有索引为奇数的节点和索引为偶数的节点分别组合在一起，然后返回重新排序的列表。

第一个节点的索引被认为是奇数，第二个节点的索引为偶数，以此类推。

请注意，偶数组和奇数组内部的相对顺序应该与输入时保持一致。

你必须在 O(1) 的额外空间复杂度和 O(n) 的时间复杂度下解决这个问题。

class Solution {
    // 分离节点后合并
    public ListNode oddEvenList(ListNode head) {
        if(head == null || head.next == null) {
            return head;
        }
        ListNode evenHead = head.next; // 连接单节点的尾
        
        ListNode odd = head; // 单数链表的头节点
        ListNode even = head.next; // 偶数链表的头节点
        while(even != null && even.next != null) {
            odd.next = even.next;
            odd = odd.next;

            even.next = odd.next;
            even = even.next;
        }
        odd.next = evenHead; // 
        return head;
    }
}

2. 两数相加

给你两个非空的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

class Solution {
    // 正确做法：与67题类似
    // https://leetcode-cn.com/problems/add-binary/
    // 由于输入的两个链表都是逆序存储数字的位数的，因此两个链表中同一位置的数字可以直接相加。
    // 我们同时遍历两个链表，逐位计算它们的和，并与当前位置的进位值相加。
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode newHead = new ListNode(-1);
        ListNode tmp = newHead;

        int carry = 0; // 进位
        while(l1 != null || l2 != null || carry != 0) {
            int val1 = l1 != null ? l1.val : 0;
            int val2 = l2 != null ? l2.val : 0;
            int val = val1 + val2 + carry; // 还需加入的总值
            carry = val / 10; // 如果是10，此次节点val为0，进位1

            tmp.next = new ListNode(val % 10);
            tmp = tmp.next; // 不要忘了往后走

            if(l1 != null) {
                l1 = l1.next;
            }
            if(l2 != null) {
                l2 = l2.next;
            }
        }

        return newHead.next;
    }



    // 修改为Long 还是有超出范围的情况
    public Long getSumOfVal(ListNode cur) {
        StringBuilder sb = new StringBuilder();
        while(cur != null) {
            sb.append(cur.val);
            cur = cur.next;
        }
        String str = sb.reverse().toString();
        return Long.valueOf(str);
    }

    public ListNode addTwoNumbers1(ListNode l1, ListNode l2) {
        Long num1 = getSumOfVal(l1);
        Long num2 = getSumOfVal(l2);
        Long sum = num1 + num2; // 两链表 val 之和
        // 逆置和
        String str = String.valueOf(sum);
        StringBuilder sb = new StringBuilder(str).reverse();

        ListNode newHead = new ListNode(-1);
        ListNode cur = newHead; // 连接每一个节点
        for (int i = 0; i < str.length(); i++) {
            ListNode node = new ListNode(sb.charAt(i) - '0');
            cur.next = node;
            cur = cur.next;
        }
        
        return newHead.next;
    }
}

67. 二进制求和

添加链接描述
给你两个二进制字符串，返回它们的和（用二进制表示）。
输入为非空字符串且只包含数字 1 和 0。

示例 1:
输入: a = “11”, b = “1”
输出: “100”

class Solution {
    public String addBinary(String a, String b) {
        int i = a.length() - 1;
        int j = b.length() - 1;
        StringBuilder sb = new StringBuilder();
        int carry = 0;
        while(i >= 0 || j >= 0 || carry != 0) { // 进位不为0
            int sum = carry;
            if(i >= 0) {
                sum += a.charAt(i--) - '0';
            }
            if(j >= 0) {
                sum += b.charAt(j--) - '0';
            }
            sb.append(sum % 2);
            carry = sum / 2;
        }
        /*if() { // 进位 不为0 放个位数
            sb.append(carry);
        }*/
        return sb.reverse().toString();
    }

    // 先将 a 和 b 转化成十进制数，求和后再转化为二进制数
    // 如果字符串超过 33 位，不能转化为 Integer
    // 如果字符串超过 65 位，不能转化为 Long
    // 如果字符串超过 500000001 位，不能转化为 BigInteger
    /*public String addBinary1(String a, String b) {
        return Integer.toBinaryString(
             Integer.parseInt(a, 2) + Integer.parseInt(b, 2)
        );
    }*/
}

1171. 从链表中删去总和值为零的连续节点

给你一个链表的头节点 head，请你编写代码，反复删去链表中由总和值为 0 的连续节点组成的序列，直到不存在这样的序列为止。

删除完毕后，请你返回最终结果链表的头节点。

你可以返回任何满足题目要求的答案。

（注意，下面示例中的所有序列，都是对 ListNode 对象序列化的表示。）

示例 1：
输入：head = [1,2,-3,3,1]
输出：[3,1]
提示：答案 [1,2,1] 也是正确的。

class Solution {
    // 前缀和
    public ListNode removeZeroSumSublists(ListNode head) {
        ListNode newHead = new ListNode(0);
        newHead.next = head;

        int sum = 0; // 和
        ListNode cur = newHead;
        Map<Integer, ListNode> map = new HashMap<>();
        // 首次遍历建立 节点处链表和<->节点 哈希表
        // 若同一和出现多次会覆盖，即记录该sum出现的最后一次节点
        while(cur != null) {
            sum += cur.val;
            map.put(sum, cur);
            cur = cur.next;
        }

        // 第二遍遍历 若当前节点处sum在下一处出现了则表明两结点之间所有节点和为0 直接删除区间所有节点
        //（从前面的一个sum处的节点指向后面的另一个sum处的节点的next）
        sum = 0;
        cur = newHead;
        while(cur != null) {
            sum += cur.val;
            cur.next = map.get(sum).next;
            cur = cur.next;
        }

        return newHead.next;
    }
}

717. 1比特与2比特字符

有两种特殊字符：
第一种字符可以用一个比特 0 来表示
第二种字符可以用两个比特(10 或 11)来表示、
给定一个以 0 结尾的二进制数组 bits ，如果最后一个字符必须是一位字符，则返回 true 。

示例 1:
输入: bits = [1, 0, 0]
输出: true
解释: 唯一的编码方式是一个两比特字符和一个一比特字符。
所以最后一个字符是一比特字符。

class Solution {
    public boolean isOneBitCharacter(int[] bits) {
        int start = 0;
        while(start < bits.length - 1) {
            if(bits[start] == 0) {
                start++;
            } else {
                start += 2;
            }
        }
        return start == bits.length - 1;
    }
}

1791. 找出星型图的中心节点

有一个无向的星型图，由 n 个编号从 1 到 n 的节点组成。星型图有一个中心节点，并且恰有 n - 1 条边将中心节点与其他每个节点连接起来。

给你一个二维整数数组 edges ，其中 edges[i] = [ui, vi] 表示在节点 ui 和 vi 之间存在一条边。请你找出并返回 edges 所表示星型图的中心节点。

class Solution {
    // 顶点数目为 N，中心顶点的度为 N-1
    public int findCenter(int[][] edges) {
        Map<Integer, Integer> map = new HashMap<>();
        for(int[] e : edges) {
            map.put(e[0], map.getOrDefault(e[0], 0) + 1);
            map.put(e[1], map.getOrDefault(e[1], 0) + 1);
        }
        int size = map.size();
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            if(entry.getValue() == size - 1) {
                return entry.getKey();
            }
        }
        /*for (int key : map.keySet()) {
            if(map.get(key) == size - 1) { // 根据k找v
                return key;
            }
        }*/
        return -1;
    }

    public int findCenter1(int[][] edges) {
        return edges[0][0] == edges[1][0] || edges[0][0] == edges[1][1] ? edges[0][0] : edges[0][1];
    }
}

1046. 最后一块石头的重量

添加链接描述
有一堆石头，每块石头的重量都是正整数。

每一回合，从中选出两块最重的石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。
最后，最多只会剩下一块石头。返回此石头的重量。如果没有石头剩下，就返回 0。

示例：
输入：[2,7,4,1,8,1]
输出：1
解释：
先选出 7 和 8，得到 1，所以数组转换为 [2,4,1,1,1]，
再选出 2 和 4，得到 2，所以数组转换为 [2,1,1,1]，
接着是 2 和 1，得到 1，所以数组转换为 [1,1,1]，
最后选出 1 和 1，得到 0，最终数组转换为 [1]，这就是最后剩下那块石头的重量。

class Solution {
    // 优先级队列
    public int lastStoneWeight(int[] stones) {
        // 大根堆
        PriorityQueue<Integer> pr = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        for (int n : stones) {
            pr.offer(n);
        }
        // 拿出两个 不相等y-x入队列
        while(pr.size() > 1) {
            int num1 = pr.poll();
            int num2 = pr.poll();
            if(num1 != num2) {
                pr.offer(num1 - num2);
            }
        }
        return pr.isEmpty() ? 0 : pr.poll();
    }

    // 排序
    public int lastStoneWeight1(int[] stones) {
        int n = stones.length;
        if(n <= 1) {
            return stones[0];
        }
        while(stones[n - 2] != 0) {
            Arrays.sort(stones);
            if(stones[n - 1] != stones[n - 2]) {
                stones[n - 1] = stones[n - 1] - stones[n - 2];
                stones[n - 2] = 0;
            } else {
                stones[n - 1] = 0;
                stones[n - 2] = 0;
            }
            Arrays.sort(stones); // stones[n - 2] != 0
        }
        return stones[n - 1];
    }
}

1380. 矩阵中的幸运数

添加链接描述
给你一个 m * n 的矩阵，矩阵中的数字各不相同。请你按任意顺序返回矩阵中的所有幸运数。

幸运数是指矩阵中满足同时下列两个条件的元素：

在同一行的所有元素中最小
在同一列的所有元素中最大

示例 1：
输入：matrix = [[3,7,8],[9,11,13],[15,16,17]]
输出：[15]
解释：15 是唯一的幸运数，因为它是其所在行中的最小值，也是所在列中的最大值。

class Solution {
    public List<Integer> luckyNumbers1 (int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        int[] minRow = new int[m]; // 第 i 行的最小值
        Arrays.fill(minRow, Integer.MAX_VALUE);
        int[] maxCol = new int[n]; // 第 j 列的最大值
        // 遍历   记录行最小值，列最大值
        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j++) {
                minRow[i] = Math.min(minRow[i], matrix[i][j]);
                maxCol[j] = Math.max(maxCol[j], matrix[i][j]);
            }
        }
        // 再次遍历 同时满足即为答案
        List<Integer> list = new ArrayList<>();
        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j++) {
                if(matrix[i][j] == minRow[i] && matrix[i][j] == maxCol[j]) {
                    list.add(matrix[i][j]);
                }
            }
        }
        return list;
    }


    // 遍历矩阵,判断 matrix[i][j] 是否是它所在行的最小值和所在列的最大值
    public List<Integer> luckyNumbers (int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        List<Integer> list = new ArrayList<>();
        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j++) {
                boolean isMin = true;
                boolean isMax = true;
                // 判断行最小值
                for (int k = 0; k < n; k++) {
                    if(matrix[i][k] < matrix[i][j]) {
                        isMin = false;
                        break;
                    }
                }
                if(!isMin) {
                    continue;
                }
                // 判断列最大值
                for (int k = 0; k < m; k++) {
                    if(matrix[k][j] > matrix[i][j]) {
                        isMax = false;
                        break;
                    }
                }
                if(isMax) {
                    list.add(matrix[i][j]);
                }
            }
        }
        return list;
    }
}

540. 有序数组中的单一元素

添加链接描述
给你一个仅由整数组成的有序数组，其中每个元素都会出现两次，唯有一个数只会出现一次。

请你找出并返回只出现一次的那个数。

你设计的解决方案必须满足 O(log n) 时间复杂度和 O(1) 空间复杂度。

示例 1:
输入: nums = [1,1,2,3,3,4,4,8,8]
输出: 2

class Solution {
    // O(logn) 二分查找
    public int singleNonDuplicate2(int[] nums) {
        int left = 0;
        int right = nums.length - 1;
        while (left < right) {
            int mid = (right - left) / 2 + left;
            if(mid % 2 == 0) { // 偶数
                if(nums[mid] == nums[mid + 1]) {
                    left = mid + 1;
                } else {
                    right = mid;
                }
            } else { // 奇数
                if(nums[mid] == nums[mid - 1]) {
                    left = mid + 1;
                } else {
                    right = mid;
                }
            }
        }
        return nums[right];
    }

    // 用异或来进行统一，因为 偶数异或1 等于 加1，奇数异或1 等于 减1
    public int singleNonDuplicate(int[] nums) {
        int left = 0;
        int right = nums.length - 1;
        while (left < right) {
            int mid = (right - left) / 2 + left;
            if(nums[mid] == nums[mid ^ 1]) {
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        return nums[right];
    }

    // O(n) 每两个遍历
    public int singleNonDuplicate1(int[] nums) {
        for(int i = 0; i < nums.length - 1; i += 2) {
            if(nums[i] != nums[i + 1]) {
                return nums[i];
            }
        }
        return nums[nums.length - 1];
    }
}

1189. “气球” 的最大数量

添加链接描述
给你一个字符串 text，你需要使用 text 中的字母来拼凑尽可能多的单词 “balloon”（气球）。
字符串 text 中的每个字母最多只能被使用一次。请你返回最多可以拼凑出多少个单词 “balloon”。

示例 1：
输入：text = “nlaebolko”
输出：1

class Solution {
    public int maxNumberOfBalloons(String text) {
        // 此单词每个字符次数
        int[] times = new int[5];
        for(int i = 0; i < text.length(); i++) {
            char ch = text.charAt(i);
            if(ch == 'b') {
                times[0]++;
            } else if (ch == 'a') {
                times[1]++;
            } else if (ch == 'l') {
                times[2]++;
            } else if (ch == 'o') {
                times[3]++;
            } else if(ch == 'n'){
                times[4]++;
            }
        }
        // 'l' 'o' 有两次
        times[2] /= 2;
        times[3] /= 2;
        
        int min = times[0];
        for (int i = 0; i < 5; i++) {
            min = Math.min(min, times[i]);
        }
        return min;
    }
}

面试题 01.02. 判定是否互为字符重排

添加链接描述
给定两个字符串 s1 和 s2，请编写一个程序，确定其中一个字符串的字符重新排列后，能否变成另一个字符串。

示例 1：
输入: s1 = “abc”, s2 = “bca”
输出: true

class Solution {
    // 3、哈希表
    public boolean CheckPermutation(String s1, String s2) {
        if(s1.length() != s2.length()) {
            return false;
        }
        HashMap<Character, Integer> map = new HashMap<>();
        // 如果相等，抵消为0
        for(int i = 0; i < s1.length(); i++) {
            map.put(s1.charAt(i), map.getOrDefault(s1.charAt(i), 0) + 1);
            map.put(s2.charAt(i), map.getOrDefault(s2.charAt(i), 0) - 1);
        }
        // 判断
        for(HashMap.Entry<Character, Integer> entry : map.entrySet()) {
            if(entry.getValue() != 0) {
                return false;
            }
        }
        return true;
    }


    // 2、数组统计次数
    public boolean CheckPermutation2(String s1, String s2) {
        if(s1.length() != s2.length()) {
            return false;
        }
        // 数组记录两字符串的字符次数、
        int[] cnts1 = cntLetters(s1);
        int[] cnts2 = cntLetters(s2);
        for(int i = 0; i < 26; i++) {
            if(cnts1[i] != cnts2[i]) {
                return false;
            }
        }
        return true;
    }

    public int[] cntLetters(String str) {
        int[] cnts = new int[26];
        for(int i = 0; i < str.length(); i++) {
            cnts[str.charAt(i) - 'a']++;
        }
        return cnts;
    }


    // 1、转字符数组 排序
    public boolean CheckPermutation1(String s1, String s2) {
        if(s1.length() != s2.length()) {
            return false;
        }
        char[] chars1 = s1.toCharArray();
        Arrays.sort(chars1);
        char[] chars2 = s2.toCharArray();
        Arrays.sort(chars2);
        // 字符串比较
        return new String(chars1).equals(new String(chars2));
    }
}

1984. 学生分数的最小差值

添加链接描述
给你一个下标从 0 开始的整数数组 nums ，其中 nums[i] 表示第 i 名学生的分数。另给你一个整数 k 。
从数组中选出任意 k 名学生的分数，使这 k 个分数间最高分和最低分的差值达到最小化。
返回可能的最小差值。

示例 1：
输入：nums = [90], k = 1
输出：0
解释：选出 1 名学生的分数，仅有 1 种方法：

[90] 最高分和最低分之间的差值是 90 - 90 = 0
可能的最小差值是 0

// 滑动窗口最右边的值就是窗口内的最大值，滑动窗口最左边的值就是窗口内的最小值
// 因此，我们要寻找的就是已经排序的数组中，所有大小为 k 的滑动窗口中，最右端数字 - 最左端数字 的最小结果
class Solution {
    public int minimumDifference(int[] nums, int k) {
        Arrays.sort(nums);
        int min = Integer.MAX_VALUE;
        for(int i = 0; i + k - 1 < nums.length; i++) {
            min = Math.min(min, nums[i + k - 1] - nums[i]);
        }
        return min;
    }

    // 滑动窗口：通过两个指针截取固定长度的数组
    public int minimumDifference1(int[] nums, int k) {
        //   先将数组进行排序
        Arrays.sort(nums);
        // 截取一定长度的数组
        int left=0;
        int right=k-1;
        // 创建一个变量保存最小的差值
        int min = Integer.MAX_VALUE;
        while(right < nums.length) {
              min = Math.min(min, nums[right] - nums[left]);
              left++;
              right = left + k - 1;
        }
        return min;
    }
}

1447. 最简分数

添加链接描述
给你一个整数 n ，请你返回所有 0 到 1 之间（不包括 0 和 1）满足分母小于等于 n 的最简分数。分数可以以任意顺序返回。

示例 1：
输入：n = 2
输出：[“1/2”]
解释：“1/2” 是唯一一个分母小于等于 2 的最简分数。

class Solution {
    // 更相减损法
    int gcd(int a, int b) {
        while(true) {
            if(a > b) {
                a -= b;
            } else if (a < b) {
                b -= a;
            } else {
                return a;
            }
        }
    }

    // 欧几里得算法
    int gcd1(int a, int b) {
        return b == 0 ? a : gcd(b, a % b);
        // int c = a % b;
        // while(c != 0) {
        //     a = b;
        //     b = c;
        //     c = a % b;
        // }
        // return b;
    }

    public List<String> simplifiedFractions(int n) {
        List<String> list = new ArrayList<>();
        for(int i = 1; i < n; i++) {
            for(int j = i + 1; j <= n; j++) {
                if(gcd(i, j) == 1) {
                    list.add(i + "/" + j);
                }
            }
        }
        return list;
    }
}

2006. 差的绝对值为 K 的数对数目

添加链接描述
给你一个整数数组 nums 和一个整数 k ，请你返回数对 (i, j) 的数目，满足 i < j 且 |nums[i] - nums[j]| == k 。
|x| 的值定义为：
如果 x >= 0 ，那么值为 x 。
如果 x < 0 ，那么值为 -x 。

示例 1：
输入：nums = [1,2,2,1], k = 1
输出：4
解释：差的绝对值为 1 的数对为：

[1,2,2,1]
[1,2,2,1]
[1,2,2,1]
[1,2,2,1]

class Solution {
    public int countKDifference(int[] nums, int k) {
        int ans = 0;
        HashMap<Integer, Integer> map = new HashMap<>();
        for(int n : nums) {
            ans += map.getOrDefault(n + k, 0) + map.getOrDefault(n - k, 0);
            map.put(n, map.getOrDefault(n, 0) + 1);
        }
        return ans;
    }

    public int countKDifference1(int[] nums, int k) {
        int ans = 0;
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if(nums[i] - nums[j] == k || nums[j] - nums[i] == k) {
                    ans++;
                }
            }
        }
        return ans;
    }
}

1748. 唯一元素的和

添加链接描述
给你一个整数数组 nums 。数组中唯一元素是那些只出现恰好一次的元素。
请你返回 nums 中唯一元素的和。

示例 1：
输入：nums = [1,2,3,2]
输出：4
解释：唯一元素为 [1,3] ，和为 4 。

class Solution {
    // 哈希表记录次数
    public int sumOfUnique1(int[] nums) {
        HashMap<Integer, Integer> map = new HashMap<>();
        for(int n : nums) {
            map.put(n, map.getOrDefault(n, 0) + 1);
        }
        int ans = 0;
        for(HashMap.Entry<Integer, Integer> entry : map.entrySet()) {
            if(entry.getValue() == 1) {
                ans += entry.getKey();
            }
        }
        return ans;
    }

    // 一次遍历  没有出现加起来 出现过就减 同时设为2
    public int sumOfUnique2(int[] nums) {
        HashMap<Integer, Integer> map = new HashMap<>();
        int ans = 0;
        for(int n : nums) {
            if(!map.containsKey(n)) {
                ans += n; // 没有此值
                map.put(n, 1); // 同时加入哈希表
            } else if(map.get(n) == 1) {
                ans -= n; // 出现过一次 表示加过了 需要减掉
                map.put(n, 2); // 同时设为2
            }
        }
        return ans;
    }

    // 数组
    public int sumOfUnique(int[] nums) {
        int[] cnts = new int[101];
        int ans = 0;
        for(int n : nums) {
            if(++cnts[n] == 1) {
                ans += n;
            } else if (cnts[n] == 2) {
                ans -= n;
            }
        }
        return ans;
    }
}

278. 第一个错误的版本

添加链接描述
你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。

假设你有 n 个版本 [1, 2, …, n]，你想找出导致之后所有版本出错的第一个错误的版本。

你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

示例 1：
输入：n = 5, bad = 4
输出：4
解释：
调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true
所以，4 是第一个错误的版本。

public class Solution extends VersionControl {
    public int firstBadVersion(int n) {
        int left = 1;
        int right = n;
        while(left < right) {
            int mid = left + ((right - left) >> 1);
            if(isBadVersion(mid)) {
                right = mid;  // 答案在区间 [left, mid] 中
            } else {
                left = mid + 1; // 答案在区间 [mid+1, right] 中
            }
        }
        return left;
    }
}

202. 快乐数

添加链接描述
编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」定义为：
对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。
如果这个过程结果为 1，那么这个数就是快乐数。
如果 n 是快乐数就返回 true ；不是，则返回 false 。

示例 1：
输入：n = 19
输出：true
解释：
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1

class Solution {
    // 1、用哈希集合检测循环
    /* 算法分为两部分，我们需要设计和编写代码：
    - 给一个数字 n，它的下一个数字是什么？
    - 按照一系列的数字来判断我们是否进入了一个循环。
       第 1 部分我们按照题目的要求做数位分离，求平方和。
       第 2 部分可以使用哈希集合完成。每次生成链中的下一个数字时，我们都会检查它是否已经在哈希集合中。
        如果它不在哈希集合中，我们应该添加它。
        如果它在哈希集合中，这意味着我们处于一个循环中，因此应该返回 false。*/

    public int getNextNum(int n) {
        int num = 0;
        while(n > 0) {
            num += Math.pow(n % 10, 2);
            n /= 10;
        }
        return num;
    }

    public boolean isHappy1(int n) {
        Set<Integer> set = new HashSet<>();
        while(n != 1 && !set.contains(n)) {
            set.add(n);
            n = getNextNum(n);
        }
        return n == 1;
    }

    // 2、快慢指针法判断是否有环  龟兔赛跑
    public boolean isHappy(int n) {
        int slow = n;
        int fast = getNextNum(n);
        while(fast != 1 && slow != fast) {
            slow = getNextNum(slow);
            fast = getNextNum(getNextNum(fast));
        }
        return fast == 1;
    }
}

1816. 截断句子

添加链接描述
句子是一个单词列表，列表中的单词之间用单个空格隔开，且不存在前导或尾随空格。每个单词仅由大小写英文字母组成（不含标点符号）。

例如，“Hello World”、“HELLO” 和 “hello world hello world” 都是句子。
给你一个句子 s 和一个整数 k ，请你将 s 截断，使截断后的句子仅含前 k 个单词。返回截断 s 后得到的句子。

示例 1：
输入：s = “Hello how are you Contestant”, k = 4
输出：“Hello how are you”
解释：
s 中的单词为 [“Hello”, “how” “are”, “you”, “Contestant”]
前 4 个单词为 [“Hello”, “how”, “are”, “you”]
因此，应当返回 “Hello how are you”

class Solution {
    public String truncateSentence(String s, int k) {
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < s.length(); i++) {
            if(s.charAt(i) == ' ') {
                k--;
            }
            if(k == 0) {
                break;
            }

            sb.append(s.charAt(i));
        }
        return sb.toString();
    }
}

1725. 可以形成最大正方形的矩形数目

添加链接描述
给你一个数组 rectangles ，其中 rectangles[i] = [li, wi] 表示第 i 个矩形的长度为 li 、宽度为 wi 。

如果存在 k 同时满足 k <= li 和 k <= wi ，就可以将第 i 个矩形切成边长为 k 的正方形。例如，矩形 [4,6] 可以切成边长最大为 4 的正方形。

设 maxLen 为可以从矩形数组 rectangles 切分得到的最大正方形的边长。

请你统计有多少个矩形能够切出边长为 maxLen 的正方形，并返回矩形数目。

示例 1：
输入：rectangles = [[5,8],[3,9],[5,12],[16,5]]
输出：3
解释：能从每个矩形中切出的最大正方形边长分别是 [5,3,5,5] 。
最大正方形的边长为 5 ，可以由 3 个矩形切分得到。

class Solution {
    public int countGoodRectangles(int[][] rectangles) {
        int maxLen = 0; // maxLen
        int cnt = 0;
        for(int x[] : rectangles) {
            int min = Math.min(x[0], x[1]); // 每组中的最小边长

            if(min > maxLen) {
                cnt = 1; // 更新最大边长数
            }
            if(min == maxLen) {
                cnt++;
            }
            
            maxLen = Math.max(min, maxLen);
        }
        return cnt;
    }
}

1414. 和为 K 的最少斐波那契数字数目

添加链接描述
给你数字 k ，请你返回和为 k 的斐波那契数字的最少数目，其中，每个斐波那契数字都可以被使用多次。

斐波那契数字定义为：
F1 = 1
F2 = 1
Fn = Fn-1 + Fn-2 ，其中 n > 2 。
数据保证对于给定的 k ，一定能找到可行解。

示例 1：
输入：k = 7
输出：2
解释：斐波那契数字为：1，1，2，3，5，8，13，……
对于 k = 7 ，我们可以得到 2 + 5 = 7 。

class Solution {
    // 获取1-k的数列  从大到小找
    public int findMinFibonacciNumbers(int k) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        int f1 = 1;
        int f2 = 1;
        while (f1 + f2 <= k) {
            int f3 = f1 + f2;
            list.add(f3);
            f1 = f2;
            f2 = f3;
        }

        int ans = 0;
        for (int i = list.size() - 1; i >= 0 && k > 0; i--) {
            int num = list.get(i);
            
            // ans += k / num;
            // k %= num;

            // 斐波那契数字为：1，1，2，3，5，8，13
            // k = 19
            // 输出：3 
            // 解释：对于 k = 19 ，我们可以得到 1 + 5 + 13 = 19
            if(k >= num) {
                k -= num;
                ans++;
            }
        }
        return ans;
    }
}

LeetCode 面试题 01.02. 判定是否互为字符重排 01

599. 两个列表的最小索引总和

2181. 合并零之间的节点

69. x 的平方根

917. 仅仅反转字母

剑指 Offer 54. 二叉搜索树的第k大节点

496. 下一个更大元素 I

1441. 用栈操作构建数组

328. 奇偶链表

2. 两数相加

67. 二进制求和

1171. 从链表中删去总和值为零的连续节点

717. 1比特与2比特字符

1791. 找出星型图的中心节点

1046. 最后一块石头的重量

1380. 矩阵中的幸运数

540. 有序数组中的单一元素

1189. “气球” 的最大数量

面试题 01.02. 判定是否互为字符重排

1984. 学生分数的最小差值

1447. 最简分数

2006. 差的绝对值为 K 的数对数目

1748. 唯一元素的和

278. 第一个错误的版本

202. 快乐数

1816. 截断句子

1725. 可以形成最大正方形的矩形数目

1414. 和为 K 的最少斐波那契数字数目

1688. 比赛中的配对次数

884. 两句话中的不常见单词

1332. 删除回文子序列

1512. 好数对的数目

617. 合并二叉树

844. 比较含退格的字符串

933. 最近的请求次数

682. 棒球比赛

1716. 计算力扣银行的钱

747. 至少是其他数字两倍的最大数

334. 递增的三元子序列

1920. 基于排列构建数组

1629. 按键持续时间最长的键

89. 格雷编码

976. 三角形的最大周长

495. 提莫攻击

剑指 Offer 61. 扑克牌中的顺子

1646. 获取生成数组中的最大值

1614. 括号的最大嵌套深度

119. 杨辉三角 II

1576. 替换所有的问号

1185. 一周中的第几天

930. 和相同的二元子数组

390. 消除游戏

461. 汉明距离

405. 数字转换为十六进制数

2022. 将一维数组转变成二维数组

1160. 拼写单词

1995. 统计特殊四元组

290. 单词规律

242. 有效的字母异位词

167. 两数之和 II - 输入有序数组

125. 验证回文串

229. 求众数 II

169. 多数元素

260. 只出现一次的数字 III

136. 只出现一次的数字

58. 最后一个单词的长度

13. 罗马数字转整数

448. 找到所有数组中消失的数字

88. 合并两个有序数组

80. 删除有序数组中的重复项 II

441. 排列硬币

434. 字符串中的单词数

415. 字符串相加

1154. 一年中的第几天

414. 第三大的数

412. Fizz Buzz

389. 找不同

387. 字符串中的第一个唯一字符

383. 赎金信

374. 猜数字大小