Javascript Array Sort

4 Key excerpts on "Javascript Array Sort"

• 

  eBook - ePub

  PHP 7 Data Structures and Algorithms

  • Mizanur Rahman(Author)
  • 2017(Publication Date)
  • Packt Publishing

    (Publisher)

  Using Sorting Algorithms

  Sorting is one of the most used algorithms in computer programming. Even in our everyday life, if things are not sorted, we can have a hard time with them. Sorting can pave the way for faster searching or ordering of items in a collection. Sorting can be done in many different ways, such as in ascending order or descending order. Sorting can also be based on the type of data. For example, sorting a collection of names will require lexicographical sorting rather than numerical sorting. As sorting can play an important role for other data structures and their efficiencies, there are many different sorting algorithms available. We will explore a few of the most popular sorting algorithms in this chapter, along with their complexity and usages.

  Passage contains an image

  Understanding sorting and their types

  Sorting means a sorted order of the data. Often, our data is unsorted, which means we need a way to sort it. Usually, sorting is done by comparing different elements with each other and coming up with the ranking. In most cases, without the comparison, we cannot decide on the sorting part. After the comparison, we also need to swap the elements so that we can reorder them. A good sorting algorithm has the characteristics of making a minimum number of comparisons and swapping. There is also non-comparison based sorting, where no comparison is required to sort a list of items. We will also explore those algorithms in this chapter.

  Sorting can be classified into different types based on the type of data set, direction, computational complexities, memory usage, space usage, and so on. Here are few of the sorting algorithms we will explore in this chapter:

  • Bubble sort
  • Insertion sort
  • Selection sort
  • Quick sort
  • Merge sort
  • Bucket sort

  We will keep our discussion limited to the preceding list, as they are the most commonly used sorting algorithms and can be grouped and classified under different criteria such as simple sorting, efficient sorting, distribution sorting, and so on. We will now explore each of the sorting functionalities, their implementations, and complexity analysis, along with their pros and cons. Let's get started with the most commonly used sorting algorithm - bubble sort.

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  JavaScript

  Syntax and Practices

  • Ravi Tomar, Sarishma Dangi(Authors)
  • 2021(Publication Date)
  • Chapman and Hall/CRC

    (Publisher)

  pop() methods from the front and back of the array, respectively. These arrays can be traversed either by using their indexes or by iterating over them as we have learned before. An example that demonstrates usage of multidimensional arrays is given as follows:

  var nestedNumerals = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];

  console.log(nestedNumerals[1][1]); // returns 5

  console.log(nestedNumerals[2][1]); // returns 8

  nestedNumerals.pop(); //removes [7,8,9] from the array

  nestedNumerals.push([12, 24, 48]); //adds [12,24,48] to the end console.log(nestedNumerals); //prints [[1, 2, 3],[4, 5, 6],[7, 8, 9],[12,24,48]]

  Following examples demonstrate the usage of nested loop to iterate over the elements of multidimensional arrays:

  var studentDetails = [["Tom", 80, 6], ["Tim", 75, 7], ["Bob", 88, 9]]; console.log("Name, Percentage, Class"); for (var i = 0; i < 3; i + +) { console.log("/n"); for (var j = 0; j < 3; j + +) { console.log(studentDetails[i][j]); } } /*Output: Name, Percentage, Class Tom,80, 6 Tim, 75, 7 Bob, 88, 9 */

  5.7 Sorting

  JavaScript provides the sort() method to sort the elements of an array. The array elements are compared by value, and the resulting array is sorted in an ascending order. In order to find the descending order of elements, reverse() can be used on an array.

  sort() works by converting the elements into strings and then comparing their values. Therefore, it might not work well in cases where numeric arrays need sorting. The solution to this is to pass a comparing function in the sort() method. Comparing function can be used to generate any kind of sorting operation for array elements. It gives us the flexibility to modify array elements in any order that we like. Syntax for using sort()

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  Learning JavaScript Data Structures and Algorithms

  • Loiane Groner(Author)
  • 2018(Publication Date)
  • Packt Publishing

    (Publisher)
• We move to the next value: 4. Should the value 4 stay in the current position (index 3), or does it need to be moved to a lower position? The value 4 is less than 5, so 5 will get shifted to index 3. Should we insert 4 in index 2? The value 4 is greater than 3, so 4 is inserted in position 3 of the array.
• The next value to be inserted is 2 (position 4 of the array). The value 5 is greater than 2, so 5 gets shifted to index 4. The value 4 is greater than 2, so 4 will also get shifted (position 3). The value 3 is also greater than 2, and 3 also gets shifted. The value 1 is less than 2, so 2 is inserted at the second position of the array. Thus, the array is sorted.
This algorithm has a better performance than the selection and bubble sort algorithms when sorting small arrays. Passage contains an image

The merge sort

The merge sort algorithm is the first sorting algorithm that can be used in a real-world scenario. The three first sorting algorithms that we learned about in this book do not have a good performance, but the merge sort has good performance with a complexity of O(n log n) .
The JavaScript Array class defines a sort function (Array.prototype.sort) that can be used to sort arrays using JavaScript (with no need to implement the algorithm ourselves). ECMAScript does not define which sorting algorithm needs to be used, so each browser can implement its own algorithm. For example, Mozilla Firefox uses the merge sort as the Array.prototype.sort implementation, while Chrome (V8 engine) uses a variation of the quick sort (which we will learn about next).
The merge sort is a divide-and-conquer algorithm. The idea behind it is to divide the original array into smaller arrays until each small array has only one position, and then merge these smaller arrays into bigger ones until we have a single big array at the end that is sorted.
Because of the divide-and-conquer approach, the merge sort algorithm is also recursive. We will divide the algorithm into two functions: the first one will be responsible for dividing the array into smaller ones and evoking the helper function that will perform the sort. Let's take a look at the main function declared here: