- Trending Categories
Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Sorting an array including the elements present in the subarrays in JavaScript
In the given problem statement we are asked to sort an array including the elements present in the subarrays with the help of javascript functionalities. As we talk about sorting any list or array the sort() and flat method is useful.
What are sort(), flat() and isArray() methods in JavaScript ?
Let's understand the working of sort, flat and isArray methods in JavaScript.
The sort() method is basically used to sort the elements of an array and returns the sorted array. The items are sorted in dictionary order by default. But we can provide a function as an argument to sort the items in a different manner. For example:
input - arr = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]; arr.sort((a, b) => a - b); // in ascending order output - [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
The flat() function is used to flatten an array by concatenation subarrays. It flattens the array one level deep by default. But we can provide a number to flatten the array to a certain depth. For example:
input - arr = [1, [2, 3], [4, [5, 6]]]; const flatArr = arr.flat(); output - [1, 2, 3, 4, 5, 6]
isArray() is a built−in javascript function. With the help of this function we can determine that the given value is an array or not. It gives boolean output indicating that the value is an array. For example:
Array.isArray([1, 2, 3]); // true Array.isArray("hello"); // false Array.isArray({"name": "John"}); // false
Logic for The Above Problem
The easiest way to sort the items in an array with subarrays in javascript is by using the sort method and flat method.
For sorting an array which includes items present in the sub arrays in javascript, we can use the flat() method of javascript to flatten the array and then we can use the sort method to sort the items.
In our algorithm, the flat method of javascript will be used to flatten the array into a one dimensional array and the sort method will sort this array in ascending order. If we want to sort the sub arrays themselves instead of flattening them, we can use the map function to iterate the array items and sort them individually.
Algorithm - First Approach
Step 1 − Create an array which contains sub arrays.
Step 2 − Define a flatArr variable and apply the flat method on the created arr.
Step 3 − After flattening the array arr we will now sort the array with the sort method.
Step 4 − Show the output on console
Example
const arr = [4, 2, [5, 1], 3, [6]]; // Flatten the array const flatArr = arr.flat(); // Sort the flattened array flatArr.sort((a, b) => a - b); console.log("After sorting the elements from subarray"); console.log(flatArr);
Output
After sorting the elements from subarray [ 1, 2, 3, 4, 5, 6 ]
Algorithm − Second Approach
Step 1 − Declare an empty array called flatArr
Step 2 − Define a helper method called flattenHelper that is taking an array as its parameter and performs iteration over each and every item of the array.
Step 3 − If the item is present in an array then call the flattenHelper function recursively on the element.
Step 4 − If the element is not present in the array then push it into the flatArr.
Step 5 − Now call the flattenHelper function with the input array arr.
Step 6 − Following the fifth step, sort the flatArr in ascending order using the sort() method with a callback function that checks two items.
Step 7 − At last returns the flatArr as an output.
Example
function flattenAndSort(arr) { const flatArr = []; // A function to recursively flatten and push elements into flatArr function flattenHelper(arr) { for (let i = 0; i < arr.length; i++) { if (Array.isArray(arr[i])) { // recursively flatten subarray flattenHelper(arr[i]); } else { // push element into flatArr flatArr.push(arr[i]); } } } flattenHelper(arr); // sort flatArr in ascending order flatArr.sort((a, b) => a - b); return flatArr; } // example usage const arr = [4, 2, [5, 1], 3, [6]]; const sortedArr = flattenAndSort(arr); console.log(sortedArr);
Output
[ 1, 2, 3, 4, 5, 6 ]
Complexity
The above mentioned code is using the flat() function to flatten the array and then we have used the sort method to sort the array. This method has a time complexity of O(n log n). In this n is the total number of items in the array. The worst case time complexity of the sort method is O(n log n).
Conclusion
An array which contains items present in subarrays depends on the size of the array and the complexity of the problem. We have seen that the flat method is a simple and good approach to flatten small arrays.