力扣 (LeetCode) 剑指 Offer（第 2 版）刷题(java)合集-05

最新推荐文章于 2024-08-15 14:47:41 发布
最新推荐文章于 2024-08-15 14:47:41 发布
阅读量238 收藏
点赞数
分类专栏： 力扣 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42628903/article/details/119723306
版权
剑指 Offer 53 - I. 在排序数组中查找数字 I

难度简单145

统计一个数字在排序数组中出现的次数。

示例 1:

输入: nums = [5,7,7,8,8,10], target = 8
输出: 2

示例 2:

输入: nums = [5,7,7,8,8,10], target = 6
输出: 0

限制：

0 <= 数组长度 <= 50000

class Solution {
    public int search(int[] nums, int target) {
        // 搜索右边界 right
        int i = 0, j = nums.length - 1;
        while(i <= j) {
            int m = (i + j) / 2;
            if(nums[m] <= target) i = m + 1;
            else j = m - 1;
        }
        int right = i;
        // 若数组中无 target ，则提前返回
        if(j >= 0 && nums[j] != target) return 0;
        // 搜索左边界 right
        i = 0; j = nums.length - 1;
        while(i <= j) {
            int m = (i + j) / 2;
            if(nums[m] < target) i = m + 1;
            else j = m - 1;
        }
        int left = j;
        return right - left - 1;
    }
}

class Solution {
    public int search(int[] nums, int target) {
        return helper(nums, target) - helper(nums, target - 1);
    }
    int helper(int[] nums, int tar) {
        int i = 0, j = nums.length - 1;
        while(i <= j) {
            int m = (i + j) / 2;
            if(nums[m] <= tar) i = m + 1;
            else j = m - 1;
        }
        return i;
    }
}
剑指 Offer 53 - II. 0～n-1中缺失的数字

难度简单149

一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。

示例 1:

输入: [0,1,3]
输出: 2

示例 2:

输入: [0,1,2,3,4,5,6,7,9]
输出: 8

限制：

1 <= 数组长度 <= 10000

Picture1.png

class Solution {
    public int missingNumber(int[] nums) {
        int i = 0, j = nums.length - 1;
        while(i <= j) {
            int m = (i + j) / 2;
            if(nums[m] == m) i = m + 1;
            else j = m - 1;
        }
        return i;
    }
}
剑指 Offer 54. 二叉搜索树的第k大节点

难度简单170

给定一棵二叉搜索树，请找出其中第k大的节点。

示例 1:

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

示例 2:

输入: root = [5,3,6,2,4,null,null,1], k = 3
       5
      / \
     3   6
    / \
   2   4
  /
 1
输出: 4

限制：
1 ≤ k ≤ 二叉搜索树元素个数

后序遍历

class Solution {
​     public int kthLargest(TreeNode root, int k) {
​    if (root==null)
​      return 0;
​    dfs(root);
​    return arrayList.get(k-1);
  	}
  ArrayList<Integer> arrayList=new ArrayList<>();
  public void dfs(TreeNode root){
​    if (root!=null&&root.left==null&&root.right==null){
​      arrayList.add(root.val);
​      return;
​    }
​    if (root.right!=null)
​    dfs(root.right);
​    arrayList.add(root.val);
​    if (root.left!=null)
​    dfs(root.left);
  }
}

参考别人的代码，优化之后的，遍历到k就return了

 int count=0, res=0;//形参k不能随着dfs的迭代而不断变化，为了记录迭代进程和结果，引入类变量count和res。
    public int kthLargest(TreeNode root, int k) {
        this.count=k;//利用形参值k对类变量count进行初始化
        dfs(root);//这里不要引入形参k，dfs中直接使用的是初始值为k的类变量count
        return res;            
    }
    public void dfs(TreeNode root){
        if(root==null||count==0) return;//当root为空或者已经找到了res时，直接返回
        dfs(root.right);
        if(--count==0){//先--，再判断
            res = root.val;
            return;//这里的return可以避免之后的无效迭代dfs(root.left);
        }
        dfs(root.left);  
    }
剑指 Offer 55 - I. 二叉树的深度

难度简单124

输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。

例如：

给定二叉树 [3,9,20,null,null,15,7]，

    3
   / \
  9  20
    /  \
   15   7

返回它的最大深度 3 。

提示：

  1. 节点总数 <= 10000
  • 关键点： 此树的深度和其左（右）子树的深度之间的关系。显然，此树的深度 等于 左子树的深度 与 右子树的深度 中的 最大值 +1 。
class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null) return 0;
        return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
    }
}

//方法二：层序遍历（BFS）
//树的层序遍历 / 广度优先搜索往往利用 队列 实现。
//关键点： 每遍历一层，则计数器 +1，直到遍历完成，则可得到树的深度。

class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null) return 0;
        List<TreeNode> queue = new LinkedList<>() {{ add(root); }}, tmp;
        int res = 0;
        while(!queue.isEmpty()) {
            tmp = new LinkedList<>();
            for(TreeNode node : queue) {
                if(node.left != null) tmp.add(node.left);
                if(node.right != null) tmp.add(node.right);
            }
            queue = tmp;
            res++;
        }
        return res;
    }
}
剑指 Offer 55 - II. 平衡二叉树

难度简单166

输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。

示例 1:

给定二叉树 [3,9,20,null,null,15,7]

    3
   / \
  9  20
    /  \
   15   7

返回 true 。

示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]

       1
      / \
     2   2
    / \
   3   3
  / \
 4   4

返回 false 。

限制：

  • 0 <= 树的结点个数 <= 10000

方法一：后序遍历 + 剪枝 （从底至顶）
此方法为本题的最优解法，但剪枝的方法不易第一时间想到。

思路是对二叉树做后序遍历，从底至顶返回子树深度，若判定某子树不是平衡树则 “剪枝” ，直接向上返回。

算法流程：
recur(root) 函数：

返回值：
当节点root 左 / 右子树的深度差 ≤1 ：则返回当前子树的深度，即节点 root 的左 / 右子树的深度最大值 +1 （ max(left, right) + 1 ）；
当节点root 左 / 右子树的深度差 >2 ：则返回 -1 ，代表 此子树不是平衡树 。
终止条件：
当 root 为空：说明越过叶节点，因此返回高度 0 ；
当左（右）子树深度为 -1 ：代表此树的 左（右）子树 不是平衡树，因此剪枝，直接返回 -1 ；

class Solution {
    public boolean isBalanced(TreeNode root) {
        return recur(root) != -1;
    }

    private int recur(TreeNode root) {
        if (root == null) return 0;
        int left = recur(root.left);
        if(left == -1) return -1;
        int right = recur(root.right);
        if(right == -1) return -1;
        return Math.abs(left - right) < 2 ? Math.max(left, right) + 1 : -1;
    }

}
方法二：先序遍历 + 判断深度 （从顶至底）

此方法容易想到，但会产生大量重复计算，时间复杂度较高。

思路是构造一个获取当前子树的深度的函数 depth(root) （即 面试题55 - I. 二叉树的深度 ），通过比较某子树的左右子树的深度差 abs(depth(root.left) - depth(root.right)) <= 1 是否成立，来判断某子树是否是二叉平衡树。若所有子树都平衡，则此树平衡。

class Solution {
    public boolean isBalanced(TreeNode root) {
        if (root == null) return true;
        return Math.abs(depth(root.left) - depth(root.right)) <= 1 && isBalanced(root.left) && isBalanced(root.right);
    }

    private int depth(TreeNode root) {
        if (root == null) return 0;
        return Math.max(depth(root.left), depth(root.right)) + 1;
    }

}
剑指 Offer 56 - I. 数组中数字出现的次数

难度中等412

一个整型数组 nums 里除两个数字之外，其他数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。

示例 1：

输入：nums = [4,1,4,6]
输出：[1,6] 或 [6,1]

示例 2：

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

题目要求时间复杂度 O(N)，空间复杂度 O(1)，因此首先排除 暴力法 和 哈希表统计法 。

class Solution {
    public int[] singleNumbers(int[] nums) {
        int x = 0, y = 0, n = 0, m = 1;
        for(int num : nums)               // 1. 遍历异或
            n ^= num;
        while((n & m) == 0)               // 2. 循环左移，计算 m
            m <<= 1;
        for(int num: nums) {              // 3. 遍历 nums 分组
            if((num & m) != 0) x ^= num;  // 4. 当 num & m != 0
            else y ^= num;                // 4. 当 num & m == 0
        }
        return new int[] {x, y};          // 5. 返回出现一次的数字
    }
}
剑指 Offer 56 - II. 数组中数字出现的次数 II

难度中等193

在一个数组 nums 中除一个数字只出现一次之外，其他数字都出现了三次。请找出那个只出现一次的数字。

示例 1：

输入：nums = [3,4,3,3]
输出：4

示例 2：

输入：nums = [9,1,7,9,7,9,7]
输出：1

限制：

  • 1 <= nums.length <= 10000
  • 1 <= nums[i] < 2^31

如下图所示，考虑数字的二进制形式，对于出现三次的数字，各 二进制位 出现的次数都是 3 的倍数。
因此，统计所有数字的各二进制位中 1 的出现次数，并对 3 求余，结果则为只出现一次的数字。

Picture1.png

class Solution {
    public int singleNumber(int[] nums) {
        int[] counts = new int[32];
        for(int num : nums) {
            for(int j = 0; j < 32; j++) {
                counts[j] += num & 1;
                num >>>= 1;
            }
        }
        int res = 0, m = 3;
        for(int i = 0; i < 32; i++) {
            res <<= 1;
            res |= counts[31 - i] % m;
        }
        return res;
    }
}
剑指 Offer 57. 和为s的两个数字

难度简单116

输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。如果有多对数字的和等于s，则输出任意一对即可。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[2,7] 或者 [7,2]

示例 2：

输入：nums = [10,26,30,31,47,60], target = 40
输出：[10,30] 或者 [30,10]

限制：

  • 1 <= nums.length <= 10^5
  • 1 <= nums[i] <= 10^6
解题思路：

利用 HashMap 可以通过遍历数组找到数字组合，时间和空间复杂度均为 O(N) ；
注意本题的 nums是 排序数组 ，因此可使用 双指针法 将空间复杂度降低至 O(1) 。

算法流程：

  1. 初始化： 双指针 i, j 分别指向数组 nums的左右两端 （俗称对撞双指针）。

  2. 循环搜索：

    当双指针相遇时跳出；

    1. 计算和 s = nums[i] + nums[j]；
    2. 若 s > target，则指针 j 向左移动，即执行 j = j - 1；
    3. 若 s < target ，则指针 i 向右移动，即执行 i = i + 1；
    4. 若 s = target ，立即返回数组 [nums[i], nums[j]][num**s[i]；

  3. 返回空数组，代表无和为 target的数字组合。

Picture1.png

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int i = 0, j = nums.length - 1;
        while(i < j) {
            int s = nums[i] + nums[j];
            if(s < target) i++;
            else if(s > target) j--;
            else return new int[] { nums[i], nums[j] };
        } 
        return new int[0];
    }
}
剑指 Offer 57 - II. 和为s的连续正数序列

难度简单282

输入一个正整数 target ，输出所有和为 target 的连续正整数序列（至少含有两个数）。

序列内的数字由小到大排列，不同序列按照首个数字从小到大排列。

示例 1：

输入：target = 9
输出：[[2,3,4],[4,5]]

示例 2：

输入：target = 15
输出：[[1,2,3,4,5],[4,5,6],[7,8]]

限制：

  • 1 <= target <= 10^5
方法二：滑动窗口（双指针）

设连续正整数序列的左边界 i 和右边界 j ，则可构建滑动窗口从左向右滑动。循环中，每轮判断滑动窗口内元素和与目标值 target 的大小关系，若相等则记录结果，若大于 target 则移动左边界 i （以减小窗口内的元素和），若小于 target则移动右边界 j （以增大窗口内的元素和）。

算法流程：
  1. 初始化： 左边界 i = 1，右边界 j = 2，元素和 s = 3 ，结果列表 res；
  2. 循环： 当i≥j 时跳出；
    • 当 s > target时： 向右移动左边界 i = i + 1，并更新元素和 s ；
    • 当 s < target时： 向右移动右边界 j = j + 1，并更新元素和 s ；
    • 当 s = target时： 记录连续整数序列，并向右移动左边界 i = i + 1；
  3. 返回值： 返回结果列表 res；
    Picture2.png
class Solution {
    public int[][] findContinuousSequence(int target) {
        int i = 1, j = 2, s = 3;
        List<int[]> res = new ArrayList<>();
        while(i < j) {
            if(s == target) {
                int[] ans = new int[j - i + 1];
                for(int k = i; k <= j; k++)
                    ans[k - i] = k;
                res.add(ans);
            }
            if(s >= target) {
                s -= i;
                i++;
            } else {
                j++;
                s += j;
            }
        }
        return res.toArray(new int[0][]);
    }
}
  • ！！！！！！
  • 如果向左扩展窗口：比如 target 为10 ,以 1,2,3,4,5,6 为例，初始窗口[1,2] sum = 3 < target，首先此时窗口左边没有元素，无法扩展。 即使使用条件判断避免首次向左扩展，假设窗口能走到[1,2,3,4]，此时sum == 10，满足条件， 然后更新窗口为[2,3,4]，计算sum = 9 <target; 如果向左扩展，则又变为[1,2,3,4] 存在以下问题： 1. 该结果已经运算过了，会造成重复运算 2. 死循环，[1.2,3,4]计算过又变为[2,3,4]，继续向左扩展会变成死循环。
剑指 Offer 58 - I. 翻转单词顺序

难度简单109

输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。为简单起见，标点符号和普通字母一样处理。例如输入字符串"I am a student. “，则输出"student. a am I”。

示例 1：

输入: "the sky is blue"
输出: "blue is sky the"

示例 2：

输入: "  hello world!  "
输出: "world! hello"
解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。

示例 3：

输入: "a good   example"
输出: "example good a"
解释: 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

说明：

  • 无空格字符构成一个单词。
  • 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
  • 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。
方法一：双指针
算法解析：
  • 倒序遍历字符串 s，记录单词左右索引边界 i, j；
  • 每确定一个单词的边界，则将其添加至单词列表 res；
  • 最终，将单词列表拼接为字符串，并返回即可。
class Solution {
    public String reverseWords(String s) {
        s = s.trim(); // 删除首尾空格
        int j = s.length() - 1, i = j;
        StringBuilder res = new StringBuilder();
        while(i >= 0) {
            while(i >= 0 && s.charAt(i) != ' ') i--; // 搜索首个空格
            res.append(s.substring(i + 1, j + 1) + " "); // 添加单词
            while(i >= 0 && s.charAt(i) == ' ') i--; // 跳过单词间空格
            j = i; // j 指向下个单词的尾字符
        }
        return res.toString().trim(); // 转化为字符串并返回
    }
}
方法二：分割 + 倒序

利用 “字符串分割”、“列表倒序” 的内置函数 （面试时不建议使用） ，可简便地实现本题的字符串翻转要求。

算法解析：
  • Python ： 由于 split()方法将单词间的 “多个空格看作一个空格” （参考自 split()和split(’ ')的区别 ），因此不会出现多余的 “空单词” 。因此，直接利用 reverse()方法翻转单词列表 strs** ，拼接为字符串并返回即可。

Picture0.png

class Solution {
    public String reverseWords(String s) {
        String[] strs = s.trim().split(" "); // 删除首尾空格，分割字符串
        StringBuilder res = new StringBuilder();
        for(int i = strs.length - 1; i >= 0; i--) { // 倒序遍历单词列表
            if(strs[i].equals("")) continue; // 遇到空单词则跳过
            res.append(strs[i] + " "); // 将单词拼接至 StringBuilder
        }
        return res.toString().trim(); // 转化为字符串，删除尾部空格，并返回
    }
}
方法二：分割 + 倒序

利用 “字符串分割”、“列表倒序” 的内置函数 （面试时不建议使用） ，可简便地实现本题的字符串翻转要求。

算法解析：
  • Python ： 由于 split()方法将单词间的 “多个空格看作一个空格” （参考自 split()和split(’ ')的区别 ），因此不会出现多余的 “空单词” 。因此，直接利用 reverse()方法翻转单词列表 strs** ，拼接为字符串并返回即可。

Picture0.png

class Solution {
    public String reverseWords(String s) {
        String[] strs = s.trim().split(" "); // 删除首尾空格，分割字符串
        StringBuilder res = new StringBuilder();
        for(int i = strs.length - 1; i >= 0; i--) { // 倒序遍历单词列表
            if(strs[i].equals("")) continue; // 遇到空单词则跳过
            res.append(strs[i] + " "); // 将单词拼接至 StringBuilder
        }
        return res.toString().trim(); // 转化为字符串，删除尾部空格，并返回
    }
}
剑指 Offer 58 - II. 左旋转字符串

难度简单129

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。

示例 1：

输入: s = "abcdefg", k = 2
输出: "cdefgab"

示例 2：

输入: s = "lrloseumgh", k = 6
输出: "umghlrlose"

限制：

  • `1 <= k < s.length <= 10000
方法一：字符串切片

应用字符串切片函数，可方便实现左旋转字符串。

获取字符串 s[n:]切片和 s[:n]切片，使用 “+” 运算符拼接并返回即可。

复杂度分析：
  • 时间复杂度 O(N)： 其中 N 为字符串 s 的长度，字符串切片函数为线性时间复杂度（参考资料）；
  • 空间复杂度 O(N) ： 两个字符串切片的总长度为 N 。
class Solution {
    public String reverseLeftWords(String s, int n) {
        return s.substring(n, s.length()) + s.substring(0, n);
    }
}
方法二：列表遍历拼接

若面试规定不允许使用 切片函数 ，则使用此方法。

算法流程：
  1. 新建一个 list(Python)、StringBuilder(Java) ，记为 res；
  2. 先向 res添加 “第 n + 1位至末位的字符” ；
  3. 再向 res添加 “首位至第 n位的字符” ；
  4. 将 res转化为字符串并返回。
复杂度分析：
  • 时间复杂度 O(N)\： 线性遍历 s 并添加，使用线性时间；
  • 空间复杂度 O(N) ： 新建的辅助 res使用 O(N) 大小的额外空间。
    Picture2.png
class Solution {
    public String reverseLeftWords(String s, int n) {
        StringBuilder res = new StringBuilder();
        for(int i = n; i < s.length(); i++)
            res.append(s.charAt(i));
        for(int i = 0; i < n; i++)
            res.append(s.charAt(i));
        return res.toString();
    }
}
方法三：字符串遍历拼接
class Solution {
    public String reverseLeftWords(String s, int n) {
        String res = "";
        for(int i = n; i < s.length(); i++)
            res += s.charAt(i);
        for(int i = 0; i < n; i++)
            res += s.charAt(i);
        return res;
    }
}
方法三测试：

在 Python 和 Java 中，字符串是 “不可变对象” 。因此，每轮遍历拼接字符时，都需要新建一个字符串；因此，系统 需申请 N 次内存 ，数据量较大时效率低下。

剑指 Offer 59 - I. 滑动窗口的最大值

难度困难280

给定一个数组 nums 和滑动窗口的大小 k，请找出所有滑动窗口里的最大值。

示例:

输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3
输出: [3,3,5,5,6,7] 
解释: 

  滑动窗口的位置                最大值
---------------               -----
[1  3  -1] -3  5  3  6  7       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7

提示：

你可以假设 k 总是有效的，在输入数组不为空的情况下，1 ≤ k ≤ 输入数组的大小。
提示：

你可以假设 k 总是有效的，在输入数组不为空的情况下，1 ≤ k ≤ 输入数组的大小。

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums.length == 0 || k == 0) return new int[0];
        Deque<Integer> deque = new LinkedList<>();
        int[] res = new int[nums.length - k + 1];
        for(int j = 0, i = 1 - k; j < nums.length; i++, j++) {
            // 删除 deque 中对应的 nums[i-1]
            if(i > 0 && deque.peekFirst() == nums[i - 1])
                deque.removeFirst();
            // 保持 deque 递减
            while(!deque.isEmpty() && deque.peekLast() < nums[j])
                deque.removeLast();
            deque.addLast(nums[j]);
            // 记录窗口最大值
            if(i >= 0)
                res[i] = deque.peekFirst();
        }
        return res;
    }
}

可以将 “未形成窗口” 和 “形成窗口后” 两个阶段拆分到两个循环里实现。代码虽变长，但减少了冗余的判断操作。

剑指 Offer 59 - II. 队列的最大值

难度中等253

请定义一个队列并实现函数 max_value 得到队列里的最大值，要求函数max_value、push_back 和 pop_front 的均摊时间复杂度都是O(1)。

若队列为空，pop_front 和 max_value 需要返回 -1

示例 1：

输入: 
["MaxQueue","push_back","push_back","max_value","pop_front","max_value"]
[[],[1],[2],[],[],[]]
输出: [null,null,null,2,1,2]

示例 2：

输入: 
["MaxQueue","pop_front","max_value"]
[[],[],[]]
输出: [null,-1,-1]

限制：

  • 1 <= push_back,pop_front,max_value的总操作数 <= 10000
  • 1 <= value <= 10^5
方法二：维护一个单调的双端队列

那么如何高效实现一个始终递减的队列呢？我们只需要在插入每一个元素 value 时，从队列尾部依次取出比当前元素 value 小的元素，直到遇到一个比当前元素大的元素 value' 即可。

class MaxQueue {
    Queue<Integer> q;
    Deque<Integer> d;

    public MaxQueue() {
        q = new LinkedList<Integer>();
        d = new LinkedList<Integer>();
    }
    
    public int max_value() {
        if (d.isEmpty()) {
            return -1;
        }
        return d.peekFirst();
    }
    
    public void push_back(int value) {
        while (!d.isEmpty() && d.peekLast() < value) {
            d.pollLast();
        }
        d.offerLast(value);
        q.offer(value);
    }
    
    public int pop_front() {
        if (q.isEmpty()) {
            return -1;
        }
        int ans = q.poll();
        if (ans == d.peekFirst()) {
            d.pollFirst();
        }
        return ans;
    }

}

回忆 剑指Offer 30. 包含 min 函数的栈 ，其使用 单调栈 实现了随意入栈、出栈情况下的 O(1)时间获取 “栈内最小值” 。本题同理，不同点在于 “出栈操作” 删除的是 “列表尾部元素” ，而 “窗口滑动” 删除的是 “列表首部元素” 。思考方式不同，细细掂量！！！

class Solution {
    public boolean isStraight(int[] nums) {
        int joker = 0;
        Arrays.sort(nums); // 数组排序
        for(int i = 0; i < 4; i++) {
            if(nums[i] == 0) joker++; // 统计大小王数量
            else if(nums[i] == nums[i + 1]) return false; // 若有重复，提前返回 false
        }
        return nums[4] - nums[joker] < 5; // 最大牌 - 最小牌 < 5 则可构成顺子
    }
}
剑指 Offer 62. 圆圈中最后剩下的数字

难度简单386

0,1,···,n-1这n个数字排成一个圆圈，从数字0开始，每次从这个圆圈里删除第m个数字（删除后从下一个数字开始计数）。求出这个圆圈里剩下的最后一个数字。

例如，0、1、2、3、4这5个数字组成一个圆圈，从数字0开始每次删除第3个数字，则删除的前4个数字依次是2、0、4、1，因此最后剩下的数字是3。

示例 1：

输入: n = 5, m = 3
输出: 3

示例 2：

输入: n = 10, m = 17
输出: 2

限制：

  • 1 <= n <= 10^5
  • 1 <= m <= 10^6

方法：数学 + 递归

思路

题目中的要求可以表述为：给定一个长度为 n 的序列，每次向后数 m 个元素并删除，那么最终留下的是第几个元素？

这个问题很难快速给出答案。但是同时也要看到，这个问题似乎有拆分为较小子问题的潜质：如果我们知道对于一个长度 n - 1 的序列，留下的是第几个元素，那么我们就可以由此计算出长度为 n 的序列的答案。

算法

我们将上述问题建模为函数 f(n, m)，该函数的返回值为最终留下的元素的序号。

首先，长度为 n 的序列会先删除第 m % n 个元素，然后剩下一个长度为 n - 1 的序列。那么，我们可以递归地求解 f(n - 1, m)，就可以知道对于剩下的 n - 1 个元素，最终会留下第几个元素，我们设答案为 x = f(n - 1, m)。

由于我们删除了第 m % n 个元素，将序列的长度变为 n - 1。当我们知道了 f(n - 1, m) 对应的答案 x 之后，我们也就可以知道，长度为 n 的序列最后一个删除的元素，应当是从 m % n 开始数的第 x 个元素。因此有 f(n, m) = (m % n + x) % n = (m + x) % n。

fig1

我们递归计算 f(n, m), f(n - 1, m), f(n - 2, m), ... 直到递归的终点 f(1, m)。当序列长度为 1 时，一定会留下唯一的那个元素，它的编号为 0。

下面的代码实现了上述的递归函数。

class Solution {
    public int lastRemaining(int n, int m) {
        return f(n, m);
    }

    public int f(int n, int m) {
        if (n == 1) {
            return 0;
        }
        int x = f(n - 1, m);
        return (m + x) % n;
    }

}
剑指 Offer 63. 股票的最大利润

难度中等130

假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？

示例 1:

输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
     注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。

示例 2:

输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

限制：

0 <= 数组长度 <= 10^5
动态规划解析：
  • 状态定义： 设动态规划列表 dp，dp[i]代表以 prices[i]为结尾的子数组的最大利润（以下简称为 前 i日的最大利润 ）。
  • 转移方程： 由于题目限定 “买卖该股票一次” ，因此前 i日最大利润 dp[i]等于前 i - 1 日最大利润 dp[i-1]和第 i 日卖出的最大利润中的最大值。

前 i 日最大利润 =前i日最大利润=max(前(i−1)日最大利润,第i日价格−前i日最低价格)

dp[i] =max(dp[i−1],prices[i]−min(prices[0:i]))

  • 初始状态： dp[0] = 0，即首日利润为 0；
  • 返回值： dp[n - 1]，其中 n为 dp列表长度。
class Solution {
    public int maxProfit(int[] prices) {
        int cost = Integer.MAX_VALUE, profit = 0;
        for(int price : prices) {
            cost = Math.min(cost, price);
            profit = Math.max(profit, price - cost);
        }
        return profit;
    }
}
不懂就多学学
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
剑指 Offer 57. 和为s的两个数字
炫云云
08-28 87
剑指 Offer 57. 和为s的两个数字 输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。如果有多对数字的和等于s，则输出任意一对即可。 示例 1： 输入：nums = [2,7,11,15], target = 9 输出：[2,7] 或者 [7,2] 示例 2： 输入：nums = [10,26,30,31,47,60], target = 40 输出：[10,30] 或者 [30,10] 双指针法 利用 HashMap 可以通过遍历数组找到数字组合，时间和空间复杂度均
力扣(LeetCode)剑指offer刷题笔记（java），已完结！！！
Ferron的个人博客
03-28 1044
这是笔者在力扣上刷剑指offer的题目的刷题笔记，持续更新!!!
数据结构和算法二十九
weixin_44211905的博客
05-15 108
剑指 Offer 52. 两个链表的第一个公共节点 题目： 输入两个链表，找出它们的第一个公共节点。 如下面的两个链表： 在节点 c1 开始相交。 示例1： 输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 输出：Reference of the node with value = 8 输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链
「刷leetcode题」剑指offer 第二版
雨y飘零久的博客
11-23 373
文章目录数组1 数组中重复的数字（03，2020.11.23） 数组 1 数组中重复的数字（03，2020.11.23） 1 自己的解法 思路： 双重for循环遍历 var findRepeatNumber = function(nums) { for(let i=0; i<nums.length; i++){ for(let j=i+1; j< nums.length; j++) if(nums[i] === nums[j]){
阿翰 剑指offer 之 Day 13 双指针 3
b_e_w的博客
11-14 323
双指针 1 奇数调整到偶数前面 2 求和为s的两个数字 3 翻转单词顺序
java数据结构——HashMap的3种遍历方式
m0_38057941的博客
08-26 249
1.keySet遍历 1.先把map的key单独取出，存进一个新的Set； 2.再用foreach根据map.get(key)，遍历出value。 Set set = map.keySet(); for (Object obj: set) { System.out.print(obj + "=" + map.get(obj) + ","); } 2.Entry遍历 1.使用map.entrySet()，获取Entry<>数组，存入一个新的Set； 2.根据foreach.
力扣(LeetCode) 剑指Offer 14-Ⅰ
weixin_43754153的博客
06-29 144
题目描述 给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]…k[m-1] 。请问 k[0]*k[1]*…*k[m-1] 可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。 示例： 输入：2 输出：1 解释: 2 = 1 + 1, 1 × 1 = 1 题目思路 最开始看到题目就想到用动态规划，但是一时间太久没复习跟课上的钢条切割混淆了（那个是
包含网络、多线程、算法、leetCode和剑指offer的JAVA相关知识和解答
08-26
在网络技术领域，计算机网络概述是一...此外，算法面试题如LeetCode和剑指offer这类题库也经常出现在面试过程中，它们考查的是候选人的逻辑思维、问题解决能力和编码技巧。掌握这些知识点，无疑会增加面试成功的几率。
leetcode中文版-jianzhi-Offer-Leetcode:剑指Offer与Leetcode对应题目
06-29
update：中文版leetcode已发布剑指offer授权的刷题合集： 本帖记录剑指offer在leetcode主站的原题。 无 无 数组中重复的数字 -> （中文版） 二维数组中的查找 -> 替换空格 -> （中文版） 从尾到头打印链表 -> （中文...
leetcode分类-LeetCode:力扣笔记/剑指offer
06-30
leetcode 分类 LeetCode 力扣笔记，语言为c++ 其中有根据题目难度划分的Easy、Medium分类，多为模拟题目 除此外还有根据题目类型的专项分类，多涉及数据结构、基础算法 剑指offer
jianzhi-offer:力扣上剑指优惠
03-27
《力扣上剑指优惠：Java编程精要》 在编程的世界里，力扣（LeetCode）是一个广受程序员喜爱的在线平台，它提供了丰富的编程挑战题目，旨在提升程序员的实际编程能力和算法理解。"jianzhi-offer"是力扣上的一个专题...
力扣Leetcode试题选编(第三卷)
08-29
此外，还有关于春招必刷题目、居家学习的调查报告，以及阿里员工刷《剑指offer》的经验分享，这些都是为求职者提供实战经验和策略的宝贵资料。 书中还讨论了优秀程序员应具备的代码整洁之道，强调了代码可读性和可...
HashMap使遍历集合查找更效率
LiuEP的博客
12-11 759
效率循环数组 通常我们在匹配数组或者集合的时候经常会无脑的去用多层for循环遍历。【别点我，我就是一个菜鸟】。偶然一次发现，当需要处理遍历匹配两个数组或者集合的时候利用map的效率会比for循环高出几十倍。在这里mark一下。 参照力扣题库第一题。给定一个数组，在里面找出两个数字加起来正好等于目标值。 暴力的写法： class Solution { public int[] twoSum(...
leetcode253. 会议室II(java)：最小堆
yinianxx的博客
04-27 1652
题目 思路 用优先队列实现最小堆 1.先将数组进行升序排序 Arrays.sort(intervals,(o1,o2)->o1[0]-o2[0]); 这里使用了Lambda表达式，完整写法应该是 Arrays.sort(intervals,new Comparator<int[]>(){ @Override public int compare(int[]o1,int[...
leetcode253——会议室 II——java实现
阿花的IT历程
08-13 3157
参考地址：253. Meeting Rooms II 题目要求： 分析： 我没有开leetcode会员，在人家的博客上看到这道题目的，不知道是在哪里看到过这道题目，反正之前肯定是见过的。 在这里，我们先将所有的左闭区间和右闭区间都重新取出来进行排序，排序方法可以重写一个sort方法，也可以将每个值取出，然后进行排序； 将开始时间标记为1，结束时间标记为-1； 再从左到右遍历，将它们标记的值相加...
剑指Offer1—10题（leetcode 剑指Offer第二版）
qq_52880445的博客
04-10 527
1，用两个栈实现队列 import java.util.Stack; /** * @version v1.0 * @ProjectName: 数据结构 * @ClassName: CQueue * @Description: 请描述该类的功能 * @Author: ming * @Date: 2022/4/4 20:08 * 用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若
n个人围成一圈,第一个人从1开始数数,数到3的倍数的人离开,最后剩的人是第几个
weixin_46056679的博客
11-07 400
n个人围成一圈,第一个人从1开始数数,数到3的倍数的人离开,最后剩下的人是第几个 # coding=utf-8 n = int(input('输入人数:')) ren = [i + 1 for i in range(n)] # 数值 count = 1 i = 0 while True: if count % 3 == 0: ren[i] = 0
JAVA进阶补充
最新发布
2301_80150315的博客
08-15 1014
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值