Efficiently Sorting Squared Numbers from a Sorted Array

When working with arrays in JavaScript, a common task is to transform and sort data. A specific, interesting challenge arises when you have a sorted array containing negative and positive numbers and need to square each number, then sort the resulting array. Innovative Software Technology often encounters such scenarios, and understanding efficient solutions is crucial for optimal performance.

The Challenge: Squaring and Sorting

Suppose you’re given a sorted array of integers. This array can include both negative and positive numbers. The goal is to create a new array containing the square of each number from the original array, sorted in non-decreasing order.

Example Scenarios:

• Input: [-7, -3, 2, 3, 11]
  Output: [4, 9, 9, 49, 121]

• Input: [-4, -1, 0, 3, 10]
  Output: [0, 1, 9, 16, 100]

Solution 1: Leveraging JavaScript’s Built-in Sorting

One straightforward approach is to first square each number in the array and then use JavaScript’s built-in .sort() method to arrange the squared values.

Implementation:

function sortedSquares(nums) {
  const result = [];
  for (let i = 0; i < nums.length; i++) {
    const element = Math.abs(nums[i]);
    result.push(element * element);
  }

  return result.sort((a, b) => a - b);
}

Complexity Breakdown:

• Time Complexity: O(n log n). The .sort() method in JavaScript typically has a time complexity of O(n log n), where n is the number of elements in the array.
• Space Complexity: O(n). We create a new array (result) to store the squared values, so the space used is proportional to the input array’s size.

Solution 2: Understanding Bubble Sort

While less efficient than built-in sorting methods, Bubble Sort offers a clear illustration of a basic sorting algorithm. Bubble Sort repeatedly compares adjacent elements and swaps them if they are in the wrong order, gradually “bubbling” the largest (or smallest) elements to their correct positions.

Implementation:

const sortedSquaresUsingBubbleSort = (nums) => {
  let result = [];
  for (let index = 0; index < nums.length; index++) {
    const element = Math.abs(nums[index]);
    result.push(element * element);
  }

  let swapped;
  do {
    swapped = false;
    for (let i = 0; i < result.length - 1; i++) {
      if (result[i] > result[i + 1]) {
        [result[i], result[i + 1]] = [result[i + 1], result[i]];
        swapped = true;
      }
    }
  } while (swapped);

  return result;
};

Complexity Analysis:

• Time Complexity: O(n²). Due to the nested loops, Bubble Sort has a time complexity of O(n²), making it less efficient for large datasets.
• Space Complexity: O(n). Similar to the previous solution, we use a new array to store the squared numbers.

Testing the Solutions:

console.log(sortedSquaresUsingBubbleSort([-7, -3, 2, 3, 11])); // Output: [4, 9, 9, 49, 121]
console.log(sortedSquaresUsingBubbleSort([-4, -1, 0, 3, 10])); // Output: [0, 1, 9, 16, 100]

Choosing the Right Approach

Both presented methods correctly solve the problem. However, for performance reasons, using JavaScript’s built-in sort() method (Solution 1) is significantly faster. Its O(n log n) time complexity outperforms Bubble Sort’s O(n²) complexity, especially as the array size grows. While Bubble Sort has educational value for understanding sorting algorithm fundamentals, it’s not ideal for production code dealing with substantial amounts of data.

There are further optimizations possible, such as the two-pointer technique, which achieves O(n) time complexity. This approach takes advantage of the initial sorted nature of the input array.

How Innovative Software Technology Can Help

At Innovative Software Technology, we specialize in optimizing algorithms and data processing techniques to build high-performance applications. Whether it’s refining existing code or developing new solutions from scratch, our expertise in areas like array manipulation and sorting algorithms can significantly enhance your software’s efficiency. We can analyze your specific needs and implement the most effective strategies to ensure your applications handle data swiftly and reliably. Contact us to discuss how we can improve your software’s performance.