Open In App

Javascript Program For Sorting An Array Of 0s, 1s and 2s

Last Updated : 19 Sep, 2023
Improve
Improve
Like Article
Like
Save
Share
Report

Given an array A[] consisting 0s, 1s and 2s. The task is to write a function that sorts the given array. The functions should put all 0s first, then all 1s and all 2s in last.
Examples:

Input: {0, 1, 2, 0, 1, 2}
Output: {0, 0, 1, 1, 2, 2}

Input: {0, 1, 1, 0, 1, 2, 1, 2, 0, 0, 0, 1}
Output: {0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2}

A simple solution is discussed in this(Sort an array of 0s, 1s and 2s (Simple Counting)) post.
Method 1:

Approach:The problem is similar to our old post Segregate 0s and 1s in an array, and both of these problems are variation of famous Dutch national flag problem.
The problem was posed with three colours, here `0′, `1′ and `2′. The array is divided into four sections: 

  1. a[1..Lo-1] zeroes (red)
  2. a[Lo..Mid-1] ones (white)
  3. a[Mid..Hi] unknown
  4. a[Hi+1..N] twos (blue)
  5. If the ith element is 0 then swap the element to the low range, thus shrinking the unknown range.
  6. Similarly, if the element is 1 then keep it as it is but shrink the unknown range.
  7. If the element is 2 then swap it with an element in high range.

    Algorithm: 

    1. Keep three indices low = 1, mid = 1 and high = N and there are four ranges, 1 to low (the range containing 0), low to mid (the range containing 1), mid to high (the range containing unknown elements) and high to N (the range containing 2).
    2. Traverse the array from start to end and mid is less than high. (Loop counter is i)
    3. If the element is 0 then swap the element with the element at index low and update low = low + 1 and mid = mid + 1
    4. If the element is 1 then update mid = mid + 1
    5. If the element is 2 then swap the element with the element at index high and update high = high – 1 and update i = i – 1. As the swapped element is not processed
    6. Print the output array.

      Dry Run: 
      Part way through the process, some red, white and blue elements are known and are in the “right” place. The section of unknown elements, a[Mid..Hi], is shrunk by examining a[Mid]:

      DNF1

      Examine a[Mid]. There are three possibilities: 
      a[Mid] is (0) red, (1) white or (2) blue. 
      Case (0) a[Mid] is red, swap a[Lo] and a[Mid]; Lo++; Mid++
       

      DNF2

      Case (1) a[Mid] is white, Mid++

      DNF3

      Case (2) a[Mid] is blue, swap a[Mid] and a[Hi]; Hi–

      DNF4

      Continue until Mid>Hi.

      Implementation:

      Javascript




      <script>
      // Javascript program to sort an 
      // array of 0, 1 and 2 
        
      // Sort the input array, the array is 
      // assumed to have values in {0, 1, 2} 
      function sort012(a, arr_size)
      {
          let lo = 0; 
          let hi = arr_size - 1; 
          let mid = 0;
          let temp = 0; 
          while (mid <= hi)
          {
              if(a[mid] == 0)
              {
                  temp = a[lo]; 
                  a[lo] = a[mid]; 
                  a[mid] = temp; 
                  lo++; 
                  mid++; 
              }
              else if(a[mid] == 1)
              {
                  mid++; 
              }
              else
              {
                  temp = a[mid]; 
                  a[mid] = a[hi]; 
                  a[hi] = temp; 
                  hi--;
              }  
          }
      }
            
      /* Utility function to print 
         array arr[] */
      function printArray(arr, arr_size)
      {
          let i;
          for (i = 0; i < arr_size; i++)
          {
              document.write(arr[i] + " ");
          }
          document.write("<br>");
      }
            
      // Driver code
      let arr= [0, 1, 1, 0, 1, 2, 
                1, 2, 0, 0, 0, 1 ];
      let arr_size = arr.length;
      sort012(arr, arr_size);
      document.write(
      "Array after seggregation <br>")
      printArray(arr, arr_size); 
      // This code is contributed by rag2127
      </script>

      
      

      Output: 

      array after segregation
       0 0 0 0 0 1 1 1 1 1 2 2 

      Complexity Analysis: 

      • Time Complexity: O(n). 
        Only one traversal of the array is needed.
      • Space Complexity: O(1). 
        No extra space is required.
      • Method 2:

        Approach: Count the number of 0s, 1s and 2s in the given array. Then store all the 0s in the beginning followed by all the 1s then all the 2s.

        Algorithm: 

        1. Keep three counter c0 to count 0s, c1 to count 1s and c2 to count 2s
        2. Traverse through the array and increase the count of c0 if the element is 0,increase the count of c1 if the element is 1 and increase the count of c2 if the element is 2
        3. Now again traverse the array and replace first c0 elements with 0, next c1 elements with 1 and next c2 elements with 2.

        Implementation:

        Javascript




        <script>
        // Javascript implementation of the 
        // approach
          
        // Utility function to print the 
        // contents of an array
        function printArr( arr, n)
        {
            for (let i = 0; i < n; i++)
                document.write(arr[i] + " ");
        }
          
        // Function to sort the array of 0s, 
        // 1s and 2s
        function sortArr( arr,  n)
        {
            let i, cnt0 = 0, cnt1 = 0, 
                   cnt2 = 0;
          
            // Count the number of 0s, 1s and 
            // 2s in the array
            for (i = 0; i < n; i++) 
            {
                switch (arr[i]) 
                {
                    case 0:
                    cnt0++;
                    break;
                    case 1:
                    cnt1++;
                    break;
                    case 2:
                    cnt2++;
                    break;
                }
            }
          
            // Update the array
            i = 0;
          
            // Store all the 0s in the 
            // beginning
            while (cnt0 > 0) 
            {
                arr[i++] = 0;
                cnt0--;
            }
          
            // Then all the 1s
            while (cnt1 > 0) 
            {
                arr[i++] = 1;
                cnt1--;
            }
          
            // Finally all the 2s
            while (cnt2 > 0) 
            {
                arr[i++] = 2;
                cnt2--;
            }
          
            // Print the sorted array
            printArr(arr, n);
        }
          
        // Driver code
        let arr = [0, 1, 1, 0, 1, 2, 1,
                   2, 0, 0, 0, 1]; 
        let n = arr.length; 
              
        // Function calling
        sortArr(arr, n);
        // This code is contributed by jana_sayantan.
        </script>

        
        

        Output:

        0 0 0 0 0 1 1 1 1 1 2 2

        Complexity Analysis:

        • Time Complexity: O(n). 
          Only two traversals of the array is needed.
        • Space Complexity: O(1). 
          As no extra space is required.

        Please refer complete article on Sort an array of 0s, 1s and 2s for more details!



        Previous Article
        Next Article

Similar Reads

Different ways of sorting Dictionary by Keys and Reverse sorting by keys
Prerequisite: Dictionaries in Python A dictionary is a collection which is unordered, changeable and indexed. In Python, dictionaries are written with curly brackets, and they have keys and values. We can access the values of the dictionary using keys. In this article, we will discuss 10 different ways of sorting the Python dictionary by keys and a
8 min read
Different ways of sorting Dictionary by Values and Reverse sorting by values
Prerequisite: Dictionaries in Python A dictionary is a collection which is unordered, changeable, and indexed. In Python, dictionaries are written with curly brackets, and they have keys and values. We can access the values of the dictionary using keys. In this article, 10 different ways of sorting the Python dictionary by values and also reverse s
17 min read
Sorting objects using In-Place sorting algorithm
Given an array of red, blue and yellow objects, the task is to use an in-place sorting algorithm to sort the array in such a way that all the blue objects appear before all the red objects and all the red objects appear before all the yellow objects.Examples: Input: arr[] = {"blue", "red", "yellow", "blue", "yellow"} Output: blue blue red yellow ye
7 min read
What is Sorting in DSA | Sorting meaning
Sorting is defined as the process of arranging a collection of data elements in a specific order, usually in ascending or descending order based on a specific attribute of the data elements. Characteristics of Sorting:Time Complexity: Time complexity, a measure of how long it takes to run an algorithm, is used to categorize sorting algorithms. The
3 min read
Know Your Sorting Algorithm | Set 1 (Sorting Weapons used by Programming Languages)
Ever wondered how sort() function we use in C++/Java or sorted() in Python work internally? Here is a list of all the inbuilt sorting algorithms of different programming languages and the algorithm they use internally. C’s qsort() – QuicksortBest Case Time Complexity- O(NlogN)Average Case Time Complexity- O(NlogN)Worse Case Time Complexity- O(N2)Au
2 min read
What is the stupidest sorting algorithm? (Worst Sorting Algorithm)
Bogo sort stands out as the undisputed champion of stupidity. Unlike other sorting algorithms that follow a structured approach, Bogo sort relies on sheer luck and randomness to achieve its goal. How Bogo Sort Works?Bogo sort operates on the following principle: Randomly shuffle the elements in the list.Check if the list is sorted.If the list is no
2 min read
Javascript Program For Sorting A Linked List Of 0s, 1s And 2s
Given a linked list of 0s, 1s and 2s, sort it.Examples: Input: 1 -> 1 -> 2 -> 0 -> 2 -> 0 -> 1 -> NULL Output: 0 -> 0 -> 1 -> 1 -> 1 -> 2 -> 2 -> NULL Input: 1 -> 1 -> 2 -> 1 -> 0 -> NULL  Output: 0 -> 1 -> 1 -> 1 -> 2 -> NULL Source: Microsoft Interview | Set 1 Recommended: Please solve it on "PRACTICE" first, before moving on to the solution. Fol
3 min read
Javascript Program For Sorting A Linked List That Is Sorted Alternating Ascending And Descending Orders
Given a Linked List. The Linked List is in alternating ascending and descending orders. Sort the list efficiently. Example: Input List: 10 -&gt; 40 -&gt; 53 -&gt; 30 -&gt; 67 -&gt; 12 -&gt; 89 -&gt; NULL Output List: 10 -&gt; 12 -&gt; 30 -&gt; 40 -&gt; 53 -&gt; 67 -&gt; 89 -&gt; NULL Input List: 1 -&gt; 4 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; NULL Output L
4 min read
Javascript Program For Sorting A Linked List Of 0s, 1s And 2s By Changing Links
Given a linked list of 0s, 1s and 2s, sort it.Examples: Input: 2->1->2->1->1->2->0->1->0 Output: 0->0->1->1->1->1->2->2->2 The sorted Array is 0, 0, 1, 1, 1, 1, 2, 2, 2. Input: 2->1->0 Output: 0->1->2 The sorted Array is 0, 1, 2Recommended: Please solve it on "PRACTICE" first, before moving on to the solution. Method 1: There is a solution discusse
3 min read
Javascript Program To Find Longest Common Prefix Using Sorting
Problem Statement: Given a set of strings, find the longest common prefix.Examples: Input: {"geeksforgeeks", "geeks", "geek", "geezer"} Output: "gee" Input: {"apple", "ape", "april"} Output: "ap" The longest common prefix for an array of strings is the common prefix between 2 most dissimilar strings. For example, in the given array {"apple", "ape",
2 min read