# Segregate Even and Odd numbers | Set 2

• Difficulty Level : Easy
• Last Updated : 11 Nov, 2020

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:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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`
Output
`18 52 70 2 34 37 3 63 `

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

My Personal Notes arrow_drop_up