力扣1502. 判断能否形成等差数列（Array数组详解）

最新推荐文章于 2025-06-03 18:15:13 发布
最新推荐文章于 2025-06-03 18:15:13 发布
阅读量996 收藏 22
点赞数 18
分类专栏： Java基础 编程基础0-1 力扣学习计划 文章标签： leetcode 算法 数据结构 Array
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AffectionGF/article/details/148339129
版权

来源：1502. 判断能否形成等差数列 - 力扣（LeetCode）

题目

给你一个数字数组 arr 。

如果一个数列中，任意相邻两项的差总等于同一个常数，那么这个数列就称为 等差数列 。

如果可以重新排列数组形成等差数列，请返回 true ；否则，返回 false 。

示例 1：

输入：arr = [3,5,1]
输出：true
解释：对数组重新排序得到 [1,3,5] 或者 [5,3,1] ，任意相邻两项的差分别为 2 或 -2 ，可以形成等差数列。

示例 2：

输入：arr = [1,2,4]
输出：false
解释：无法通过重新排序得到等差数列。

提示：

  • 2 <= arr.length <= 1000
  • -10^6 <= arr[i] <= 10^6

详解 

思路

此题非常简单，只需将数组排序，再计算一个公差即可判断是否为等差数列 

class Solution {
    public boolean canMakeArithmeticProgression(int[] arr) {
        //对数组进行sort排列
        Arrays.sort(arr);
        int diff = arr[1] - arr[0];
        for (int i = 2; i < arr.length; i++) {
            if (arr[i] - arr[i - 1] != diff) {
                return false;
            }
        }
        return true;
    }
}

 Arrays工具类（常用方法详解）

Arrays类提供了许多用于操作数组的静态方法。以下是一些常见的方法及其示例：

1. 排序

  • sort(T[] a): 对数组进行升序排序。

    int[] arr = {5, 2, 8, 3, 1};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr)); // 输出: [1, 2, 3, 5, 8]

  • sort(T[] a, Comparator<? super T> c): 根据指定的比较器对数组进行排序。

    String[] names = {"Alice", "Bob", "Charlie"};
Arrays.sort(names, Comparator.comparingInt(String::length));
System.out.println(Arrays.toString(names)); // 输出: [Bob, Alice, Charlie]

  • parallelSort(T[] a): 使用并行排序对数组进行升序排序。

    int[] arr = {5, 2, 8, 3, 1};
Arrays.parallelSort(arr);
System.out.println(Arrays.toString(arr)); // 输出: [1, 2, 3, 5, 8]
2. 搜索

  • binarySearch(T[] a, T key): 使用二分搜索在升序数组中搜索指定的元素。

    int[] arr = {1, 2, 3, 5, 8};
int index = Arrays.binarySearch(arr, 3);
System.out.println(index); // 输出: 2

  • binarySearch(T[] a, T key, Comparator<? super T> c): 使用二分搜索在升序数组中搜索指定的元素，使用指定的比较器。

    String[] names = {"Alice", "Bob", "Charlie"};
int index = Arrays.binarySearch(names, "Bob", Comparator.naturalOrder());
System.out.println(index); // 输出: 1
3. 复制

  • copyOf(T[] original, int newLength): 复制指定的数组，返回一个新数组，长度为newLength。

    int[] arr = {1, 2, 3, 4, 5};
int[] newArr = Arrays.copyOf(arr, 3);
System.out.println(Arrays.toString(newArr)); // 输出: [1, 2, 3]

  • copyOfRange(T[] original, int from, int to): 复制指定范围的数组，返回一个新数组。

    int[] arr = {1, 2, 3, 4, 5};
int[] newArr = Arrays.copyOfRange(arr, 1, 4);
System.out.println(Arrays.toString(newArr)); // 输出: [2, 3, 4]
4. 转换

  • asList(T... a): 返回一个由指定数组支持的固定大小的列表。

    String[] names = {"Alice", "Bob", "Charlie"};
List<String> list = Arrays.asList(names);
System.out.println(list); // 输出: [Alice, Bob, Charlie]

  • toString(T[] a): 返回数组的字符串表示形式。

    int[] arr = {1, 2, 3, 4, 5};
String str = Arrays.toString(arr);
System.out.println(str); // 输出: [1, 2, 3, 4, 5]
5. 填充

  • fill(T[] a, T val): 用指定的值填充整个数组。

    int[] arr = new int[5];
Arrays.fill(arr, 7);
System.out.println(Arrays.toString(arr)); // 输出: [7, 7, 7, 7, 7]

  • fill(T[] a, int fromIndex, int toIndex, T val): 用指定的值填充数组的指定范围。

    int[] arr = {1, 2, 3, 4, 5};
Arrays.fill(arr, 1, 4, 0);
System.out.println(Arrays.toString(arr)); // 输出: [1, 0, 0, 0, 5]
6. 其他

  • equals(T[] a, T[] a2): 比较两个数组是否相等。

    int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
boolean isEqual = Arrays.equals(arr1, arr2);
System.out.println(isEqual); // 输出: true

  • hashCode(T[] a): 返回数组的哈希码。

    int[] arr = {1, 2, 3};
int hashCode = Arrays.hashCode(arr);
System.out.println(hashCode); // 输出: 哈希码

  • stream(T[] a): 返回一个顺序流，其元素是数组的元素。

    int[] arr = {1, 2, 3, 4, 5};
IntStream stream = Arrays.stream(arr);
stream.forEach(System.out::println); // 输出: 1 2 3 4 5
7. 升序排序

  • sort(int[] a): 对整数数组进行升序排序。

    int[] arr = {5, 2, 8, 3, 1};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr)); // 输出: [1, 2, 3, 5, 8]

  • binarySearch(int[] a, int key): 使用二分搜索在升序数组中搜索指定的元素。

    int[] arr = {1, 2, 3, 5, 8};
int index = Arrays.binarySearch(arr, 3);
System.out.println(index); // 输出: 2
8.降序排序
  • Array.sort(arr,Comparator.reverseOrder())：结合自定义的比较器。
Integer[] arr = {5, 2, 8, 3, 1};
        
        // 使用自定义比较器进行降序排序
        Arrays.sort(arr, Comparator.reverseOrder());
        
        System.out.println(Arrays.toString(arr)); // 输出: [8, 5, 3, 2, 1]

需要注意的是，Comparator.reverseOrder()适用于对象数组（如Integer[]），而不适用于基本数据类型数组（如int[]）。如果你使用的是基本数据类型数组，可以先将其转换为对象数组，排序后再转回基本数据类型数组，或者使用Java 8的流（Stream）API来实现降序排序。

以下是使用流API对基本数据类型数组进行降序排序的示例：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 3, 1};
        
        // 使用流API进行降序排序
        arr = Arrays.stream(arr)
                    .boxed()
                    .sorted(Comparator.reverseOrder())
                    .mapToInt(Integer::intValue)
                    .toArray();
        
        System.out.println(Arrays.toString(arr)); // 输出: [8, 5, 3, 2, 1]
    }
}

  在这个示例中，我们首先将int[]数组转换为IntStream，然后使用boxed()方法将其转换为Stream<Integer>，接着使用sorted(Comparator.reverseOrder())进行降序排序，最后再通过mapToInt(Integer::intValue)和toArray()方法将其转换回int[]数组。

9. 填充多维数组
  • fill(T[][] a, T val): 用指定的值填充整个二维数组。 
    int[][] matrix = new int[3][3];
Arrays.fill(matrix, 7);
for (int[] row : matrix) {
    System.out.println(Arrays.toString(row)); 
    // 输出: [7, 7, 7]
    //       [7, 7, 7]
    //       [7, 7, 7]
}
10. 排序多维数组
  • sort(T[][] a): 对二维数组的每个子数组进行排序。 
    int[][] matrix = {{5, 2, 8}, {3, 1, 4}, {7, 6, 9}};
for (int[] row : matrix) {
    Arrays.sort(row);
}
for (int[] row : matrix) {
    System.out.println(Arrays.toString(row)); 
    // 输出: [2, 5, 8]
    //       [1, 3, 4]
    //       [6, 7, 9]
}
11. 检查数组是否包含某个元素
  • binarySearch(T[] a, T key): 检查数组是否包含某个元素（需先排序）。 
    int[] arr = {1, 2, 3, 4, 5};
boolean contains = Arrays.binarySearch(arr, 3) >= 0;
System.out.println(contains); // 输出: true
12. 使用流进行复杂操作
  • stream(T[] a): 使用流进行复杂操作，例如过滤、映射、归约等。 
    int[] arr = {1, 2, 3, 4, 5};
int sum = Arrays.stream(arr).filter(n -> n % 2 != 0).sum();
System.out.println(sum); // 输出: 9 (奇数之和)
13. 并行流操作
  • parallelStream(T[] a): 使用并行流进行高效处理。 
    int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int sum = Arrays.parallelStream(arr).map(n -> n * 2).sum();
System.out.println(sum); // 输出: 110 (每个元素乘以2后求和)
14. 数组转换为集合
  • asList(T... a): 将数组转换为列表，然后进行集合操作。 
    String[] names = {"Alice", "Bob", "Charlie"};
List<String> list = Arrays.asList(names);
list.add("David"); // 抛出 UnsupportedOperationException，因为 asList 返回的是固定大小的列表
15. 使用setAll和replaceAll

  • setAll(T[] a, IntFunction<T> generator): 使用生成器函数设置数组的所有元素。

    int[] arr = new int[5];
Arrays.setAll(arr, i -> i * i);
System.out.println(Arrays.toString(arr)); // 输出: [0, 1, 4, 9, 16]

  • replaceAll(T[] a, UnaryOperator<T> operator): 使用操作符替换数组的所有元素。

    int[] arr = {1, 2, 3, 4, 5};
Arrays.replaceAll(arr, n -> n * 2);
System.out.println(Arrays.toString(arr)); // 输出: [2, 4, 6, 8, 10]
16. 使用copyOf和copyOfRange处理多维数组

  • copyOf(T[][] original, int newLength): 复制二维数组。

    int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int[][] newMatrix = Arrays.copyOf(matrix, 2);
for (int[] row : newMatrix) {
    System.out.println(Arrays.toString(row)); 
    // 输出: [1, 2, 3]
    //       [4, 5, 6]
}

  • copyOfRange(T[][] original, int from, int to): 复制二维数组的指定范围。

    int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int[][] newMatrix = Arrays.copyOfRange(matrix, 1, 3);
for (int[] row : newMatrix) {
    System.out.println(Arrays.toString(row)); 
    // 输出: [4, 5, 6]
    //       [7, 8, 9]
}
Leet Code 力扣 - - 最短最优雅python解法带解析汇总
Knife丶小刀博客
04-19 4656
Leet Code 刷题笔记 记录一下刷过的有意义和代表性的题 动态规划 Unique Paths 题目可以转换为排列组合问题，解是C(min(m,n), m+n)，从m+n个中选出m个下移或n个右移。 用DP做很快，以后算 C(a, b) 都可以用算这题的DP法代替 ...
leetcode 最常见的前端基础算法面试题汇总
weixin_52546522的博客
08-13 2227
目录二叉树二叉树前中后遍历套路详解对称二叉树二叉树的最大深度将有序数组转化为二叉搜索树栈有效的括号最小栈动态规划最大子序和爬楼梯数学问题加一x的平方根Excel表序列号阶乘中的零颠倒二进制位丢失的数字的幂Fizz Buzz环问题环形链表快乐数前端面试题人事+项目小程序HTML5\CSS3JSReact 把这些基础算法题掌握好，基础不牢地动山摇，后面中级题很多都是在这些基础题的基础上的。 二叉树 二叉树前中后遍历套路详解 前序遍历题目如下： root节点是A节点（下图的A节点），然后让你按照下图数字的顺序依次
数组和链表部分例题（力扣）
weixin_67852890的博客
01-17 1011
如果不在，则计算后将结果存入缓存，然后再返回。在尾递归优化中，如果递归调用是函数体中的最后一句，并且返回值直接是该递归调用的结果，编译器或解释器可以避免创建新的栈帧，从而减少栈空间的使用。如果要计算环的大小，可以通过让其中一个指针停留在相遇点，另一个指针重置回头结点，然后两个指针以相同速度前进再次相遇的方式来实现，此时两者共同走过的额外距离就是环的长度。（方法2）与方法1类似，构建新的链表，从头部移除节点，添加至新链表头部，完成后新链表既是倒序的，需要构建一个容器类，但是不去创建新的节点，更加偏面向对象。
力扣刷题总结
weixin_43270322的博客
01-12 1137
总结刷过的力扣题目的一些思路
刷力扣算法--蓝桥杯备战
qq_45655136的博客
08-05 9172
刷题网站：https://leetcode-cn.com/problems/container-with-most-water/submissions/ 参考书籍：LeetCode 101：和你一起你轻松刷题（C++） 使用语言：python 记录刷题过程中的学到的一些知识点–持续更新（每天坚持至少刷三道算法题） 坚持就是胜利鸭 1、数组 两数之和 class Solution: def twoSum(self,nums, target): #用len()方法取得nums列表长度
力扣做题之旅
qq_42784882的博客
12-04 2225
力扣做题之旅(菜鸡选手)
LeetCode-题目详解：排序【高频题：6、中频题：27、低频题：29】
u013250861的博客
05-13 2319
242、有效的字母异位词 252、会议室 349、两个数组的交集 350、两个数组的交集 II 922、按奇偶排序数组 II 976、三角形的最大周长 1030、距离顺序排列矩阵单元格 1086、前五科的均分 1099、小于 K 的两数之和 1122、数组的相对排序 1356、根据数字二进制下 1 的数目排序 1370、上升下降字符串 1403、非递增顺序的最小子序列 1491、去掉最低工资和最高工资后的工资平均值 1502、判断能否形成等差数列
算法笔记(个人用)(不定期更新)
cuber-lotus的博客
03-23 3197
文章目录前言说明Note文档编辑相关语言特性相关 (C/C++)输出数组最后一个元素后面无空格二分查找函数rand() 范围算法相关排序区间求和题单基础数学素数素数判断素数筛朴素筛选 (埃式筛)朴素筛选优化线性筛 (欧拉筛)闰年判断蔡勒（Zeller）公式GCD10转R进制卡特兰数完美数分解因数欧几里得-欧拉定理数根[1~n] 中完全平方数的个数计算Π pia二分查找顺序序列找唯一值逼近类二分容斥原理位运算整形存储大小intlong long`__builtin_函数`取模自动取模工具类除法取模判断奇偶统计
手把手带你了解时间复杂度和空间复杂度 【超详细】
热门推荐
Eraser的博客
04-22 2万+
学习数据结构的第一步，对时间复杂度和空间复杂掌握和理解是非常关键的，不管是考研还是学校的应试或者说你想要写出一个效率高的程序，内容有点多，请大家耐心看完。
LeetCode刷题之python解法（持续更新）
sinat_29217765的博客
06-25 3229
1. Two Sum 4行 class Solution: def twoSum(self, nums: List[int], target: int) -> List[int]: d = {} for i, n in enumerate(nums): if n in d: return [d[n], i] d[target-n] = i O(N)时间效...
Unity游戏开发客户端面经——算法（初级）
Sea3752的博客
10-27 1万+
Unity游戏开发客户端面经之算法篇
力扣每日一题——连接两棵树后最大目标节点数目 ||
WenJGo的博客
05-29 726
本文介绍了LeetCode 3373题的解法——双树贡献分离法。该算法通过将问题分解为两个独立子问题：计算每棵树内部的节点贡献，再通过简单相加得到最终结果。Java和C++实现都采用BFS遍历树结构，记录节点层级奇偶分布，最后将第一棵树的节点贡献与第二棵树的最大贡献相加。时间复杂度为O(n²+m²)（BFS实现），空间复杂度为O(n+m+k)。这种分治思路避免了暴力枚举，有效优化了算法效率。
Java详解LeetCode 热题 100(23):LeetCode 206. 反转链表（Reverse Linked List）详解
yk_dflkg的博客
06-02 1073
*** 单链表节点的定义*/int val;// 节点的值// 指向下一个节点的指针// 无参构造函数// 带值的构造函数// 带值和下一个节点的构造函数算法理解反转链表本质是改变指针方向关键是保存下一个节点的信息，避免链表断裂迭代法使用三指针，递归法利用调用栈实现技巧边界条件：空链表和单节点链表prevcurrnext三指针配合递归法：明确递归终止条件和回溯处理复杂度权衡迭代法：时间O(n)，空间O(1)，推荐使用。
704. 二分查找 （力扣）
最新发布
woyvxuetongzai52的博客
06-03 118
摘要：本文实现了一个二分查找算法，用于在有序整型数组中查找目标值。算法通过维护左右指针逐步缩小搜索范围，时间复杂度为O(log n)。当目标值存在时返回其下标，否则返回-1。示例展示了查找成功（target=9返回4）和失败（target=2返回-1）的情况。代码采用左闭右开区间写法，避免整数溢出问题，适用于元素唯一且数组长度在1到10000之间的场景。
【LeetCode 热题 100】最小路径和 / 最长回文子串 / 最长公共子序列 / 编辑距离
小羊的博客
05-29 376
最小路径和 / 最长回文子串 / 最长公共子序列 / 编辑距离
力扣HOT100之动态规划：70. 爬楼梯
weixin_52151595的博客
05-29 325
这道题得用动态规划来做，用递归好像会超时。2.确定递推公式:dp[i] = dp[i - 1] + dp[i - 2]由于这本质上就是一个斐波那契数列，所以递推公式也很好想，只有到达第。3.dp数组初始化:dp[0] = 1, dp[1] = 1。1.确定dp[i]的含义:爬到第i阶楼梯的方法数。由于本题使用的是一维dp数组，因此。4.确定遍历顺序：从前往后遍历。5.打印数组(省略)
LeetCode - 965. 单值二叉树
2402_83315537的博客
06-01 215
本文介绍了使用深度优先搜索(DFS)判断二叉树是否为单值二叉树的方法。DFS是一种递归遍历算法，会尽可能深入搜索每条路径。实现时分为三部分：检查当前节点与左右子节点的值是否相同，并递归验证左右子树是否为单值树。文中给出了正确的代码实现，若遇到空节点返回true，发现不同值则返回false，最终需左右子树都满足条件才判定为单值二叉树。
Leetcode 2921. 价格递增的最大利润三元组 II
m0_51437455的博客
05-29 414
第二步，使用树状数组，一边添加元素，一边计算单边最大值，构建larr和rarr数组，分别维护i处左边更小价格对应最大利润，i处右边更大价格对应的最大利润。第二步，使用线段树，一边添加元素，一边计算单边最大值，构建larr和rarr数组，分别维护i处左边更小价格对应最大利润，i处右边更大价格对应的最大利润。第一步，构建两个树状数组，treeArr1维护左边更小价格对应利润的最大值，treeArr1维护右边更大价格对应利润的最大值。第三步，根据larr和rarr和profits数组提取题解。
力扣HOT100之动态规划：416. 分割等和子集
weixin_52151595的博客
06-01 713
这道题之前刷过代码随想录，现在只能想起一点点思路，最后还是去看视频了。这道题用二维dp数组或者一维dp数组都可以做，这篇博客把两种思路都讲一下。
力扣 977. 有序数组的平方 js
09-14
这是一个关于有序数组的平方的问题。给定一个按非递减顺序排序的整数数组，你需要返回每个数字的平方，并按非递减顺序返回新的数组。 下面是一个使用 JavaScript 解决该问题的示例代码： ```javascript var sortedSquares = function(nums) { // 创建一个新数组用于存放平方后的结果 var result = []; var left = 0; // 左指针 var right = nums.length - 1; // 右指针 // 从数组两端开始遍历 while (left <= right) { var leftSquare = nums[left] * nums[left]; var rightSquare = nums[right] * nums[right]; // 判断左右指针所指元素的平方大小，将较大的平方值添加到结果数组中 if (leftSquare > rightSquare) { result.unshift(leftSquare); left++; } else { result.unshift(rightSquare); right--; } } return result; }; ``` 通过上述代码，在给定的有序数组上进行双指针遍历，每次取左右指针所指元素的平方，将较大的平方值从结果数组的头部插入。最终返回按非递减顺序排列的平方结果数组。 希望能够帮助到你！如果有任何疑问，请随时提出。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值