GFG App
Open App
Browser
Continue

# Three way partitioning of an Array without changing the relative ordering

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

• All elements smaller than lowVal come first.
• All elements in range lowVal to highVal come next.
• All elements greater than highVVal appear in the end.
• The relative ordering of numbers shouldn’t be changed.

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 3 1 14 20 20 54 87 98 32 }

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 3 1 20 20 54 87 98 32 }

Approach: This approach is based on using extra data structures to store the elements lesser than lowVal, in between lowVal and highVal, and elements greater than highVal. We will be using 3 queue for maintaining the original order of elements.

• Traverse the array one by one
• Insert the array elements into the respective queue one by one
• At the end,
• Pop out all the elements in queue 1 with elements lesser than lowVal
• Then Pop out all the elements in queue 2 with elements in between lowVal and highVal
• Then Pop out all the elements in queue 3 with elements greater than highVal.

Below is the implementation of the above approach:

## C++

 `// C++ code to implement three way` `// partitioning of an array without` `// changing the relative ordering`   `#include ` `using` `namespace` `std;`   `// Function to do three way partitioning` `vector<``int``> pivotArray(vector<``int``>& nums, ``int` `lowVal,` `                       ``int` `highVal)` `{` `    ``// Declaring 3 queues` `    ``queue<``int``> before, same, after;`   `    ``// Traverse the array elements one by one` `    ``for` `(``int` `i = 0; i < nums.size(); i++) {`   `        ``// If the element is` `        ``// less than pivot range` `        ``// insert it into queue before` `        ``if` `(nums[i] < lowVal)` `            ``before.push(nums[i]);`   `        ``// Else If the element is` `        ``// in between pivot range` `        ``// insert it into queue same` `        ``else` `if` `(nums[i] > highVal)` `            ``after.push(nums[i]);`   `        ``// Else If the element is` `        ``// less than pivot range` `        ``// insert it into queue after` `        ``else` `            ``same.push(nums[i]);` `    ``}`   `    ``int` `k = 0;` `    ``// Now insert all elements` `    ``// in queue before and` `    ``// insert into final vector` `    ``while` `(before.size() > 0) {` `        ``nums[k++] = before.front();` `        ``before.pop();` `    ``}`   `    ``// Now insert all elements` `    ``// in queue same and` `    ``// insert into final vector` `    ``while` `(same.size() > 0) {` `        ``nums[k++] = same.front();` `        ``same.pop();` `    ``}`   `    ``// Now insert all elements` `    ``// in queue after and` `    ``// insert into final vector` `    ``while` `(after.size() > 0) {` `        ``nums[k++] = after.front();` `        ``after.pop();` `    ``}`   `    ``// Return the final vector` `    ``return` `nums;` `}`   `// Driver code` `int` `main()` `{` `    ``vector<``int``> arr` `        ``= { 1, 14, 5, 20, 4, 2, 54,` `            ``20, 87, 98, 3, 1, 32 };` `    ``int` `lowVal = 20, highVal = 20;`   `    ``pivotArray(arr, lowVal, highVal);` `    ``for` `(``int` `i = 0; i < arr.size(); i++) {` `        ``cout << arr[i] << ``" "``;` `    ``}` `    ``return` `0;` `}`

## Java

 `// JAVA code to implement three way` `// partitioning of an array without` `// changing the relative ordering` `import` `java.util.*;` `class` `GFG {` `    ``// Function to do three way partitioning` `    ``public` `static` `int``[] pivotArray(``int``[] nums, ``int` `lowVal,` `                                   ``int` `highVal)` `    ``{` `        ``// Declaring 3 queues` `        ``Queue before = ``new` `LinkedList<>();` `        ``Queue same = ``new` `LinkedList<>();` `        ``Queue after = ``new` `LinkedList<>();`   `        ``// Traverse the array elements one by one` `        ``for` `(``int` `i = ``0``; i < nums.length; i++) {`   `            ``// If the element is` `            ``// less than pivot range` `            ``// insert it into queue before` `            ``if` `(nums[i] < lowVal)` `                ``before.add(nums[i]);`   `            ``// Else If the element is` `            ``// in between pivot range` `            ``// insert it into queue same` `            ``else` `if` `(nums[i] > highVal)` `                ``after.add(nums[i]);`   `            ``// Else If the element is` `            ``// less than pivot range` `            ``// insert it into queue after` `            ``else` `                ``same.add(nums[i]);` `        ``}`   `        ``int` `k = ``0``;` `        ``// Now insert all elements` `        ``// in queue before and` `        ``// insert into final vector` `        ``while` `(before.size() > ``0``) {` `            ``nums[k++] = before.poll();` `        ``}`   `        ``// Now insert all elements` `        ``// in queue same and` `        ``// insert into final vector` `        ``while` `(same.size() > ``0``) {` `            ``nums[k++] = same.poll();` `        ``}`   `        ``// Now insert all elements` `        ``// in queue after and` `        ``// insert into final vector` `        ``while` `(after.size() > ``0``) {` `            ``nums[k++] = after.poll();` `        ``}`   `        ``// Return the final vector` `        ``return` `nums;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `arr[] = ``new` `int``[] { ``1``,  ``14``, ``5``,  ``20``, ``4``, ``2``, ``54``,` `                                ``20``, ``87``, ``98``, ``3``,  ``1``, ``32` `};` `        ``int` `lowVal = ``20``, highVal = ``20``;`   `        ``pivotArray(arr, lowVal, highVal);` `        ``for` `(``int` `i = ``0``; i < arr.length; i++) {` `            ``System.out.print(arr[i] + ``" "``);` `        ``}` `    ``}` `}`   `// This code is contributed by Taranpreet`

## Python3

 `# Python 3 code to implement three way` `# partitioning of an array without` `# changing the relative ordering`   `# Function to do three way partitioning` `def` `pivotArray(nums,  lowVal,` `               ``highVal):`   `    ``# Declaring 3 queues` `    ``before ``=` `[]` `    ``same ``=` `[]` `    ``after ``=` `[]`   `    ``# Traverse the array elements one by one` `    ``for` `i ``in` `range``(``len``(nums)):`   `        ``# If the element is` `        ``# less than pivot range` `        ``# insert it into queue before` `        ``if` `(nums[i] < lowVal):` `            ``before.append(nums[i])`   `        ``# Else If the element is` `        ``# in between pivot range` `        ``# insert it into queue same` `        ``elif` `(nums[i] > highVal):` `            ``after.append(nums[i])`   `        ``# Else If the element is` `        ``# less than pivot range` `        ``# insert it into queue after` `        ``else``:` `            ``same.append(nums[i])`   `    ``k ``=` `0` `    ``# Now insert all elements` `    ``# in queue before and` `    ``# insert into final vector` `    ``while` `(``len``(before) > ``0``):` `        ``nums[k] ``=` `before[``0``]` `        ``k ``+``=` `1` `        ``before.pop(``0``)`   `    ``# Now insert all elements` `    ``# in queue same and` `    ``# insert into final vector` `    ``while` `(``len``(same) > ``0``):` `        ``nums[k] ``=` `same[``0``]` `        ``same.pop(``0``)` `        ``k ``+``=` `1`   `    ``# Now insert all elements` `    ``# in queue after and` `    ``# insert into final vector` `    ``while` `(``len``(after) > ``0``):` `        ``nums[k] ``=` `after[``0``]` `        ``k ``+``=` `1` `        ``after.pop(``0``)`   `    ``# Return the final vector` `    ``return` `nums`   `# Driver code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``arr ``=` `[``1``, ``14``, ``5``, ``20``, ``4``, ``2``, ``54``,` `           ``20``, ``87``, ``98``, ``3``, ``1``, ``32``]` `    ``lowVal ``=` `20` `    ``highVal ``=` `20`   `    ``pivotArray(arr, lowVal, highVal)` `    ``for` `i ``in` `range``(``len``(arr)):` `        ``print``(arr[i], end``=``" "``)`   `        ``# This code is contributed by ukasp.`

## C#

 `// C# code to implement three way` `using` `System;` `using` `System.Collections;`   `public` `class` `GFG{`   `  ``// partitioning of an array without` `  ``// changing the relative ordering`   `  ``// Function to do three way partitioning` `  ``static` `int``[] pivotArray(``int``[] nums, ``int` `lowVal,` `                          ``int` `highVal)` `  ``{` `    `  `    ``// Declaring 3 queues` `    ``Queue before = ``new` `Queue();` `    ``Queue same = ``new` `Queue();` `    ``Queue after = ``new` `Queue();`   `    ``// Traverse the array elements one by one` `    ``for` `(``int` `i = 0; i < nums.Length; i++) {`   `      ``// If the element is` `      ``// less than pivot range` `      ``// insert it into queue before` `      ``if` `(nums[i] < lowVal)` `        ``before.Enqueue(nums[i]);`   `      ``// Else If the element is` `      ``// in between pivot range` `      ``// insert it into queue same` `      ``else` `if` `(nums[i] > highVal)` `        ``after.Enqueue(nums[i]);`   `      ``// Else If the element is` `      ``// less than pivot range` `      ``// insert it into queue after` `      ``else` `        ``same.Enqueue(nums[i]);` `    ``}`   `    ``int` `k = 0;` `    ``// Now insert all elements` `    ``// in queue before and` `    ``// insert into final vector` `    ``while` `(before.Count > 0) {` `      ``nums[k++] = (``int``)before.Peek();` `      ``before.Dequeue();` `    ``}`   `    ``// Now insert all elements` `    ``// in queue same and` `    ``// insert into final vector` `    ``while` `(same.Count > 0) {` `      ``nums[k++] = (``int``)same.Peek();` `      ``same.Dequeue();` `    ``}`   `    ``// Now insert all elements` `    ``// in queue after and` `    ``// insert into final vector` `    ``while` `(after.Count > 0) {` `      ``nums[k++] = (``int``)after.Peek();` `      ``after.Dequeue();` `    ``}`   `    ``// Return the final vector` `    ``return` `nums;` `  ``}`   `  ``// Driver code` `  ``static` `public` `void` `Main (){`   `    ``int` `[ ] arr` `      ``= { 1, 14, 5, 20, 4, 2, 54,` `         ``20, 87, 98, 3, 1, 32 };` `    ``int` `lowVal = 20, highVal = 20;`   `    ``pivotArray(arr, lowVal, highVal);` `    ``for` `(``int` `i = 0; i < arr.Length; i++) {` `      ``Console.Write(arr[i] + ``" "``);`   `    ``}` `  ``}` `}`   `// This code is contributed by hrithikgarg03188.`

## Javascript

 ``

Output

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

Time Complexity: O(N), where N is the size of the array.
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up