# Three way partitioning of an array around a given range

• Difficulty Level : Medium
• Last Updated : 20 Feb, 2023

Given an array and a range [lowVal, highVal], partition the array around the range such that array is divided in three parts.

• All elements smaller than lowVal come first.
• All elements in range lowVal to highVal come next.
• All elements greater than highVal appear in the end.

The individual elements of the three sets can appear in any order.

Examples;

Input: arr[] = {1, 14, 5, 20, 4, 2, 54, 20, 87, 98, 3, 1, 32}  , lowVal = 14 , highVal = 20
Output: arr[] = {1, 5, 4, 2, 1, 3, 14, 20, 20, 98, 87, 32, 54}
Explanation: all elements which are less than 14 are present in the range of 0 to 6
all elements which are greater than 14 and less than 20 are present in the range of 7 to 8
all elements which are greater than 20 are present in the range of 9 to 12

Input: arr[] = {1, 14, 5, 20, 4, 2, 54, 20, 87, 98, 3, 1, 32} , lowVal = 20 , highVal = 20
Output: arr[] = {1, 14, 5, 4, 2, 1, 3, 20, 20, 98, 87, 32, 54}

Recommended Practice

## Three-way partitioning of an array using Two Pointer

The idea is based on Dutch National Flag based QuickSort. We traverse the given array of elements from left. We keep track of two pointers, first to store next position of smaller element (smaller than range) from beginning, and second to store next position of greater element from end. while traversing the array use these two pointers to place elements according to their range.

Follow the steps mentioned below to implement the idea:

• Create two variables start and end to store the index of the vacant place to store the elements according to their range.
• Traverse the array from 0 to end.
• If an element is less than lowVal then swap it with the element present at index start and increase the value of start by 1.
• If an element is greater than highVal then swap it with the element present at index end and decrease the value of end by 1.
• Print the array.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement three way partitioning``// around a given range.``#include ``using` `namespace` `std;` `// Partitions arr[0..n-1] around [lowVal..highVal]``void` `threeWayPartition(``int` `arr[], ``int` `n, ``int` `lowVal,``                       ``int` `highVal)``{``    ``// Initialize next available positions for``    ``// smaller (than range) and greater elements``    ``int` `start = 0, end = n - 1;` `    ``// Traverse elements from left``    ``for` `(``int` `i = 0; i <= end;) {``        ``// If current element is smaller than``        ``// range, put it on next available smaller``        ``// position.``        ``if` `(arr[i] < lowVal) {``            ``// if i and start are same in that case we can't``            ``// swap swap only if i is greater than start``            ``if` `(i == start) {``                ``start++;``                ``i++;``            ``}``            ``else``                ``swap(arr[i++], arr[start++]);``        ``}` `        ``// If current element is greater than``        ``// range, put it on next available greater``        ``// position.``        ``else` `if` `(arr[i] > highVal)``            ``swap(arr[i], arr[end--]);` `        ``else``            ``i++;``    ``}``}` `// Driver code``int` `main()``{``    ``int` `arr[]``        ``= { 1, 14, 5, 20, 4, 2, 54, 20, 87, 98, 3, 1, 32 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``threeWayPartition(arr, n, 10, 20);` `    ``cout << ``"Modified array \n"``;``    ``for` `(``int` `i = 0; i < n; i++)``        ``cout << arr[i] << ``" "``;``}`

## Java

 `// Java program to implement three way partitioning``// around a given range.``import` `java.io.*;` `class` `GFG {` `    ``// Partitions arr[0..n-1] around [lowVal..highVal]``    ``public` `static` `void``    ``threeWayPartition(``int``[] arr, ``int` `lowVal, ``int` `highVal)``    ``{` `        ``int` `n = arr.length;` `        ``// Initialize ext available positions for``        ``// smaller (than range) and greater elements``        ``int` `start = ``0``, end = n - ``1``;` `        ``// Traverse elements from left``        ``for` `(``int` `i = ``0``; i <= end;) {` `            ``// If current element is smaller than``            ``// range, put it on next available smaller``            ``// position.` `            ``if` `(arr[i] < lowVal) {` `                ``int` `temp = arr[start];``                ``arr[start] = arr[i];``                ``arr[i] = temp;``                ``start++;``                ``i++;``            ``}` `            ``// If current element is greater than``            ``// range, put it on next available greater``            ``// position.``            ``else` `if` `(arr[i] > highVal) {` `                ``int` `temp = arr[end];``                ``arr[end] = arr[i];``                ``arr[i] = temp;``                ``end--;``            ``}` `            ``else``                ``i++;``        ``}``    ``}` `    ``public` `static` `void` `main(String[] args)``    ``{` `        ``int` `arr[] = { ``1``,  ``14``, ``5``,  ``20``, ``4``, ``2``, ``54``,``                      ``20``, ``87``, ``98``, ``3``,  ``1``, ``32` `};` `        ``threeWayPartition(arr, ``10``, ``20``);` `        ``System.out.println(``"Modified array "``);``        ``for` `(``int` `i = ``0``; i < arr.length; i++) {``            ``System.out.print(arr[i] + ``" "``);``        ``}``    ``}``}` `// This code is contributed by Dheerendra Singh`

## Python3

 `# Python3 program to implement three way``# partitioning around a given range.` `# Partitions arr[0..n-1] around [lowVal..highVal]`  `def` `threeWayPartition(arr, n, lowVal, highVal):` `    ``# Initialize ext available positions for``    ``# smaller (than range) and greater elements``    ``start ``=` `0``    ``end ``=` `n ``-` `1``    ``i ``=` `0` `    ``# Traverse elements from left``    ``while` `i <``=` `end:` `        ``# If current element is smaller than``        ``# range, put it on next available smaller``        ``# position.``        ``if` `arr[i] < lowVal:``              ``arr[i], arr[start] ``=` `arr[start], arr[i]``            ``i ``+``=` `1``            ``start ``+``=` `1` `        ``# If current element is greater than``        ``# range, put it on next available greater``        ``# position.``        ``elif` `arr[i] > highVal:``              ``arr[i], arr[end] ``=` `arr[end], arr[i]``            ``end ``-``=` `1` `        ``else``:``            ``i ``+``=` `1` `# Driver code``if` `__name__ ``=``=` `"__main__"``:``    ``arr ``=` `[``1``, ``14``, ``5``, ``20``, ``4``, ``2``, ``54``,``           ``20``, ``87``, ``98``, ``3``, ``1``, ``32``]``    ``n ``=` `len``(arr)` `    ``threeWayPartition(arr, n, ``10``, ``20``)` `    ``print``(``"Modified array"``)``    ``for` `i ``in` `range``(n):``        ``print``(arr[i], end ``=` `" "``)` `# This code is contributed by``# sanjeev2552`

## C#

 `// C# program to implement three way``// partitioning around a given range.``using` `System;` `class` `GFG {` `    ``// Partitions arr[0..n-1]``    ``// around [lowVal..highVal]``    ``public` `static` `void``    ``threeWayPartition(``int``[] arr, ``int` `lowVal, ``int` `highVal)``    ``{``        ``int` `n = arr.Length;` `        ``// Initialize ext available positions for``        ``// smaller (than range) and greater elements``        ``int` `start = 0, end = n - 1;` `        ``// Traverse elements from left``        ``for` `(``int` `i = 0; i <= end;) {` `            ``// If current element is smaller than``            ``// range, put it on next available smaller``            ``// position.` `            ``if` `(arr[i] < lowVal) {` `                ``int` `temp = arr[start];``                ``arr[start] = arr[i];``                ``arr[i] = temp;``                ``start++;``                ``i++;``            ``}` `            ``// If current element is greater than``            ``// range, put it on next available greater``            ``// position.``            ``else` `if` `(arr[i] > highVal) {` `                ``int` `temp = arr[end];``                ``arr[end] = arr[i];``                ``arr[i] = temp;``                ``end--;``            ``}` `            ``else``                ``i++;``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int``[] arr = { 1,  14, 5,  20, 4, 2, 54,``                      ``20, 87, 98, 3,  1, 32 };` `        ``threeWayPartition(arr, 10, 20);` `        ``Console.WriteLine(``"Modified array "``);``        ``for` `(``int` `i = 0; i < arr.Length; i++) {``            ``Console.Write(arr[i] + ``" "``);``        ``}``    ``}``}` `// This article is contributed by vt_m.`

## Javascript

 ``

Output

```Modified array
1 5 4 2 1 3 14 20 20 98 87 32 54 ```

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up