LeetCode第360题_有序转化数组

最新推荐文章于 2025-08-14 22:07:01 发布

@蓝莓果粒茶

最新推荐文章于 2025-08-14 22:07:01 发布

阅读量720

点赞数 10

CC 4.0 BY-SA版权

分类专栏：算法文章标签： leetcode 算法职场和发展 c# 学习

本文链接：https://blog.csdn.net/qq_40263592/article/details/149696959

算法专栏收录该内容

354 篇文章

订阅专栏

LeetCode 第360题：有序转化数组

📖 文章摘要

本文详细解析LeetCode第360题"有序转化数组"，这是一道数学和双指针问题。文章提供了基于双指针的解法，包含C#、Python、C++三种语言实现，配有详细的算法分析和性能对比。适合想要提升数学思维和双指针技巧的读者。

核心知识点： 双指针、数学分析、抛物线、排序
难度等级： 中等
推荐人群： 具有一定算法基础，想要提升数学问题解决能力的程序员

题目描述

给你一个已经排好序的整数数组 nums 和整数 a、b、c。对于数组中的每一个数 x，计算函数值 f(x) = ax^2 + bx + c，请将函数值也按照升序排序。

示例

示例 1：

输入：nums = [-4,-2,2,4], a = 1, b = 3, c = 5
输出：[3,9,15,33]
解释：函数值 f(x) = x^2 + 3x + 5

示例 2：

输入：nums = [-4,-2,2,4], a = -1, b = 3, c = 5
输出：[-23,-5,1,7]
解释：函数值 f(x) = -x^2 + 3x + 5

提示

1 <= nums.length <= 200
-100 <= nums[i] <= 100
-100 <= a, b, c <= 100
nums 已按升序排序

解题思路

本题可以使用双指针方法解决：

根据a的正负确定函数值的单调性
使用双指针从两端向中间移动
根据单调性选择较大或较小的值
将结果存入新数组

时间复杂度： O(n)
空间复杂度： O(n)

图解思路

函数分析表

a的符号	函数特性	处理策略
a > 0	开口向上	两端值较大
a < 0	开口向下	两端值较小
a = 0	线性函数	根据b的符号决定

双指针移动表

情况	左指针	右指针	选择
a > 0	增大	减小	较大值
a < 0	增大	减小	较小值

代码实现

C# 实现

public class Solution {
    public int[] SortTransformedArray(int[] nums, int a, int b, int c) {
        int n = nums.Length;
        int[] result = new int[n];
        int left = 0, right = n - 1;
        int index = a >= 0 ? n - 1 : 0;
        
        while (left <= right) {
            int leftVal = Calculate(nums[left], a, b, c);
            int rightVal = Calculate(nums[right], a, b, c);
            
            if (a >= 0) {
                if (leftVal >= rightVal) {
                    result[index--] = leftVal;
                    left++;
                } else {
                    result[index--] = rightVal;
                    right--;
                }
            } else {
                if (leftVal <= rightVal) {
                    result[index++] = leftVal;
                    left++;
                } else {
                    result[index++] = rightVal;
                    right--;
                }
            }
        }
        
        return result;
    }
    
    private int Calculate(int x, int a, int b, int c) {
        return a * x * x + b * x + c;
    }
}

Python 实现

class Solution:
    def sortTransformedArray(self, nums: List[int], a: int, b: int, c: int) -> List[int]:
        n = len(nums)
        result = [0] * n
        left, right = 0, n - 1
        index = n - 1 if a >= 0 else 0
        
        while left <= right:
            left_val = self.calculate(nums[left], a, b, c)
            right_val = self.calculate(nums[right], a, b, c)
            
            if a >= 0:
                if left_val >= right_val:
                    result[index] = left_val
                    left += 1
                else:
                    result[index] = right_val
                    right -= 1
                index -= 1
            else:
                if left_val <= right_val:
                    result[index] = left_val
                    left += 1
                else:
                    result[index] = right_val
                    right -= 1
                index += 1
                
        return result
    
    def calculate(self, x: int, a: int, b: int, c: int) -> int:
        return a * x * x + b * x + c

C++ 实现

class Solution {
public:
    vector<int> sortTransformedArray(vector<int>& nums, int a, int b, int c) {
        int n = nums.size();
        vector<int> result(n);
        int left = 0, right = n - 1;
        int index = a >= 0 ? n - 1 : 0;
        
        while (left <= right) {
            int leftVal = calculate(nums[left], a, b, c);
            int rightVal = calculate(nums[right], a, b, c);
            
            if (a >= 0) {
                if (leftVal >= rightVal) {
                    result[index--] = leftVal;
                    left++;
                } else {
                    result[index--] = rightVal;
                    right--;
                }
            } else {
                if (leftVal <= rightVal) {
                    result[index++] = leftVal;
                    left++;
                } else {
                    result[index++] = rightVal;
                    right--;
                }
            }
        }
        
        return result;
    }
    
private:
    int calculate(int x, int a, int b, int c) {
        return a * x * x + b * x + c;
    }
};