GFG App
Open App
Browser
Continue

# Segregate Even and Odd numbers | Set 2

Given an array arr[] of size N, the task is to segregate even and odd numbers. Print all even numbers first, and then odd numbers.

Examples:

Input: arr[] = {8, 22, 65, 70, 33, 60, 2, 34, 43, 21}
Output: {8, 22, 70, 60, 2, 34, 65, 33, 43, 21}

Input: arr[] = {18, 52, 37, 70, 3, 63, 2, 34}
Output: {18, 52, 70, 2, 34, 37, 3, 63}

Linear Approach: This problem can be seen as a variation of the Dutch National Flag Problem. Refer to the previous post for all the linear approaches to solve the problem.

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

Approach using stable_partition() Function: The stable_partition() algorithm arranges the sequence defined by start and end such that all elements for which the predicate, specified by user-defined predicate function, returns True, precedes the ones for which the function returns False. The partitioning is stable. Therefore, the relative ordering of the sequence is preserved.

Syntax:

template
BiIter stable_partition(BiIter start, BiIter end, UnPred pfn)

Parameters:

start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines the condition to be satisfied if an element is to be classified.
A predicate takes a single argument and returns True or False
Return Value: Returns an iterator to the beginning of the elements for which the predicate is false.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement` `// the above approach`   `#include ` `using` `namespace` `std;`   `// Function to segregate` `// odd and even numbers` `void` `segregate(vector<``int``> arr)` `{`   `    ``// Using stable partition` `    ``// with lambda expression` `    ``stable_partition(arr.begin(),` `                     ``arr.end(),` `                     ``[](``int` `a) {` `                         ``return` `a % 2 == 0;` `                     ``});`   `    ``// Print array after partition` `    ``for` `(``int` `num : arr)` `        ``cout << num << ``" "``;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given array arr[]` `    ``vector<``int``> arr = { 18, 52, 37, 70,` `                        ``3, 63, 2, 34 };`   `    ``// Function Call` `    ``segregate(arr);`   `    ``return` `0;` `}`

## Java

 `// Java program to implement` `// the above approach` `import` `java.util.*;` `class` `GFG{` `  `  `static` `int``[] stable_partition(``int` `arr[])` `{` `  ``// Initialize left and ` `  ``// right indexes ` `  ``int` `left = ``0``, ` `      ``right = arr.length - ``1``;` `  `  `  ``while` `(left < right)` `  ``{` `    ``// Increment left index while` `    ``// we see 0 at left ` `    ``while` `(arr[left] % ``2` `== ``0` `&& ` `           ``left < right)` `      ``left++;`   `    ``// Decrement right index while` `    ``// we see 1 at right ` `    ``while` `(arr[right] % ``2` `== ``1` `&& ` `           ``left < right)` `      ``right--;`   `    ``if` `(left < right)` `    ``{` `      ``// Swap arr[left] and ` `      ``// arr[right]` `      ``int` `temp = arr[left];` `      ``arr[left] = arr[right];` `      ``arr[right] = temp;` `      ``left++;` `      ``right--;` `    ``}` `  ``}` `  ``return` `arr;` `}`   `// Function to segregate` `// odd and even numbers` `static` `void` `segregate(``int``[] arr)` `{` `  ``// Using stable partition` `  ``// with lambda expression` `  ``int` `[]ans = stable_partition(arr);`   `  ``// Print array after partition` `  ``for` `(``int` `num : ans)` `    ``System.out.print(num + ``" "``);` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `  ``// Given array arr[]` `  ``int``[] arr = {``18``, ``52``, ``37``, ``70``,` `               ``3``, ``63``, ``2``, ``34``};`   `  ``// Function Call` `  ``segregate(arr);` `}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program to implement` `# the above approach`   `# Function to segregate` `# odd and even numbers` `def` `segregate(arr):` `    `  `    ``# Using stable partition` `    ``# with lambda expression` `    ``odd ``=` `[]` `    ``even ``=` `[]` `    `  `    ``for` `x ``in` `arr:` `        ``if` `(x ``%` `2` `=``=` `0``):` `            ``even.append(x)` `        ``else``:` `            ``odd.append(x)` `            `  `    ``for` `x ``in` `even:` `        ``print``(x, end ``=` `" "``)` `    ``for` `x ``in` `odd:` `        ``print``(x, end ``=` `" "``)`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``# Given array arr[]` `    ``arr ``=` `[ ``18``, ``52``, ``37``, ``70``, ``3``, ``63``, ``2``, ``34` `]`   `    ``# Function Call` `    ``segregate(arr)`   `# This code is contributed by SURENDRA_GANGWAR`

## C#

 `// C# program to implement` `// the above approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG{` `  `  `static` `void` `stable_partition(``int` `[]arr)` `{` `  ``// Initialize left and ` `  ``// right indexes ` `  ``List<``int``> odd = ``new` `List<``int``>();` `  ``List<``int``> even = ``new` `List<``int``>();`   `  ``foreach``(``int` `i ``in` `arr)` `  ``{` `    ``if``(i % 2 == 1)` `      ``odd.Add(i);` `    ``else` `      ``even.Add(i);` `  ``}` `  `  `  ``foreach``(``int` `i ``in` `even)` `    ``Console.Write(i +``" "``);` `  `  `  ``foreach``(``int` `i ``in` `odd)` `    ``Console.Write(i +``" "``);` `}`   `// Function to segregate` `// odd and even numbers` `static` `void` `segregate(``int``[] arr)` `{` `  ``// Using stable partition` `  ``// with lambda expression` `  ``stable_partition(arr);`   `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `  ``// Given array []arr` `  ``int``[] arr = {18, 52, 37, 70,` `               ``3, 63, 2, 34};`   `  ``// Function Call` `  ``segregate(arr);` `}` `}`   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

`18 52 70 2 34 37 3 63 `

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

My Personal Notes arrow_drop_up