Welcome to Subscribe On Youtube

3667. Sort Array By Absolute Value 🔒

Description

You are given an integer array nums.

Rearrange elements of nums in non-decreasing order of their absolute value.

Return any rearranged array that satisfies this condition.

Note: The absolute value of an integer x is defined as:

  • x if x >= 0
  • -x if x < 0

 

Example 1:

Input: nums = [3,-1,-4,1,5]

Output: [-1,1,3,-4,5]

Explanation:

  • The absolute values of elements in nums are 3, 1, 4, 1, 5 respectively.
  • Rearranging them in increasing order, we get 1, 1, 3, 4, 5.
  • This corresponds to [-1, 1, 3, -4, 5]. Another possible rearrangement is [1, -1, 3, -4, 5].

Example 2:

Input: nums = [-100,100]

Output: [-100,100]

Explanation:

  • The absolute values of elements in nums are 100, 100 respectively.
  • Rearranging them in increasing order, we get 100, 100.
  • This corresponds to [-100, 100]. Another possible rearrangement is [100, -100].

 

Constraints:

  • 1 <= nums.length <= 100
  • -100 <= nums[i] <= 100

Solutions

Solution 1: Custom Sorting

We can use a custom sorting function to sort the array, where the sorting criterion is the absolute value of each element.

The time complexity is $O(n \times \log n)$, and the space complexity is $O(\log n)$, where $n$ is the length of the array $\textit{nums}$.

  • class Solution {
        public int[] sortByAbsoluteValue(int[] nums) {
            return Arrays.stream(nums)
                .boxed()
                .sorted(Comparator.comparingInt(Math::abs))
                .mapToInt(Integer::intValue)
                .toArray();
        }
    }
    
    
  • class Solution {
    public:
        vector<int> sortByAbsoluteValue(vector<int>& nums) {
            sort(nums.begin(), nums.end(), [](int a, int b) {
                return abs(a) < abs(b);
            });
            return nums;
        }
    };
    
    
  • class Solution:
        def sortByAbsoluteValue(self, nums: List[int]) -> List[int]:
            return sorted(nums, key=lambda x: abs(x))
    
    
  • func sortByAbsoluteValue(nums []int) []int {
    	slices.SortFunc(nums, func(a, b int) int {
    		return abs(a) - abs(b)
    	})
    	return nums
    }
    
    func abs(x int) int {
    	if x < 0 {
    		return -x
    	}
    	return x
    }
    
    
  • function sortByAbsoluteValue(nums: number[]): number[] {
        return nums.sort((a, b) => Math.abs(a) - Math.abs(b));
    }
    
    
  • impl Solution {
        pub fn sort_by_absolute_value(mut nums: Vec<i32>) -> Vec<i32> {
            nums.sort_by_key(|&x| x.abs());
            nums
        }
    }
    
    

All Problems

All Solutions